Bitcoin Cash Specification

Script

Bitcoin Cash transactions make use of a scripting language to authorize and secure transfers. While, colloquially, there is a tendency to refer to transactions as “sending” Bitcoin Cash to “an address”, that is merely an abstraction. In fact, the only thing that permits the spending of existing UTXOs is the successful execution of a script. The only thing preventing the spending of newly created UTXOs is the difficulty of producing a successfully executing script. Through the use of cryptographic signatures and hash functions, such scripts are often designed specifically to be difficult to produce unless you are the intended spender of a given UTXO, though that need not necessarily be the case.

For more information on how Transactions are commonly secured, see Locking Script.

This page will focus on how the scripts are run, what they are capable of, and what limitations they have.

Script Execution

Scripts are executed using a stack-based memory model and have an intentionally restricted set of available operations. Unlike the common general-purpose programming languages your are probably aware of, Script (the term for the language itself) does not allow for loops, persistent state/memory across script executions, or the definition of functions. Instead, scripts are expected to contain whatever data they need and use the available operations to prove transaction validity.

Features

In addition to the primary stack (“the stack”), there is a secondary stack, referred to as the “alt-stack”, which data can be moved to temporarily. Any data left on the alt-stack is lost when a given sub-script finishes execution. In effect, any data moved to the alt-stack by an unlocking script is not present when the locking script runs.

There are a large number of op-codes that support everything from simple stack-manipulation, to mathematical calculations, to complex cryptographic processes. In terms of control structures there are only basic conditional branching (IF/ELSE) operations available.

Transaction Validation

Scripts are run when validating transactions, and successful execution of all of the scripts defined by the transaction is a necessary, but not sufficient, condition for transaction validity. See Transaction Validation for more details.

As a part of validating a transaction, a script is built for each input spent by the transaction. Each script is the sequential execution (carrying over the same stack, but not alt-stack) of the unlocking script provided with the input definition (which is used that the beginning of the script) and the locking script provided by the previous output being referenced. The exception to this is pay to script hash, which has an altered execution workflow. In general, though, this combined unlocking/locking script is then executed and considered successful if and only if the following conditions are met:

Non-Zero Value - after execution the top of the stack must contain a non-zero (TRUE) value.
No Stack Overflows - no operation should attempt to pop a value from the stack when the stack is empty. An overflow of the alt-stack is also disallowed.
Clean Stack - after execution the stack must only contain a single value, which must be non-zero (TRUE). Added in HF-20181115. The alt-stack is exempt from this.

Additionally, in order for the combined script to be valid, the following must be true:

Non-Empty Scripts - both the locking and unlocking scripts must be non-empty.
Max Script Length - the locking and unlocking script, when executed, must each be less than the max script length of 10,000 bytes (for a combined script maximum of 20,000 bytes).
Contained Control Flow - an IF/ELSE block cannot start in the unlocking script and end in the locking script, the script must be in the top-level scope when the locking script execution begins.
Permitted Operations Only - the locking script must not include operations that are disallowed and must not execute operations that are disabled..
Push Only - the unlocking script must contain only push operations (i.e. those with op codes 0x60 or less). Added in HF-20181115.

NOTE: violations of the above rules does not necessarily make a transaction invalid. For example, a locking script may be longer than 10,000 bytes, but it would be unspendable, since the max script length is only checked when the scripts are combined before execution.

Operation codes (opcodes)

The table below lists the currently allocated op codes. Op codes marked with (ignored) are permitted but will do nothing when executed. Op codes marked with (disabled) are permitted in scripts so long as they are not executed. Op codes marked with (do not use) are disallowed and will make a transaction invalid merely be being present.

Constants

