Struct Pubkey

pub struct Pubkey(pub Pubkey);

A public key.

Args: pubkey_bytes (bytes): The pubkey in bytes.

Example: >>> from solders.pubkey import Pubkey >>> pubkey = Pubkey(bytes([1] * 32)) >>> str(pubkey) ‘4vJ9JU1bJJE96FWSJKvHsmmFADCg4gpZQff4P3bkLKi’ >>> bytes(pubkey).hex() ‘0101010101010101010101010101010101010101010101010101010101010101’

Tuple Fields

0: Pubkey

Implementations

impl Pubkey

pub const LENGTH: usize = 32usize

pub fn new(pubkey_bytes: [u8; 32]) -> Self

pub fn new_unique() -> Self

Unique pubkey for tests and benchmarks.

Returns: Pubkey: Randomly generated pubkey.

pub fn new_from_str(s: &str) -> PyResult<Self>

Retrieve a pubkey from a base58 string.

Returns: Pubkey: the pubkey obtained from the base58 string.

Example:

>>> from solders.pubkey import Pubkey
>>> Pubkey.from_string("BPFLoader1111111111111111111111111111111111")
Pubkey(
    BPFLoader1111111111111111111111111111111111,
)

pub fn new_default() -> Self

Create a new default pubkey.

Returns: Pubkey: The default pubkey.

Example: >>> from solders.pubkey import Pubkey >>> Pubkey.default() Pubkey( 11111111111111111111111111111111, )

pub fn create_with_seed( base: &Self, seed: &str, program_id: &Self, ) -> PyResult<Self>

Derive a pubkey from another key, a seed, and a program ID.

Args: base (Pubkey): The other pubkey to use. seed (str): The seed string program_id (Pubkey): The program ID.

Returns: Pubkey: The derived pubkey.

Example: >>> from solders.pubkey import Pubkey >>> default_public_key = Pubkey.default() >>> Pubkey.create_with_seed(default_public_key, “limber chicken: 4/45”, default_public_key) Pubkey( 9h1HyLCW5dZnBVap8C5egQ9Z6pHyjsh5MNy83iPqqRuq, )

pub fn create_program_address(seeds: Vec<&[u8]>, program_id: &Self) -> Self

Derive a program address from seeds and a program ID.

Args: seeds (Sequence[bytes]): The seeds to use. program_id (Pubkey): The program ID.

Returns: Pubkey: The derived program address.

Example:

>>> from solders.pubkey import Pubkey
>>> program_id = Pubkey.from_string("BPFLoader1111111111111111111111111111111111")
>>> Pubkey.create_program_address([b"", bytes([1])], program_id)
Pubkey(
    3gF2KMe9KiC6FNVBmfg9i267aMPvK37FewCip4eGBFcT,
)

pub fn find_program_address(seeds: Vec<&[u8]>, program_id: &Self) -> (Self, u8)

Find a valid program derived address <https://docs.solana.com/developing/programming-model/calling-between-programs#program-derived-addresses>_ and its corresponding bump seed.

Program derived addresses (PDAs) are account keys that only the program, program_id, 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, along with the calculated bump seed, which this function returns as the second tuple element. The runtime will verify that the program associated with this address is the caller and thus authorized to be the signer.

The seeds are application-specific, and must be carefully selected to uniquely derive accounts per application requirements. It is common to use static strings and other pubkeys as seeds.

Because the program address must not lie on the ed25519 curve, there may be seed and program id combinations that are invalid. For this reason, an extra seed (the bump seed) is calculated that results in a point off the curve. The bump seed must be passed as an additional seed when calling invoke_signed.

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 chance 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 each other. For seed schemes that are susceptible to this type of hash collision, a common remedy is to insert separators between seeds, e.g. transforming {“abc”, “def”} into {“abc”, “-”, “def”}.

Args: seeds (Sequence[bytes]): The seeds to use. program_id (Pubkey): The program ID.

Returns: Pubkey: The PDA.

Example:

