Struct Address 

pub struct Address { /* private fields */ }

Address is a universal opaque identifier to use in contracts.

Address can be used as an input argument (for example, to identify the payment recipient), as a data key (for example, to store the balance), as the authentication & authorization source (for example, to authorize the token transfer) etc.

See require_auth documentation for more details on using Address for authorization.

Internally, Address may represent a Stellar account or a contract. Contract address may be used to identify the account contracts - special contracts that allow customizing authentication logic and adding custom authorization rules.

In tests Addresses should be generated via Address::generate().

Implementations

impl Address

pub fn require_auth_for_args(&self, args: Vec<Val>)

Ensures that this Address has authorized invocation of the current contract with the provided arguments.

During the on-chain execution the Soroban host will perform the needed authentication (verify the signatures) and ensure the replay prevention. The contracts don’t need to perform this tasks.

The arguments don’t have to match the arguments of the contract invocation. However, it’s considered the best practice to have a well-defined, deterministic and ledger-state-independent mapping between the contract invocation arguments and require_auth arguments. This will allow the contract callers to easily build the required signature payloads and prevent potential authorization failures.

Panics

If the invocation is not authorized.

pub fn require_auth(&self)

Ensures that this Address has authorized invocation of the current contract with all the invocation arguments

This works exactly in the same fashion as require_auth_for_args, but arguments are automatically inferred from the current contract invocation.

This is useful when there is only a single Address that needs to authorize the contract invocation and there are no dynamic arguments that don’t need authorization.

Panics

If the invocation is not authorized.

pub fn from_str(env: &Env, strkey: &str) -> Address

Creates an Address corresponding to the provided Stellar strkey.

The only supported strkey types are account keys (G...) and contract keys (C...). Any other valid or invalid strkey will cause this to panic.

Prefer using the Address directly as input or output argument. Only use this in special cases when addresses need to be shared between different environments (e.g. different chains).

pub fn from_string(strkey: &String) -> Address

Creates an Address corresponding to the provided Stellar strkey.

The only supported strkey types are account keys (G...) and contract keys (C...). Any other valid or invalid strkey will cause this to panic.

Prefer using the Address directly as input or output argument. Only use this in special cases when addresses need to be shared between different environments (e.g. different chains).

pub fn from_string_bytes(strkey: &Bytes) -> Address

Creates an Address corresponding to the provided Stellar strkey bytes.

This behaves exactly in the same fashion as from_strkey, i.e. the bytes should contain exactly the same contents as String would (i.e. base-32 ASCII string).

The only supported strkey types are account keys (G...) and contract keys (C...). Any other valid or invalid strkey will cause this to panic.

Prefer using the Address directly as input or output argument. Only use this in special cases when addresses need to be shared between different environments (e.g. different chains).

pub fn to_string(&self) -> String

pub fn env(&self) -> &Env

pub fn as_val(&self) -> &Val

pub fn to_val(&self) -> Val

pub fn as_object(&self) -> &AddressObject

pub fn to_object(&self) -> AddressObject

Trait Implementations

impl Address for Address

fn generate(env: &Env) -> Address

Generate a new Address.

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl From<&Address> for ScAddress

fn from(v: &Address) -> ScAddress

Converts to this type from the input type.

impl From<&Address> for ScVal

fn from(v: &Address) -> ScVal

Converts to this type from the input type.

impl From<Address> for ScAddress

fn from(v: Address) -> ScAddress

Converts to this type from the input type.

impl From<Address> for ScVal

fn from(v: Address) -> ScVal

Converts to this type from the input type.

impl Ord for Address

fn cmp(&self, other: &Address) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Address

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

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl SorobanArbitrary for Address

type Prototype = ArbitraryAddress

A type that implements Arbitrary and can be converted to this SorobanArbitrary type.

impl TryFromVal<Env, &Address> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Address, ) -> Result<Val, <Val as TryFromVal<Env, &Address>>::Error>

impl TryFromVal<Env, Address> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Address, ) -> Result<Val, <Val as TryFromVal<Env, Address>>::Error>

impl TryFromVal<Env, AddressObject> for Address

type Error = Infallible

fn try_from_val( env: &Env, val: &AddressObject, ) -> Result<Address, <Address as TryFromVal<Env, AddressObject>>::Error>

impl TryFromVal<Env, ArbitraryAddress> for Address

type Error = ConversionError

fn try_from_val( env: &Env, v: &ArbitraryAddress, ) -> Result<Address, <Address as TryFromVal<Env, ArbitraryAddress>>::Error>

impl TryFromVal<Env, ScAddress> for Address

type Error = ConversionError

fn try_from_val( env: &Env, val: &ScAddress, ) -> Result<Address, <Address as TryFromVal<Env, ScAddress>>::Error>

impl TryFromVal<Env, ScVal> for Address

type Error = ConversionError

fn try_from_val( env: &Env, val: &ScVal, ) -> Result<Address, <Address as TryFromVal<Env, ScVal>>::Error>

impl TryFromVal<Env, Val> for Address

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Address, <Address as TryFromVal<Env, Val>>::Error>

impl Eq for Address