Value	Hex	Words	output
0	0x00	OP_0, OP_FALSE	0
0	0x00	An empty array of bytes is pushed onto the stack. See also OP_X
1-75	0x01-0x4b	N/A
1-75	0x01-0x4b	The next value bytes is data to be pushed onto the stack. See also OP_DATA_X
76	0x4c	OP_PUSHDATA1
76	0x4c	The next byte contains the number of bytes to be pushed onto the stack.
77	0x4d	OP_PUSHDATA2
77	0x4d	The next two bytes contain the number of bytes to be pushed onto the stack in little endian order.
78	0x4e	OP_PUSHDATA4
78	0x4e	The next four bytes contain the number of bytes to be pushed onto the stack in little endian order.
79	0x4f	OP_1NEGATE	-1
79	0x4f	The number -1 is pushed onto the stack.
81	0x51	OP_1, OP_TRUE	1
81	0x51	The number 1 is pushed onto the stack.
82-96	0x52-0x60	OP_2-OP_16	2-16
82-96	0x52-0x60	The number (2-16) is pushed onto the stack.

Flow control

Value	Hex	Words	Input	output
97	0x61	OP_NOP
97	0x61	Does nothing.
99	0x63	OP_IF	<expression> IF [statements] [ELSE [statements]] ENDIF
99	0x63	If the top stack value is not False, the statements are executed. The top stack value is removed.
100	0x64	OP_NOTIF	<expression> NOTIF [statements] [ELSE [statements]] ENDIF
100	0x64	If the top stack value is False, the statements are executed. The top stack value is removed.
103	0x67	OP_ELSE	<expression> IF [statements] [ELSE [statements]] ENDIF
103	0x67	If the preceding OP_IF or OP_NOTIF or OP_ELSE was not executed then these statements are and if the preceding OP_IF or OP_NOTIF or OP_ELSE was executed then these statements are not.
104	0x68	OP_ENDIF	<expression> IF [statements] [ELSE [statements]] ENDIF
104	0x68	Ends an if/else block. All blocks must end, or the transaction is marked as invalid. An OP_ENDIF without OP_IF earlier is also invalid.
105	0x69	OP_VERIFY	true / false	Nothing / fail
105	0x69	Marks transaction as invalid if top stack value is not true. The top stack value is removed.
106	0x6a	OP_RETURN		fail
106	0x6a	Marks the output as unspendable. Since Bitcoin Core 0.9, a standard way of attaching extra data to transactions is to add a zero-value output with a scriptPubKey consisting of OP_RETURN followed by data. Such outputs are provably unspendable and specially discarded from storage in the UTXO set, reducing their cost to the network. Current standard relay rules on the Bitcoin Cash network allow a single output with OP_RETURN, that contains any sequence of push statements (or OP_RESERVED) after the OP_RETURN provided the total scriptPubKey length is at most 223 bytes.

Stack

Value	Hex	Words	Input	output
107	0x6b	OP_TOALTSTACK	x1	(alt) x1
107	0x6b	Puts the input onto the top of the alt stack. Removes it from the main stack.
108	0x6c	OP_FROMALTSTACK	(alt) x1	x1
108	0x6c	Puts the input onto the top of the main stack. Removes it from the alt stack.
115	0x73	OP_IFDUP	x	x / x x
115	0x73	If the top stack value is not 0, duplicate it.
116	0x74	OP_DEPTH	Nothing	<stack size>
116	0x74	Puts the number of stack items onto the stack.
117	0x75	OP_DROP	x	Nothing
117	0x75	Removes the top stack item.
118	0x76	OP_DUP	x	x x
118	0x76	Duplicates the top stack item.
119	0x77	OP_NIP	x1 x2	x2
119	0x77	Removes the second-to-top stack item.
120	0x78	OP_OVER	x1 x2	x1 x2 x1
120	0x78	Copies the second-to-top stack item to the top.
121	0x79	OP_PICK	xn ... x2 x1 x0 n	xn ... x2 x1 x0 xn
121	0x79	The item n back in the stack is copied to the top.
122	0x7a	OP_ROLL	xn ... x2 x1 x0 n	x(n-1) ... x2 x1 x0 xn
122	0x7a	The item n back in the stack is moved to the top.
123	0x7b	OP_ROT	x1 x2 x3	x2 x3 x1
123	0x7b	The top three items on the stack are rotated to the left.
124	0x7c	OP_SWAP	x1 x2	x2 x1
124	0x7c	The top two items on the stack are swapped.
125	0x7d	OP_TUCK	x1 x2	x2 x1 x2
125	0x7d	The item at the top of the stack is copied and inserted below the second-to-top item.
109	0x6d	OP_2DROP	x1 x2	Nothing
109	0x6d	Removes the top two stack items.
110	0x6e	OP_2DUP	x1 x2	x1 x2 x1 x2
110	0x6e	Duplicates the top two stack items.
111	0x6f	OP_3DUP	x1 x2 x3	x1 x2 x3 x1 x2 x3
111	0x6f	Duplicates the top three stack items.
112	0x70	OP_2OVER	x1 x2 x3 x4	x1 x2 x3 x4 x1 x2
112	0x70	Copies the pair of items two spaces back in the stack to the front.
113	0x71	OP_2ROT	x1 x2 x3 x4 x5 x6	x3 x4 x5 x6 x1 x2
113	0x71	The fifth and sixth items back are moved to the top of the stack.
114	0x72	OP_2SWAP	x1 x2 x3 x4	x3 x4 x1 x2
114	0x72	Swaps the top two pairs of items.

