Enum Signer

pub enum Signer {
    AccountSigner(AccountSigner),
    ContractSigner(ContractSigner),
    TransactionSigner(TransactionSigner),
}

Represents a signer in the NEO blockchain.

This enum can be either an AccountSigner, ContractSigner, or TransactionSigner.

Variants

AccountSigner(AccountSigner)

ContractSigner(ContractSigner)

TransactionSigner(TransactionSigner)

Implementations

impl Signer

pub fn from_bytes(data: &[u8]) -> Result<Signer, TransactionError>

Creates a Signer from a byte array.

Arguments

• data - The byte array containing the serialized signer data.

Returns

A Result containing the deserialized Signer or a TransactionError.

pub fn get_type(&self) -> SignerType

Returns the type of the signer.

pub fn get_signer_hash(&self) -> &H160

Returns a reference to the signer’s script hash.

pub fn as_account_signer(&self) -> Option<&AccountSigner>

pub fn as_contract_signer(&self) -> Option<&ContractSigner>

pub fn as_transaction_signer(&self) -> Option<&TransactionSigner>

pub fn to_account_signer(self) -> Result<AccountSigner, String>

Safely converts to AccountSigner

pub fn to_contract_signer(self) -> Result<ContractSigner, String>

Safely converts to ContractSigner

Trait Implementations

impl Clone for Signer

fn clone(&self) -> Signer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Signer

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Signer

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AccountSigner> for Signer

fn from(account_signer: AccountSigner) -> Self

Converts to this type from the input type.

impl From<ContractSigner> for Signer

fn from(contract_signer: ContractSigner) -> Self

Converts to this type from the input type.

impl Hash for Signer

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 Into<AccountSigner> for Signer

fn into(self) -> AccountSigner

Converts this type into the (usually inferred) input type.

impl Into<ContractSigner> for &mut Signer

fn into(self) -> ContractSigner

Converts this type into the (usually inferred) input type.

impl Into<ContractSigner> for Signer

fn into(self) -> ContractSigner

Converts this type into the (usually inferred) input type.

impl Into<TransactionSigner> for &Signer

fn into(self) -> TransactionSigner

Converts this type into the (usually inferred) input type.

impl Into<TransactionSigner> for &mut Signer

fn into(self) -> TransactionSigner

Converts this type into the (usually inferred) input type.

impl Into<TransactionSigner> for Signer

fn into(self) -> TransactionSigner

Converts this type into the (usually inferred) input type.

impl NeoSerializable for Signer

type Error = TransactionError

fn size(&self) -> usize

fn encode(&self, writer: &mut Encoder)

fn decode(reader: &mut Decoder<'_>) -> Result<Self, Self::Error>

where Self: Sized,

fn to_array(&self) -> Vec<u8>

impl PartialEq for Signer

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

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

const 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 Signer

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SignerTrait for Signer

fn get_type(&self) -> SignerType

fn get_signer_hash(&self) -> &H160

fn set_signer_hash(&mut self, signer_hash: H160)

fn get_scopes(&self) -> &Vec<WitnessScope>

fn get_scopes_mut(&mut self) -> &mut Vec<WitnessScope>

fn set_scopes(&mut self, scopes: Vec<WitnessScope>)

fn get_allowed_contracts(&self) -> &Vec<H160>

fn get_allowed_contracts_mut(&mut self) -> &mut Vec<H160>

fn get_allowed_groups(&self) -> &Vec<Secp256r1PublicKey>

fn get_allowed_groups_mut(&mut self) -> &mut Vec<Secp256r1PublicKey>

fn get_rules(&self) -> &Vec<WitnessRule>

fn get_rules_mut(&mut self) -> &mut Vec<WitnessRule>

fn set_allowed_contracts( &mut self, contracts: Vec<H160>, ) -> Result<(), BuilderError>

fn set_allowed_groups( &mut self, groups: Vec<Secp256r1PublicKey>, ) -> Result<(), BuilderError>

fn set_rules( &mut self, rules: Vec<WitnessRule>, ) -> Result<&mut Self, BuilderError>

fn check_depth( &self, condition: &WitnessCondition, depth: i8, ) -> Result<(), BuilderError>

fn validate_subitems( &self, count: usize, _name: &str, ) -> Result<(), BuilderError>

impl ValueExtension for Signer

fn to_value(&self) -> Value