Struct Pubkey 

#[repr(C)]
pub struct Pubkey(pub [u8; 32]);

A public key used to identify accounts, programs, and other entities in the Arch VM.

The Pubkey is a 32-byte value that uniquely identifies an entity within the Arch system. It can be used as an account identifier, a program ID, or for other identification purposes. The struct provides methods for serialization, creation, and verification of program-derived addresses (PDAs).

Tuple Fields

0: [u8; 32]

Implementations

impl Pubkey

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

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

Serializes the public key to a 32-byte array.

Returns

A 32-byte array containing the public key bytes

pub fn from_slice(data: &[u8]) -> Self

Creates a new Pubkey from a slice of bytes.

If the slice is shorter than 32 bytes, the remaining bytes will be padded with zeros.

Arguments

• data - The byte slice to create the Pubkey from

Returns

A new Pubkey instance

pub const fn system_program() -> Self

Returns the system program’s public key.

Returns

The system program’s Pubkey

pub fn is_system_program(&self) -> bool

Checks if the Pubkey represents the system program.

Returns

true if the Pubkey is the system program’s Pubkey, false otherwise

pub fn new_unique() -> Self

Creates a unique Pubkey for tests and benchmarks.

This method generates a deterministic unique pubkey by incrementing an atomic counter. It is useful for creating distinct keys in test and benchmark environments.

Returns

A new unique Pubkey instance

pub fn log(&self)

Logs the Pubkey to the program log.

This method is used within programs to output the public key to the program’s log, which can be useful for debugging and monitoring program execution.

Safety

This method makes a direct system call and should only be used within a program context.

pub fn is_on_curve(pubkey: &[u8]) -> bool

Checks if a public key represents a point on the secp256k1 curve.

This is used in program address derivation to ensure that derived addresses cannot be used to sign transactions (as they don’t map to valid private keys).

Arguments

• pubkey - The public key bytes to check

Returns

true if the pubkey is on the curve, false otherwise

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

Finds a valid program address and bump seed for the given seeds and program ID.

This method searches for a program-derived address (PDA) by trying different bump seeds until it finds one that produces a valid PDA (one that is not on the curve).

Arguments

• seeds - The seeds to use in the address derivation
• program_id - The program ID to derive the address from

Returns

A tuple containing the derived program address and the bump seed used

Panics

Panics if no valid program address could be found with any bump seed

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

Attempts to find a valid program address and bump seed for the given seeds and program ID.

Similar to find_program_address, but returns None instead of panicking if no valid address can be found.

Arguments

• seeds - The seeds to use in the address derivation
• program_id - The program ID to derive the address from

Returns

An Option containing a tuple of the derived program address and bump seed if found, or None if no valid program address could be derived

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

Creates a program address (PDA) deterministically from a set of seeds and a program ID.

Program addresses are deterministically derived from seeds and a program ID, but unlike normal public keys, they do not lie on the ed25519 curve and thus have no associated private key.

Arguments

• seeds - The seeds to use in the address derivation, maximum of 16 seeds with each seed having a maximum length of 32 bytes
• program_id - The program ID to derive the address from

Returns

The derived program address if successful

Errors

Returns an error if:

• There are more than MAX_SEEDS seeds
• Any seed is longer than MAX_SEED_LEN bytes
• The resulting address would lie on the ed25519 curve (invalid for a PDA)

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

Creates a derived address based on a base public key, string seed and owner program id.

Mirrors the behaviour of Solana’s Pubkey::create_with_seed helper and is required by higher-level crates (e.g. Anchor) when working with SystemProgram instructions such as CreateAccountWithSeed.

The resulting address is simply sha256(base || seed || owner) and can be on-curve – it is not restricted to PDAs.

Arguments

• base – Base public key that must sign any transaction creating the account
• seed – Arbitrary UTF-8 seed text (≤ MAX_SEED_LEN bytes)
• owner – Program id that will own the created account

Errors

• ProgramError::MaxSeedLengthExceeded – if the seed is longer than MAX_SEED_LEN

Trait Implementations

impl AsMut<[u8]> for Pubkey

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

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

impl AsRef<[u8]> for Pubkey

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

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

impl BorshDeserialize for Pubkey

fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>

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.

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

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Pubkey

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

impl Clone for Pubkey

fn clone(&self) -> Pubkey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

TODO: Change this in future according to the correct base implementation

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

Formats the value using the given formatter.

impl From<[u8; 32]> for Pubkey

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

Converts to this type from the input type.

impl FromStr for Pubkey

type Err = &'static str

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.

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 LowerHex for Pubkey

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

Formats the value using the given formatter.

impl Ord for Pubkey

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

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

fn partial_cmp(&self, other: &Pubkey) -> 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 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 Zeroable for Pubkey

fn zeroed() -> Self

Calls zeroed.

impl Copy for Pubkey

impl<'__de> Decode<'__de> for Pubkey

where '__de:,

impl Encode for Pubkey

impl Eq for Pubkey

impl Pod for Pubkey

impl StructuralPartialEq for Pubkey