Struct AccountSigner

pub struct AccountSigner {
    pub account: Account,
    /* private fields */
}

Represents an account signer in the NEO blockchain.

This struct contains information about the account signer, including the signer hash, scopes, allowed contracts, allowed groups, and witness rules.

Fields

account: Account

Implementations

impl AccountSigner

pub fn account(&self) -> &Account

impl AccountSigner

pub fn none(account: &Account) -> Result<Self, TransactionError>

Creates a new AccountSigner with no scope.

Arguments

• account - The account to create the signer for.

pub fn called_by_entry(account: &Account) -> Result<Self, TransactionError>

Creates a new AccountSigner with the “Called By Entry” scope.

Arguments

• account - The account to create the signer for.

pub fn global(account: &Account) -> Result<Self, TransactionError>

Creates a new AccountSigner with the “Global” scope.

Arguments

• account - The account to create the signer for.

pub fn is_multi_sig(&self) -> bool

Checks if the account is a multi-signature account.

pub fn get_script_hash(&self) -> H160

Returns the script hash of the account.

impl AccountSigner

pub fn new(account: &Account, scope: WitnessScope) -> Self

pub fn none_hash160(account_hash: H160) -> Result<Self, TransactionError>

pub fn called_by_entry_hash160( account_hash: H160, ) -> Result<Self, TransactionError>

pub fn global_hash160(account_hash: H160) -> Result<Self, TransactionError>

Trait Implementations

impl Clone for AccountSigner

fn clone(&self) -> AccountSigner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AccountSigner

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AccountSigner

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 Hash for AccountSigner

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 NeoSerializable for AccountSigner

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 AccountSigner

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 AccountSigner

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SignerTrait for AccountSigner

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>