Splice

Value	Hex	Words	Input	output
126	0x7e	OP_CAT	x1 x2	out
126	0x7e	Concatenates two byte sequences
127	0x7f	OP_SPLIT	x n	x1 x2
127	0x7f	Splits byte sequence x at position n. Known as OP_SUBSTR before 2018-05-15.
128	0x80	OP_NUM2BIN	a b	out
128	0x80	Converts numeric value a into byte sequence of length b. Known as OP_LEFT before 2018-05-15.
129	0x81	OP_BIN2NUM	x	out
129	0x81	Converts byte sequence x into a numeric value. Known as OP_RIGHT before 2018-05-15.
130	0x82	OP_SIZE	x	x size
130	0x82	Pushes the string length of the top element of the stack (without popping it).
188	0xbc	OP_REVERSEBYTES	x	out
188	0xbc	Reverses the order of the bytes in byte sequence x so that the first byte is now its last byte, the second is now its second-to-last, and so forth. Enabled in HF-20200515.

Bitwise logic

Value	Hex	Words	Input	output
131	0x83	OP_INVERT	N/A	N/A
131	0x83	DISABLED
132	0x84	OP_AND	x1 x2	out
132	0x84	Boolean AND between each bit of the inputs
133	0x85	OP_OR	x1 x2	out
133	0x85	Boolean OR between each bit of the inputs.
134	0x86	OP_XOR	x1 x2	out
134	0x86	Boolean EXCLUSIVE OR between each bit of the inputs.
135	0x87	OP_EQUAL	x1 x2	true / false
135	0x87	Returns 1 if the inputs are exactly equal, 0 otherwise.
136	0x88	OP_EQUALVERIFY	x1 x2	Nothing / fail
136	0x88	Same as OP_EQUAL, but runs OP_VERIFY afterward.

Arithmetic

Numeric opcodes (OP_1ADD, etc.) are restricted to operating on 8-byte signed “Script Number” integers, enabled in HF-20220515. This excludes the value -9223372036854775808 that fits in 8-byte two’s complement encoding, but does not fit in an 8-byte Script Number encoding used by the Script VM. If an operation overflows or underflows, the operation must immediately fail evaluation.

