Enum TapCode

#[non_exhaustive]
#[repr(u8)]
pub enum TapCode {
    PushBytes0 = 0,
    PushBytes1 = 1,
    PushBytes2 = 2,
    PushBytes3 = 3,
    PushBytes4 = 4,
    PushBytes5 = 5,
    PushBytes6 = 6,
    PushBytes7 = 7,
    PushBytes8 = 8,
    PushBytes9 = 9,
    PushBytes10 = 10,
    PushBytes11 = 11,
    PushBytes12 = 12,
    PushBytes13 = 13,
    PushBytes14 = 14,
    PushBytes15 = 15,
    PushBytes16 = 16,
    PushBytes17 = 17,
    PushBytes18 = 18,
    PushBytes19 = 19,
    PushBytes20 = 20,
    PushBytes21 = 21,
    PushBytes22 = 22,
    PushBytes23 = 23,
    PushBytes24 = 24,
    PushBytes25 = 25,
    PushBytes26 = 26,
    PushBytes27 = 27,
    PushBytes28 = 28,
    PushBytes29 = 29,
    PushBytes30 = 30,
    PushBytes31 = 31,
    PushBytes32 = 32,
    PushBytes33 = 33,
    PushBytes34 = 34,
    PushBytes35 = 35,
    PushBytes36 = 36,
    PushBytes37 = 37,
    PushBytes38 = 38,
    PushBytes39 = 39,
    PushBytes40 = 40,
    PushBytes41 = 41,
    PushBytes42 = 42,
    PushBytes43 = 43,
    PushBytes44 = 44,
    PushBytes45 = 45,
    PushBytes46 = 46,
    PushBytes47 = 47,
    PushBytes48 = 48,
    PushBytes49 = 49,
    PushBytes50 = 50,
    PushBytes51 = 51,
    PushBytes52 = 52,
    PushBytes53 = 53,
    PushBytes54 = 54,
    PushBytes55 = 55,
    PushBytes56 = 56,
    PushBytes57 = 57,
    PushBytes58 = 58,
    PushBytes59 = 59,
    PushBytes60 = 60,
    PushBytes61 = 61,
    PushBytes62 = 62,
    PushBytes63 = 63,
    PushBytes64 = 64,
    PushBytes65 = 65,
    PushBytes66 = 66,
    PushBytes67 = 67,
    PushBytes68 = 68,
    PushBytes69 = 69,
    PushBytes70 = 70,
    PushBytes71 = 71,
    PushBytes72 = 72,
    PushBytes73 = 73,
    PushByte764 = 74,
    PushBytes75 = 75,
    PushData1 = 76,
    PushData2 = 77,
    PushData4 = 78,
    PushNumNeg1 = 79,
    Success80 = 80,
    PushNum1 = 81,
    PushNum2 = 82,
    PushNum3 = 83,
    PushNum4 = 84,
    PushNum5 = 85,
    PushNum6 = 86,
    PushNum7 = 87,
    PushNum8 = 88,
    PushNum9 = 89,
    PushNum10 = 90,
    PushNum11 = 91,
    PushNum12 = 92,
    PushNum13 = 93,
    PushNum14 = 94,
    PushNum15 = 95,
    PushNum16 = 96,
    Nop = 97,
    Success98 = 98,
    If = 99,
    NotIf = 100,
    VerIf = 101,
    VerNotIf = 102,
    Else = 103,
    EndIf = 104,
    Verify = 105,
    Return = 106,
    ToAltStack = 107,
    FromAltStack = 108,
    Drop2 = 109,
    Dup2 = 110,
    Dup3 = 111,
    Over2 = 112,
    Rot2 = 113,
    Swap2 = 114,
    IfDup = 115,
    Depth = 116,
    Drop = 117,
    Dup = 118,
    Nip = 119,
    Over = 120,
    Pick = 121,
    Roll = 122,
    Rot = 123,
    Swap = 124,
    Tuck = 125,
    Success126 = 126,
    Success127 = 127,
    Success128 = 128,
    Success129 = 129,
    Size = 130,
    Success131 = 131,
    Success132 = 132,
    Success133 = 133,
    Success134 = 134,
    Equal = 135,
    EqualVerify = 136,
    Success137 = 137,
    Success138 = 138,
    Add1 = 139,
    Sub1 = 140,
    Success141 = 141,
    Success142 = 142,
    Negate = 143,
    Abs = 144,
    Not = 145,
    NotEqual0 = 146,
    Add = 147,
    Sub = 148,
    Success149 = 149,
    Success150 = 150,
    Success151 = 151,
    Success152 = 152,
    Success153 = 153,
    BoolAnd = 154,
    BoolOr = 155,
    NumEqual = 156,
    NumEqualVerify = 157,
    NumNotEqual = 158,
    LessThan = 159,
    GreaterThan = 160,
    LessThanOrEqual = 161,
    GreaterThanOrEqual = 162,
    Min = 163,
    Max = 164,
    Within = 165,
    Ripemd160 = 166,
    Sha1 = 167,
    Sha256 = 168,
    Hash160 = 169,
    Hash256 = 170,
    CodeSeparator = 171,
    CheckSig = 172,
    CheckSigVerify = 173,
    Nop1 = 176,
    Cltv = 177,
    Csv = 178,
    Nop4 = 179,
    Nop5 = 180,
    Nop6 = 181,
    Nop7 = 182,
    Nop8 = 183,
    Nop9 = 184,
    Nop10 = 185,
    CheckSigAdd = 186,
    InvalidOpCode = 255,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

PushBytes0 = 0

Push an empty array onto the stack.

Also, a synonym for OP_0 and OP_FALSE.

PushBytes1 = 1

Push the next byte as an array onto the stack.

PushBytes2 = 2

Push the next 2 bytes as an array onto the stack.

PushBytes3 = 3

Push the next 3 bytes as an array onto the stack.

PushBytes4 = 4

Push the next 4 bytes as an array onto the stack.

PushBytes5 = 5

Push the next 5 bytes as an array onto the stack.

PushBytes6 = 6

Push the next 6 bytes as an array onto the stack.

PushBytes7 = 7

Push the next 7 bytes as an array onto the stack.

PushBytes8 = 8

Push the next 8 bytes as an array onto the stack.

PushBytes9 = 9

Push the next 9 bytes as an array onto the stack.

PushBytes10 = 10

Push the next 10 bytes as an array onto the stack.

PushBytes11 = 11

Push the next 11 bytes as an array onto the stack.

PushBytes12 = 12

Push the next 12 bytes as an array onto the stack.

PushBytes13 = 13

Push the next 13 bytes as an array onto the stack.

PushBytes14 = 14

Push the next 14 bytes as an array onto the stack.

PushBytes15 = 15

Push the next 15 bytes as an array onto the stack.

PushBytes16 = 16

Push the next 16 bytes as an array onto the stack.

PushBytes17 = 17

Push the next 17 bytes as an array onto the stack.

PushBytes18 = 18

Push the next 18 bytes as an array onto the stack.

PushBytes19 = 19

Push the next 19 bytes as an array onto the stack.

PushBytes20 = 20

Push the next 20 bytes as an array onto the stack.

PushBytes21 = 21

Push the next 21 bytes as an array onto the stack.

PushBytes22 = 22

Push the next 22 bytes as an array onto the stack.

PushBytes23 = 23

Push the next 23 bytes as an array onto the stack.

PushBytes24 = 24

Push the next 24 bytes as an array onto the stack.

PushBytes25 = 25

Push the next 25 bytes as an array onto the stack.

PushBytes26 = 26

Push the next 26 bytes as an array onto the stack.

PushBytes27 = 27

Push the next 27 bytes as an array onto the stack.

PushBytes28 = 28

Push the next 28 bytes as an array onto the stack.

PushBytes29 = 29

Push the next 29 bytes as an array onto the stack.

PushBytes30 = 30

Push the next 30 bytes as an array onto the stack.

PushBytes31 = 31

Push the next 31 byte as an array onto the stack.

PushBytes32 = 32

Push the next 32 bytes as an array onto the stack.

PushBytes33 = 33

Push the next 33 bytes as an array onto the stack.

PushBytes34 = 34

Push the next 34 bytes as an array onto the stack.

PushBytes35 = 35

Push the next 35 bytes as an array onto the stack.

PushBytes36 = 36

Push the next 36 bytes as an array onto the stack.

PushBytes37 = 37

Push the next 37 bytes as an array onto the stack.

PushBytes38 = 38

Push the next 38 bytes as an array onto the stack.

PushBytes39 = 39

Push the next 39 bytes as an array onto the stack.

PushBytes40 = 40

Push the next 40 bytes as an array onto the stack.

PushBytes41 = 41

Push the next 41 bytes as an array onto the stack.

PushBytes42 = 42

Push the next 42 bytes as an array onto the stack.

PushBytes43 = 43

Push the next 43 bytes as an array onto the stack.

PushBytes44 = 44

Push the next 44 bytes as an array onto the stack.

PushBytes45 = 45

Push the next 45 bytes as an array onto the stack.

PushBytes46 = 46

Push the next 46 bytes as an array onto the stack.

PushBytes47 = 47

Push the next 47 bytes as an array onto the stack.

PushBytes48 = 48

Push the next 48 bytes as an array onto the stack.

PushBytes49 = 49

Push the next 49 bytes as an array onto the stack.

PushBytes50 = 50

Push the next 50 bytes as an array onto the stack.

PushBytes51 = 51

Push the next 51 bytes as an array onto the stack.

PushBytes52 = 52

Push the next 52 bytes as an array onto the stack.

PushBytes53 = 53

Push the next 53 bytes as an array onto the stack.

PushBytes54 = 54

Push the next 54 bytes as an array onto the stack.

PushBytes55 = 55

Push the next 55 bytes as an array onto the stack.

PushBytes56 = 56

Push the next 56 bytes as an array onto the stack.

PushBytes57 = 57

Push the next 57 bytes as an array onto the stack.

PushBytes58 = 58

Push the next 58 bytes as an array onto the stack.

PushBytes59 = 59

Push the next 59 bytes as an array onto the stack.

PushBytes60 = 60

Push the next 60 bytes as an array onto the stack.

PushBytes61 = 61

Push the next 61 bytes as an array onto the stack.

PushBytes62 = 62

Push the next 62 bytes as an array onto the stack.

PushBytes63 = 63

Push the next 63 bytes as an array onto the stack.

PushBytes64 = 64

Push the next 64 bytes as an array onto the stack.

PushBytes65 = 65

Push the next 65 bytes as an array onto the stack.

PushBytes66 = 66

Push the next 66 bytes as an array onto the stack.

PushBytes67 = 67

Push the next 67 bytes as an array onto the stack.

PushBytes68 = 68

Push the next 68 bytes as an array onto the stack.

PushBytes69 = 69

Push the next 69 bytes as an array onto the stack.

PushBytes70 = 70

Push the next 70 bytes as an array onto the stack.

PushBytes71 = 71

Push the next 71 bytes as an array onto the stack.

PushBytes72 = 72

Push the next 72 bytes as an array onto the stack.

PushBytes73 = 73

Push the next 73 bytes as an array onto the stack.

PushByte764 = 74

Push the next 74 bytes as an array onto the stack.

PushBytes75 = 75

Push the next 75 bytes as an array onto the stack.

PushData1 = 76

Read the next byte as N; push the next N bytes as an array onto the stack.

PushData2 = 77

Read the next 2 bytes as N; push the next N bytes as an array onto the stack.

PushData4 = 78

Read the next 4 bytes as N; push the next N bytes as an array onto the stack.

PushNumNeg1 = 79

Push the array 0x81 onto the stack.

Success80 = 80

One of OP_SUCCESSx op-codes.

PushNum1 = 81

Push the array 0x01 onto the stack.

Also, a synonym for OP_1 and OP_TRUE.

PushNum2 = 82

Push the array 0x02 onto the stack.

PushNum3 = 83

Push the array 0x03 onto the stack.

PushNum4 = 84

Push the array 0x04 onto the stack.

PushNum5 = 85

Push the array 0x05 onto the stack.

PushNum6 = 86

Push the array 0x06 onto the stack.

PushNum7 = 87

Push the array 0x07 onto the stack.

PushNum8 = 88

Push the array 0x08 onto the stack.

PushNum9 = 89

Push the array 0x09 onto the stack.

PushNum10 = 90

Push the array 0x0A onto the stack.

PushNum11 = 91

Push the array 0x0B onto the stack.

PushNum12 = 92

Push the array 0x0C onto the stack.

PushNum13 = 93

Push the array 0x0D onto the stack.

PushNum14 = 94

Push the array 0x0E onto the stack.

PushNum15 = 95

Push the array 0x0F onto the stack.

PushNum16 = 96

Push the array 0x10 onto the stack.

Nop = 97

Does nothing.

Success98 = 98

One of OP_SUCCESSx op-codes.

If = 99

Pop and execute the next statements if a nonzero element was popped.

NotIf = 100

Pop and execute the next statements if a zero element was popped.

VerIf = 101

Fail the script unconditionally, does not even need to be executed.

VerNotIf = 102

Fail the script unconditionally, does not even need to be executed.

Else = 103

Execute statements if those after the previous OP_IF were not, and vice versa. If there is no previous OP_IF, this acts as an OP_RETURN.

EndIf = 104

Pop and execute the next statements if a zero element was popped.

Verify = 105

If the top value is zero or the stack is empty, fail; otherwise, pop the stack.

Return = 106

Fail the script immediately.

ToAltStack = 107

FromAltStack = 108

Pop one element from the alt stack onto the main stack.

Drop2 = 109

Drops the top two stack items.

Dup2 = 110

Duplicates the top two stack items as AB -> ABAB.

Dup3 = 111

Duplicates the two three stack items as ABC -> ABCABC.

Over2 = 112

Copies the two stack items of items two spaces back to the front, as xxAB -> ABxxAB.

Rot2 = 113

Moves the two stack items four spaces back to the front, as xxxxAB -> ABxxxx.

Swap2 = 114

Swaps the top two pairs, as ABCD -> CDAB.

IfDup = 115

Duplicate the top stack element unless it is zero.

Depth = 116

Push the current number of stack items onto the stack.

Drop = 117

Drops the top stack item.

Dup = 118

Duplicates the top stack item.

Nip = 119

Drops the second-to-top stack item.

Over = 120

Copies the second-to-top stack item, as xA -> AxA.

Pick = 121

Pop the top stack element as N. Copy the Nth stack element to the top.

Roll = 122

Pop the top stack element as N. Move the Nth stack element to the top.

Rot = 123

Rotate the top three stack items, as [top next1 next2] -> [next2 top next1].

Swap = 124

Swap the top two stack items.

Tuck = 125

Copy the top stack item to before the second item, as [top next] -> [top next top].

Success126 = 126

One of OP_SUCCESSx op-codes.

Success127 = 127

One of OP_SUCCESSx op-codes.

Success128 = 128

One of OP_SUCCESSx op-codes.

Success129 = 129

One of OP_SUCCESSx op-codes.

Size = 130

Pushes the length of the top stack item onto the stack.

Success131 = 131

One of OP_SUCCESSx op-codes.

Success132 = 132

One of OP_SUCCESSx op-codes.

Success133 = 133

One of OP_SUCCESSx op-codes.

Success134 = 134

One of OP_SUCCESSx op-codes.

Equal = 135

Pushes 1 if the inputs are exactly equal, 0 otherwise.

EqualVerify = 136

Returns success if the inputs are exactly equal, failure otherwise.

Success137 = 137

One of OP_SUCCESSx op-codes.

Success138 = 138

One of OP_SUCCESSx op-codes.

Add1 = 139

Increment the top stack element in place.

Sub1 = 140

Decrement the top stack element in place.

Success141 = 141

One of OP_SUCCESSx op-codes.

Success142 = 142

One of OP_SUCCESSx op-codes.

Negate = 143

Multiply the top stack item by -1 in place.

Abs = 144

Absolute value the top stack item in place.

Not = 145

Map 0 to 1 and everything else to 0, in place.

NotEqual0 = 146

Map 0 to 0 and everything else to 1, in place.

Add = 147

Pop two stack items and push their sum.

Sub = 148

Pop two stack items and push the second minus the top.

Success149 = 149

One of OP_SUCCESSx op-codes.

Success150 = 150

One of OP_SUCCESSx op-codes.

Success151 = 151

One of OP_SUCCESSx op-codes.

Success152 = 152

One of OP_SUCCESSx op-codes.

Success153 = 153

One of OP_SUCCESSx op-codes.

BoolAnd = 154

Pop the top two stack items and push 1 if both are nonzero, else push 0.

BoolOr = 155

Pop the top two stack items and push 1 if either is nonzero, else push 0.

NumEqual = 156

Pop the top two stack items and push 1 if both are numerically equal, else push 0.

NumEqualVerify = 157

Pop the top two stack items and return success if both are numerically equal, else return failure.

NumNotEqual = 158

Pop the top two stack items and push 0 if both are numerically equal, else push 1.

LessThan = 159

Pop the top two items; push 1 if the second is less than the top, 0 otherwise.

GreaterThan = 160

Pop the top two items; push 1 if the second is greater than the top, 0 otherwise.

LessThanOrEqual = 161

Pop the top two items; push 1 if the second is <= the top, 0 otherwise.

GreaterThanOrEqual = 162

Pop the top two items; push 1 if the second is >= the top, 0 otherwise.

Min = 163

Pop the top two items; push the smaller.

Max = 164

Pop the top two items; push the larger.

Within = 165

Pop the top three items; if the top is >= the second and < the third, push 1, otherwise push 0.

Ripemd160 = 166

Pop the top stack item and push its RIPEMD160 hash.

Sha1 = 167

Pop the top stack item and push its SHA1 hash.

Sha256 = 168

Pop the top stack item and push its SHA256 hash.

Hash160 = 169

Pop the top stack item and push its RIPEMD(SHA256) hash.

Hash256 = 170

Pop the top stack item and push its SHA256(SHA256) hash.

CodeSeparator = 171

Ignore this and everything preceding when deciding what to sign when signature-checking.

CheckSig = 172

https://en.bitcoin.it/wiki/OP_CHECKSIG pushing 1/0 for success/failure.

CheckSigVerify = 173

https://en.bitcoin.it/wiki/OP_CHECKSIG returning success/failure.

Nop1 = 176

Does nothing.

Cltv = 177

https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki

Csv = 178

https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki

Nop4 = 179

Does nothing.

Nop5 = 180

Does nothing.

Nop6 = 181

Does nothing.

Nop7 = 182

Does nothing.

Nop8 = 183

Does nothing.

Nop9 = 184

Does nothing.

Nop10 = 185

Does nothing.

CheckSigAdd = 186

OP_CHECKSIGADD post tapscript.

InvalidOpCode = 255

Synonym for OP_RETURN.

Trait Implementations

impl Clone for TapCode

fn clone(&self) -> TapCode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TapCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TapCode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TapCode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<TapCode> for u8

fn from(value: TapCode) -> u8

Converts to this type from the input type.

impl Hash for TapCode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for TapCode

fn eq(&self, other: &TapCode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TapCode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StrictDecode for TapCode

fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDumb for TapCode

fn strict_dumb() -> Self

impl StrictEncode for TapCode

fn strict_encode<W: TypedWrite>(&self, writer: W) -> Result<W>

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictEnum for TapCode

fn from_variant_name( name: &VariantName, ) -> Result<Self, VariantError<&VariantName>>

fn strict_type_info() -> TypeInfo<Self>

impl StrictSum for TapCode

const ALL_VARIANTS: &'static [(u8, &'static str)]

fn variant_name(&self) -> &'static str

fn strict_check_variants()

fn variant_name_by_tag(tag: u8) -> Option<VariantName>

fn variant_ord(&self) -> u8

impl StrictType for TapCode

const STRICT_LIB_NAME: &'static str = LIB_NAME_BITCOIN

fn strict_name() -> Option<TypeName>

impl TryFrom<u8> for TapCode

type Error = VariantError<u8>

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for TapCode

impl Eq for TapCode

impl StructuralPartialEq for TapCode