>>> from solders.pubkey import Pubkey
>>> program_id = Pubkey.from_string("BPFLoader1111111111111111111111111111111111")
>>> program_address, nonce = Pubkey.find_program_address([b""], program_id)
>>> program_address
Pubkey(
    EXWkUCz3YJU9TDVk39ogA4TwoVsUi75ZDhH6yT7acPgQ,
)
>>> nonce
255

pub fn is_on_curve(&self) -> bool

Check that the pubkey is on the ed25519 curve.

Returns: bool: True if the pubkey is on the curve.

pub fn from_bytes(raw: &[u8]) -> PyResult<Self>

Construct from bytes. Equivalent to Pubkey.__init__ but included for the sake of consistency.

Args: raw (bytes): the pubkey bytes.

Returns: Pubkey: a Pubkey object.

pub fn __hash__(&self) -> u64

pub fn __richcmp__(&self, other: &Self, op: CompareOp) -> bool

pub fn __bytes__<'a>(&self, py: Python<'a>) -> &'a PyBytes

pub fn __str__(&self) -> String

pub fn __repr__(&self) -> String

pub fn __reduce__(&self) -> PyResult<(PyObject, PyObject)>

pub fn to_json(&self) -> String

Convert to a JSON string.

pub fn from_json(raw: &str) -> PyResult<Self>

Build from a JSON string.

Trait Implementations

impl AsRef<[u8]> for Pubkey

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

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

impl AsRef<Pubkey> for Pubkey

fn as_ref(&self) -> &PubkeyOriginal

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

impl Clone for Pubkey

fn clone(&self) -> Pubkey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CommonMethods<'_> for Pubkey

fn py_to_json(&self) -> String

fn py_from_json(raw: &'a str) -> Result<Self, PyErr>

impl CommonMethodsCore for Pubkey

fn pybytes<'b>(&self, py: Python<'b>) -> &'b PyBytes

fn pystr(&self) -> String

fn pyrepr(&self) -> String

fn py_from_bytes(raw: &[u8]) -> Result<Self, PyErr>

fn pyreduce(&self) -> Result<(Py<PyAny>, Py<PyAny>), PyErr>

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 From<&Pubkey> for Pubkey

fn from(pubkey: &PubkeyOriginal) -> Self

Converts to this type from the input type.

impl From<&Pubkey> for Pubkey

fn from(pubkey: &Pubkey) -> Self

Converts to this type from the input type.

impl From<Pubkey> for Pubkey

fn from(original: PubkeyOriginal) -> Pubkey

Converts to this type from the input type.

impl From<Pubkey> for Pubkey

fn from(original: Pubkey) -> Self

Converts to this type from the input type.

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.

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 IntoPy<Py<PyAny>> for Pubkey

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

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

fn pybytes_general<'a>(&self, py: Python<'a>) -> &'a PyBytes

impl PyBytesSlice for Pubkey

fn pybytes_slice<'a>(&self, py: Python<'a>) -> &'a PyBytes

impl PyClass for Pubkey

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for Pubkey

const IS_BASETYPE: bool = true

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<Pubkey>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn doc(py: Python<'_>) -> PyResult<&'static CStr>

Rendered class doc

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature<Pubkey> for PyClassImplCollector<Pubkey>

fn new_text_signature(self) -> Option<&'static str>

impl PyFromBytesGeneral for Pubkey

fn py_from_bytes_general(raw: &[u8]) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a Pubkey

type Holder = Option<PyRef<'py, Pubkey>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl<'a, 'py> PyFunctionArgument<'a, 'py> for &'a mut Pubkey

type Holder = Option<PyRefMut<'py, Pubkey>>

fn extract(obj: &'py PyAny, holder: &'a mut Self::Holder) -> PyResult<Self>

impl PyHash for Pubkey

fn pyhash(&self) -> u64

impl PyMethods<Pubkey> for PyClassImplCollector<Pubkey>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for Pubkey

const NAME: &'static str = "Pubkey"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

type AsRefTarget = PyCell<Pubkey>

Utility type to make Py::as_ref work.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl RichcmpFull for Pubkey

fn richcmp(&self, other: &Self, op: CompareOp) -> bool

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

impl Eq for Pubkey

impl StructuralPartialEq for Pubkey