Struct Address 

pub struct Address(/* private fields */);

The address of a Solana account.

Some account addresses are ed25519 public keys, with corresponding secret keys that are managed off-chain. Often, though, account addresses do not have corresponding secret keys — as with program derived addresses — or the secret key is not relevant to the operation of a program, and may have even been disposed of. As running Solana programs can not safely create or manage secret keys, the full Keypair is not defined in solana-program but in solana-sdk.

Implementations

impl Address

pub fn derive_address<const N: usize>( seeds: &[&[u8]; N], bump: Option<u8>, program_id: &Address, ) -> Address

Derive a program address from the given seeds, optional bump and program id.

In general, the derivation uses an optional bump (byte) value to ensure a valid PDA (off-curve) is generated. Even when a program stores a bump to derive a program address, it is necessary to use the [Address::create_program_address] to validate the derivation. In most cases, the program has the correct seeds for the derivation, so it would be sufficient to just perform the derivation and compare it against the expected resulting address.

This function avoids the cost of the create_program_address syscall (1500 compute units) by directly computing the derived address calculating the hash of the seeds, bump and program id using the sol_sha256 syscall.

Important

This function differs from [Address::create_program_address] in that it does not perform a validation to ensure that the derived address is a valid (off-curve) program derived address. It is intended for use in cases where the seeds, bump, and program id are known to be valid, and the caller wants to derive the address without incurring the cost of the create_program_address syscall.

pub const fn derive_address_const<const N: usize>( seeds: &[&[u8]; N], bump: Option<u8>, program_id: &Address, ) -> Address

Derive a program address from the given seeds, optional bump and program id.

In general, the derivation uses an optional bump (byte) value to ensure a valid PDA (off-curve) is generated.

This function is intended for use in const contexts - i.e., the seeds and bump are known at compile time and the program id is also a constant. It avoids the cost of the create_program_address syscall (1500 compute units) by directly computing the derived address using the SHA-256 hash of the seeds, bump and program id.

Important

This function differs from [Address::create_program_address] in that it does not perform a validation to ensure that the derived address is a valid (off-curve) program derived address. It is intended for use in cases where the seeds, bump, and program id are known to be valid, and the caller wants to derive the address without incurring the cost of the create_program_address syscall.

This function is a compile-time constant version of Address::derive_address. It has worse performance than derive_address, so only use this function in const contexts, where all parameters are known at compile-time.

pub fn derive_program_address<const N: usize>( seeds: &[&[u8]; N], program_id: &Address, ) -> Option<(Address, u8)>

Attempt to derive a valid program derived address (PDA) and its corresponding bump seed.

The main difference between this method and Address::derive_address is that this method iterates through all possible bump seed values (starting from 255 and decrementing) until it finds a valid (off-curve) program derived address.

If a valid PDA is found, it returns the PDA and the bump seed used to derive it; otherwise, it returns None.

impl Address

pub const fn new_from_array(address_array: [u8; 32]) -> Address

pub const fn from_str_const(s: &str) -> Address

Decode a string into an Address, usable in a const context

pub fn new_unique() -> Address

Create a unique Address for tests and benchmarks.

pub fn create_with_seed( base: &Address, seed: &str, owner: &Address, ) -> Result<Address, AddressError>

pub const fn to_bytes(&self) -> [u8; 32]

pub const fn as_array(&self) -> &[u8; 32]

Return a reference to the Address’s byte array.

pub fn is_on_curve(&self) -> bool

Checks whether the given address lies on the Ed25519 curve.

On-curve addresses correspond to valid Ed25519 public keys (and therefore can have associated private keys). Off-curve addresses are typically used for program-derived addresses (PDAs).

Trait Implementations

impl AsMut<[u8]> for Address

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[u8]> for Address

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

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 Copy for Address

impl Debug for Address

Available on crate feature decode only.

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

Formats the value using the given formatter.

impl Default for Address

fn default() -> Address

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Address

fn deserialize<__D>( __deserializer: __D, ) -> Result<Address, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

Available on crate feature decode only.

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

Formats the value using the given formatter.

impl Eq for Address

impl From<&Address> for Address

fn from(value: &Address) -> Address

Converts to this type from the input type.

impl From<[u8; 32]> for Address

fn from(from: [u8; 32]) -> Address

Converts to this type from the input type.

impl FromStr for Address

Available on crate feature decode only.

type Err = ParseAddressError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Address, <Address as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Address

Custom impl of Hash for Address.

This allows us to skip hashing the length of the address which is always the same anyway.

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

Equality operator ==.

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

Inequality operator !=.

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 Sanitize for Address

Available on crate feature sanitize only.

fn sanitize(&self) -> Result<(), SanitizeError>

impl<'de, WincodeConfig> SchemaRead<'de, WincodeConfig> for Address

where WincodeConfig: Config,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Dst = Address

fn read( reader: impl Reader<'de>, dst: &mut MaybeUninit<<Address as SchemaRead<'de, WincodeConfig>>::Dst>, ) -> Result<(), ReadError>

Read into dst from reader.

fn get(reader: impl Reader<'de>) -> Result<Self::Dst, ReadError>

Read Self::Dst from reader into a new Self::Dst.

impl<WincodeConfig> SchemaWrite<WincodeConfig> for Address

where WincodeConfig: Config,

const TYPE_META: TypeMeta

Metadata about the type’s serialization.

type Src = Address

fn size_of( src: &<Address as SchemaWrite<WincodeConfig>>::Src, ) -> Result<usize, WriteError>

Get the serialized size of Self::Src.

fn write( writer: impl Writer, src: &<Address as SchemaWrite<WincodeConfig>>::Src, ) -> Result<(), WriteError>

Write Self::Src to writer.

impl Serialize for Address

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 StructuralPartialEq for Address

impl TryFrom<&[u8]> for Address

type Error = TryFromSliceError

The type returned in the event of a conversion error.

fn try_from( address: &[u8], ) -> Result<Address, <Address as TryFrom<&[u8]>>::Error>

Performs the conversion.

impl TryFrom<&str> for Address

Available on crate feature decode only.

type Error = ParseAddressError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Address, <Address as TryFrom<&str>>::Error>

Performs the conversion.

impl<WincodeConfig> ZeroCopy<WincodeConfig> for Address

where WincodeConfig: Config, [u8; 32]: for<'_wincode_internal> ZeroCopy<WincodeConfig>, Assert<solana_address::::_#3::{impl#1}::{constant#1}>: for<'_wincode_internal> IsTrue,

fn from_bytes<'de>(bytes: &'de [u8], config: C) -> Result<&'de Self, ReadError>

where Self: Sized + SchemaRead<'de, C, Dst = Self>,

Like crate::ZeroCopy::from_bytes, but allows the caller to provide a custom configuration.

fn from_bytes_mut<'de>( bytes: &'de mut [u8], config: C, ) -> Result<&'de mut Self, ReadError>

where Self: Sized + SchemaRead<'de, C, Dst = Self>,

Like crate::ZeroCopy::from_bytes_mut, but allows the caller to provide a custom configuration.