Struct solana_program::pubkey::Pubkey

#[repr(transparent)]pub struct Pubkey(_);

Implementations

impl Pubkey

pub fn new(pubkey_vec: &[u8]) -> Self

pub const fn new_from_array(pubkey_array: [u8; 32]) -> Self

pub fn new_rand() -> Self

👎 Deprecated since 1.3.9:

Please use ‘Pubkey::new_unique’ instead

pub fn new_unique() -> Self

unique Pubkey for tests and benchmarks.

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

pub fn create_program_address(
    seeds: &[&[u8]],
    program_id: &Pubkey
) -> Result<Pubkey, PubkeyError>

Create a program address

Program addresses are account keys that only the program has the authority to sign. The address is of the same form as a Solana Pubkey, except they are ensured to not be on the ed25519 curve and thus have no associated private key. When performing cross-program invocations the program can “sign” for the key by calling invoke_signed and passing the same seeds used to generate the address. The runtime will check that indeed the program associated with this address is the caller and thus authorized to be the signer.

Because the program address cannot lie on the ed25519 curve there may be seed and program id combinations that are invalid. In these cases an extra seed (bump seed) can be calculated that results in a point off the curve. Use find_program_address to calculate that bump seed.

Warning: Because of the way the seeds are hashed there is a potential for program address collisions for the same program id. The seeds are hashed sequentially which means that seeds {“abcdef”}, {“abc”, “def”}, and {“ab”, “cd”, “ef”} will all result in the same program address given the same program id. Since the change of collision is local to a given program id the developer of that program must take care to choose seeds that do not collide with themselves.

pub fn find_program_address(
    seeds: &[&[u8]],
    program_id: &Pubkey
) -> (Pubkey, u8)

Find a valid program address and its corresponding bump seed which must be passed as an additional seed when calling invoke_signed.

Panics in the very unlikely event that the additional seed could not be found.

The processes of finding a valid program address is by trial and error, and even though it is deterministic given a set of inputs it can take a variable amount of time to succeed across different inputs. This means that when called from an on-chain program it may incur a variable amount of the program’s compute budget. Programs that are meant to be very performant may not want to use this function because it could take a considerable amount of time. Also, programs that area already at risk of exceeding their compute budget should also call this with care since there is a chance that the program’s budget may be occasionally exceeded.

pub fn try_find_program_address(
    seeds: &[&[u8]],
    program_id: &Pubkey
) -> Option<(Pubkey, u8)>

Find a valid program address and its corresponding bump seed which must be passed as an additional seed when calling invoke_signed.

The processes of finding a valid program address is by trial and error, and even though it is deterministic given a set of inputs it can take a variable amount of time to succeed across different inputs. This means that when called from an on-chain program it may incur a variable amount of the program’s compute budget. Programs that are meant to be very performant may not want to use this function because it could take a considerable amount of time. Also, programs that area already at risk of exceeding their compute budget should also call this with care since there is a chance that the program’s budget may be occasionally exceeded.

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

pub fn log(&self)

Log a Pubkey from a program

Trait Implementations

impl AsRef<[u8]> for Pubkey

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

Performs the conversion.

impl BorshDeserialize for Pubkey

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

pub fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it’s worth handling it as a special case to improve performance. It’s a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl BorshSchema for Pubkey where
    [u8; 32]: BorshSchema, 

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively(
    definitions: &mut HashMap<Declaration, Definition>
)

Recursively, using DFS, add type definitions required for this type. For primitive types this is an empty map. Type definition explains how to serialize/deserialize a type.

pub fn add_definition(
    declaration: String,
    definition: Definition,
    definitions: &mut HashMap<String, Definition, RandomState>
)

Helper method to add a single type definition to the map.

pub fn schema_container() -> BorshSchemaContainer

impl BorshSerialize for Pubkey

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

pub fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it’s worth handling it as a special case to improve performance. It’s a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl Clone for Pubkey

fn clone(&self) -> Pubkey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Pubkey

impl Debug for Pubkey

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

Formats the value using the given formatter.

impl Default for Pubkey

fn default() -> Pubkey

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Pubkey

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

Deserialize this value from the given Serde deserializer.

impl Display for Pubkey

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

Formats the value using the given formatter.

impl Eq for Pubkey

impl FromStr for Pubkey

type Err = ParsePubkeyError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for Pubkey

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

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Pubkey

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Pubkey> for Pubkey

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Pubkey> for Pubkey

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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

impl Sanitize for Pubkey

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

impl Serialize for Pubkey

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Pubkey

impl StructuralPartialEq for Pubkey