Enum AddressOrScriptHash

pub enum AddressOrScriptHash {
    Address(Address),
    ScriptHash(H160),
}

An enum that can represent either a blockchain Address or a ScriptHash, offering flexibility for APIs that can work with either.

Variants

Address(Address)

An address type

ScriptHash(H160)

A bytes type

Implementations

impl AddressOrScriptHash

pub fn address(&self) -> Address

Retrieves the Address representation. If the instance is a ScriptHash, converts it to an Address.

Examples

use primitive_types::H160;
use neo3::neo_types::AddressOrScriptHash;
let script_hash = AddressOrScriptHash::ScriptHash(H160::repeat_byte(0x01));
let address = script_hash.address();
// The address will be a valid Neo address derived from the script hash
assert!(address.starts_with("N"));

pub fn script_hash(&self) -> H160

Retrieves the ScriptHash representation. If the instance is an Address, converts it to a ScriptHash.

Examples

use primitive_types::H160;
use neo3::neo_types::AddressOrScriptHash;
let address = AddressOrScriptHash::Address("NNLi44dJNXtDNSBkofB48aTVYtb1zZrNEs".to_string());
let script_hash = address.script_hash();
// The script hash will be derived from the address
assert!(script_hash != H160::zero());

Trait Implementations

impl Clone for AddressOrScriptHash

fn clone(&self) -> AddressOrScriptHash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AddressOrScriptHash

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

Formats the value using the given formatter.

impl Default for AddressOrScriptHash

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for AddressOrScriptHash

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<String> for AddressOrScriptHash

fn from(s: Address) -> Self

Allows creating an AddressOrScriptHash directly from an Address.

Examples

use neo3::neo_types::AddressOrScriptHash;
let from_address = AddressOrScriptHash::from("myAddress".to_string());
assert!(matches!(from_address, AddressOrScriptHash::Address(_)));

impl From<Vec<u8>> for AddressOrScriptHash

fn from(s: Bytes) -> Self

Allows creating an AddressOrScriptHash from a Bytes array, automatically converting it into a ScriptHash.

Examples

use neo3::neo_types::{AddressOrScriptHash, Bytes};
let bytes: Bytes = vec![0xde, 0xad, 0xbe, 0xef, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10];
let from_bytes = AddressOrScriptHash::from(bytes);
assert!(matches!(from_bytes, AddressOrScriptHash::ScriptHash(_)));

impl Hash for AddressOrScriptHash

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

Implements the Hash trait to allow AddressOrScriptHash instances to be used as keys in hash maps or elements in hash sets.

Examples

use std::collections::HashSet;
use neo3::neo_types::AddressOrScriptHash;
let mut set = HashSet::new();
set.insert(AddressOrScriptHash::Address("myAddress".into()));

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 AddressOrScriptHash

fn eq(&self, other: &AddressOrScriptHash) -> 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 AddressOrScriptHash

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AddressOrScriptHash

impl StructuralPartialEq for AddressOrScriptHash