Value	Hex	Words	Input	output
139	0x8b	OP_1ADD	in	out
139	0x8b	1 is added to the input.
140	0x8c	OP_1SUB	in	out
140	0x8c	1 is subtracted from the input.
141	0x8d	OP_2MUL	in	out
141	0x8d	The input is multiplied by 2. DISABLED
142	0x8e	OP_2DIV	in	out
142	0x8e	The input is divided by 2. DISABLED
143	0x8f	OP_NEGATE	in	out
143	0x8f	The sign of the input is flipped.
144	0x90	OP_ABS	in	out
144	0x90	The input is made positive.
145	0x91	OP_NOT	in	true / false
145	0x91	If the input is 0 or 1, it is flipped. Otherwise the output will be 0.
146	0x92	OP_0NOTEQUAL	in	true / false
146	0x92	Returns 0 if the input is 0. 1 otherwise.
147	0x93	OP_ADD	a b	out
147	0x93	a is added to b.
148	0x94	OP_SUB	a b	out
148	0x94	b is subtracted from a.
149	0x95	OP_MUL	a b	out
149	0x95	a is multiplied by b. Enabled in HF-20220515.
150	0x96	OP_DIV	a b	out
150	0x96	a is divided by b.
151	0x97	OP_MOD	a b	out
151	0x97	Returns the remainder after a is divided by b.
152	0x98	OP_LSHIFT	a b	out
152	0x98	Shifts a left b bits, preserving sign. DISABLED
153	0x99	OP_RSHIFT	a b	out
153	0x99	Shifts a right b bits, preserving sign. DISABLED
154	0x9a	OP_BOOLAND	a b	true / false
154	0x9a	If both a and b are not 0, the output is 1. Otherwise 0.
155	0x9b	OP_BOOLOR	a b	true / false
155	0x9b	If a or b is not 0, the output is 1. Otherwise 0.
156	0x9c	OP_NUMEQUAL	a b	true / false
156	0x9c	Returns 1 if the numbers are equal, 0 otherwise.
157	0x9d	OP_NUMEQUALVERIFY	a b	Nothing / fail
157	0x9d	Same as OP_NUMEQUAL, but runs OP_VERIFY afterward.
158	0x9e	OP_NUMNOTEQUAL	a b	true / false
158	0x9e	Returns 1 if the numbers are not equal, 0 otherwise.
159	0x9f	OP_LESSTHAN	a b	true / false
159	0x9f	Returns 1 if a is less than b, 0 otherwise.
160	0xa0	OP_GREATERTHAN	a b	true / false
160	0xa0	Returns 1 if a is greater than b, 0 otherwise.
161	0xa1	OP_LESSTHANOREQUAL	a b	true / false
161	0xa1	Returns 1 if a is less than or equal to b, 0 otherwise.
162	0xa2	OP_GREATERTHANOREQUAL	a b	true / false
162	0xa2	Returns 1 if a is greater than or equal to b, 0 otherwise.
163	0xa3	OP_MIN	a b	out
163	0xa3	Returns the smaller of a and b.
164	0xa4	OP_MAX	a b	out
164	0xa4	Returns the larger of a and b.
165	0xa5	OP_WITHIN	x min max	true / false
165	0xa5	Returns 1 if x is within the specified range (left-inclusive), 0 otherwise.

Cryptography

Value	Hex	Words	Input	output
166	0xa6	OP_RIPEMD160	in	hash
166	0xa6	Hashes input with RIPEMD-160.
167	0xa7	OP_SHA1	in	hash
167	0xa7	Hashes input with SHA-1.
168	0xa8	OP_SHA256	in	hash
168	0xa8	Hashes input with SHA-256.
169	0xa9	OP_HASH160	in	hash
169	0xa9	Hashes input with SHA-256 and then with RIPEMD-160.
170	0xaa	OP_HASH256	in	hash
170	0xaa	Hashes input twice with SHA-256.
171	0xab	OP_CODESEPARATOR	Nothing	Nothing
171	0xab	Makes `OP_CHECK(MULTI)SIG(VERIFY)` use the subset of the script of everything after the most recently-executed OP_CODESEPARATOR when computing the sighash.
172	0xac	OP_CHECKSIG	sig pubkey	true / false
172	0xac	The last byte (=sighash type) of the signature is removed. The sighash for this input is calculated based on the sighash type. The truncated signature used by OP_CHECKSIG must be a valid ECDSA or Schnorr signature for this hash and public key. If it is valid, 1 is returned, if it is empty, 0 is returned, otherwise the operation fails.
173	0xad	OP_CHECKSIGVERIFY	sig pubkey	Nothing / fail
173	0xad	Same as OP_CHECKSIG, but OP_VERIFY is executed afterward.
174	0xae	OP_CHECKMULTISIG	dummy sig1 sig2 ... <#-of-sigs> pub1 pub2 ... <#-of-pubkeys>	true / false
174	0xae	Signatures are checked against public keys. Signatures must be placed in the unlocking script using the same order as their corresponding public keys were placed in the locking script or redeem script. If all signatures are valid, 1 is returned, 0 otherwise. All elements are removed from the stack. For more information on the execution of this opcode, see Multisignature.
175	0xaf	OP_CHECKMULTISIGVERIFY	dummy sig1 sig2 ... <#-of-sigs> pub1 pub2 ... <#-of-pubkeys>	Nothing / fail
175	0xaf	Same as OP_CHECKMULTISIG, but OP_VERIFY is executed afterward.
186	0xba	OP_CHECKDATASIG	sig msg pubkey	true / false
186	0xba	Check if signature is valid for message and a public key. See spec
187	0xbb	OP_CHECKDATASIGVERIFY	sig msg pubkey	nothing / fail
187	0xbb	Same as OP_CHECKDATASIG, but runs OP_VERIFY afterward.

