Enum bp::OpCode

#[non_exhaustive]
#[repr(u8)]
pub enum OpCode {
    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,
    PushData1 = 76,
    PushData2 = 77,
    PushData4 = 78,
    PushNum1 = 81,
    Reserved = 80,
    Return = 106,
    Dup = 118,
    Equal = 135,
    EqualVerify = 136,
    Ripemd160 = 166,
    Sha1 = 167,
    Sha256 = 168,
    Hash160 = 169,
    Hash256 = 170,
    CheckSig = 172,
    CheckSigVerify = 173,
}

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.

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 30 bytes as an array onto the stack.

PushBytes32 = 32

Push the next 32 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.

PushNum1 = 81

Push the array 0x01 onto the stack.

Reserved = 80

Synonym for OP_RETURN.

Return = 106

Fail the script immediately.

Dup = 118

Duplicates the top stack item.

Equal = 135

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

EqualVerify = 136

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

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.

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.

Trait Implementations

impl Clone for OpCode

fn clone(&self) -> OpCode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OpCode

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

Formats the value using the given formatter.

impl Display for OpCode

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

Formats the value using the given formatter.

impl From<OpCode> for u8

fn from(value: OpCode) -> u8

Converts to this type from the input type.

impl Hash for OpCode

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

where __H: Hasher,

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 OpCode

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StrictDecode for OpCode

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

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

impl StrictDumb for OpCode

fn strict_dumb() -> OpCode

impl StrictEncode for OpCode

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

where W: TypedWrite,

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

impl StrictEnum for OpCode

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

fn strict_type_info() -> TypeInfo<Self>

impl StrictSum for OpCode

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 OpCode

const STRICT_LIB_NAME: &'static str = LIB_NAME_BITCOIN

fn strict_name() -> Option<TypeName>

impl TryFrom<u8> for OpCode

type Error = VariantError<u8>

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<OpCode, <OpCode as TryFrom<u8>>::Error>

Performs the conversion.

impl Copy for OpCode

impl Eq for OpCode

impl StructuralPartialEq for OpCode