Locktime

Value	Hex	Words	Input	output
177	0xb1	OP_CHECKLOCKTIMEVERIFY	x	x / fail
177	0xb1	Marks transaction as invalid if the top stack item is greater than the transaction's nLockTime field, otherwise script evaluation continues as though an OP_NOP was executed. Transaction is also invalid if 1. the stack is empty; or 2. the top stack item is negative; or 3. the top stack item is greater than or equal to 500000000 while the transaction's nLockTime field is less than 500000000, or vice versa; or 4. the input's nSequence field is equal to 0xffffffff. The precise semantics are described in BIP65.
178	0xb2	OP_CHECKSEQUENCEVERIFY	x	x / fail
178	0xb2	Marks transaction as invalid if the relative lock time of the input (enforced by BIP68 with nSequence) is not equal to or longer than the value of the top stack item. The precise semantics are described in BIP112.

Introspection

Value	Hex	Words	Input	output
192	0xc0	OP_INPUTINDEX	Nothing	number
192	0xc0	Push the index of the input being evaluated to the stack as a Script Number.
193	0xc1	OP_ACTIVEBYTECODE	Nothing	script
193	0xc1	Push the bytecode currently being evaluated, beginning after the last executed OP_CODESEPARATOR, to the stack1. For Pay-to-Script-Hash (P2SH) evaluations, this is the redeem bytecode of the Unspent Transaction Output (UTXO) being spent; for all other evaluations, this is the locking bytecode of the UTXO being spent.
194	0xc2	OP_TXVERSION	Nothing	number
194	0xc2	Push the version of the current transaction to the stack as a Script Number.
195	0xc3	OP_TXINPUTCOUNT	Nothing	number
195	0xc3	Push the count of inputs in the current transaction to the stack as a Script Number.
196	0xc4	OP_TXOUTPUTCOUNT	Nothing	number
196	0xc4	Push the count of outputs in the current transaction to the stack as a Script Number.
197	0xc5	OP_TXLOCKTIME	Nothing	number
197	0xc5	Push the locktime of the current transaction to the stack as a Script Number.
198	0xc6	OP_UTXOVALUE	index	number
198	0xc6	Pop the top item from the stack as an input index (Script Number). Push the value (in satoshis) of the Unspent Transaction Output (UTXO) spent by that input to the stack as a Script Number.
199	0xc7	OP_UTXOBYTECODE	index	script
199	0xc7	Pop the top item from the stack as an input index (Script Number). Push the full locking bytecode of the Unspent Transaction Output (UTXO) spent by that input to the stack.
200	0xc8	OP_OUTPOINTTXHASH	index	hash
200	0xc8	Pop the top item from the stack as an input index (Script Number). From that input, push the outpoint transaction hash – the hash of the transaction which created the Unspent Transaction Output (UTXO) which is being spent – to the stack in OP_HASH256 byte order.
201	0xc9	OP_OUTPOINTINDEX	index	number
201	0xc9	Pop the top item from the stack as an input index (Script Number). From that input, push the outpoint index – the index of the output in the transaction which created the Unspent Transaction Output (UTXO) which is being spent – to the stack as a Script Number.
202	0xca	OP_INPUTBYTECODE	index	script
202	0xca	Pop the top item from the stack as an input index (Script Number). Push the unlocking bytecode of the input at that index to the stack.
203	0xcb	OP_INPUTSEQUENCENUMBER	index	number
203	0xcb	Pop the top item from the stack as an input index (Script Number). Push the sequence number of the input at that index to the stack as a Script Number.
204	0xcc	OP_OUTPUTVALUE	index	number
204	0xcc	Pop the top item from the stack as an output index (Script Number). Push the value (in satoshis) of the output at that index to the stack as a Script Number.
205	0xcd	OP_OUTPUTBYTECODE	index	script
205	0xcd	Pop the top item from the stack as an output index (Script Number). Push the locking bytecode of the output at that index to the stack.
Cash-Tokens
206	0xce	OP_UTXOTOKENCATEGORY	index	script
206	0xce	Pop the top item from the stack as an input index (VM Number). If the Unspent Transaction Output (UTXO) spent by that input includes no tokens, push a 0 (VM Number) to the stack. If the UTXO does not include a non-fungible token with a capability, push the UTXO's token category, otherwise, push the concatenation of the token category and capability, where the mutable capability is represented by 1 (VM Number) and the minting capability is represented by 2 (VM Number).
207	0xcf	OP_UTXOTOKENCOMMITMENT	index	script
207	0xcf	Pop the top item from the stack as an input index (VM Number). Push the token commitment of the Unspent Transaction Output (UTXO) spent by that input to the stack. If the UTXO does not include a non-fungible token, or if it includes a non-fungible token with a zero-length commitment, push a 0 (VM Number).
208	0xd0	OP_UTXOTOKENAMOUNT	index	number
208	0xd0	Pop the top item from the stack as an input index (VM Number). Push the fungible token amount of the Unspent Transaction Output (UTXO) spent by that input to the stack as a VM Number. If the UTXO includes no fungible tokens, push a 0 (VM Number).
209	0xd1	OP_OUTPUTTOKENCATEGORY	index	script
209	0xd1	Pop the top item from the stack as an output index (VM Number). If the output at that index includes no tokens, push a 0 (VM Number) to the stack. If the output does not include a non-fungible token with a capability, push the output's token category, otherwise, push the concatenation of the token category and capability, where the mutable capability is represented by 1 (VM Number) and the minting capability is represented by 2 (VM Number).
210	0xd2	OP_OUTPUTTOKENCOMMITMENT	index	script
210	0xd2	Pop the top item from the stack as an output index (VM Number). Push the token commitment of the output at that index to the stack. If the output does not include a non-fungible token, or if it includes a non-fungible token with a zero-length commitment, push a 0 (VM Number).
211	0xd3	OP_OUTPUTTOKENAMOUNT	index	number
211	0xd3	Pop the top item from the stack as an output index (VM Number). Push the fungible token amount of the output at that index to the stack as a VM Number. If the output includes no fungible tokens, push a 0 (VM Number).

Reserved

Word	Value	Hex	Description
OP_NOP1	176	0xb0	Previously reserved for OP_EVAL (BIP12).
OP_NOP4-OP_NOP10	179-185	0b3-0xb9	Ignored. Does not mark transaction as invalid.

Uncategorized

Please help improve this article by categorizing and describing the following op codes.

Hex	Word
0x50	OP_RESERVED (disabled)
0x62	OP_VER (disabled)
0x65	OP_VERIF (do not use)
0x66	OP_VERNOTIF (do not use)
0x89	OP_RESERVED1 (do not use)
0x8A	OP_RESERVED2 (do not use)
0xBD - 0xFF	Unused (disabled)