Struct RegisteredAddress 

pub struct RegisteredAddress {
    pub key: Pubkey,
    pub role: AddressRole,
}

Registered address with role information

Fields

key: Pubkey

The address.

role: AddressRole

The address’s function within the program.

Implementations

impl RegisteredAddress

pub fn new(address: Pubkey, role: AddressRole) -> RegisteredAddress

Creates a new registered address with the specified role

Arguments

• address - The public key to register
• role - The role that defines the address’s purpose

Example

use anchor_lang::prelude::*;
use solana_address_book::{RegisteredAddress, AddressRole};

let address = Pubkey::new_unique();
let registered = RegisteredAddress::new(address, AddressRole::Wallet);

pub fn wallet(address: Pubkey) -> RegisteredAddress

Creates a wallet-type registered address

Arguments

• address - The wallet’s public key

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let wallet = Pubkey::new_unique();
let registered = RegisteredAddress::wallet(wallet);

pub fn mint(address: Pubkey) -> RegisteredAddress

Creates a mint-type registered address

Arguments

• address - The mint’s public key

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let mint = Pubkey::new_unique();
let registered = RegisteredAddress::mint(mint);

pub fn ata(address: Pubkey, mint: Pubkey, owner: Pubkey) -> RegisteredAddress

Creates an Associated Token Account (ATA) registered address

Arguments

• address - The ATA’s public key
• mint - The token mint public key
• owner - The owner’s public key

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let ata = Pubkey::new_unique();
let mint = Pubkey::new_unique();
let owner = Pubkey::new_unique();
let registered = RegisteredAddress::ata(ata, mint, owner);

pub fn custom(address: Pubkey, custom_role: &str) -> RegisteredAddress

Creates a custom-role registered address

Arguments

• address - The address’s public key
• custom_role - A custom string describing the address’s role

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let address = Pubkey::new_unique();
let registered = RegisteredAddress::custom(address, "governance");

pub fn program(address: Pubkey) -> RegisteredAddress

Creates a program-type registered address

Arguments

• address - The program’s public key

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let program = Pubkey::new_unique();
let registered = RegisteredAddress::program(program);

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

Creates a PDA registered address by finding the program address

Arguments

• seeds - The seeds used to derive the PDA
• program_id - The program that owns the PDA

Returns

A tuple containing:

• The derived PDA public key
• The bump seed
• The registered address

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let program_id = Pubkey::new_unique();
let user = Pubkey::new_unique();

let (pda_key, bump, registered) = RegisteredAddress::pda(&[b"vault", user.as_ref()], &program_id);

pub fn pda_from_parts( pubkey: Pubkey, seeds: Vec<String>, program_id: Pubkey, bump: u8, ) -> RegisteredAddress

Creates a PDA registered address from existing PDA information

Arguments

• pubkey - The PDA’s public key
• seeds - The string representations of seeds used
• program_id - The program that owns the PDA
• bump - The bump seed

Example

use anchor_lang::prelude::*;
use solana_address_book::RegisteredAddress;

let pda = Pubkey::new_unique();
let program_id = Pubkey::new_unique();
let seeds = vec!["vault".to_string(), "v1".to_string()];

let registered = RegisteredAddress::pda_from_parts(pda, seeds, program_id, 255);

Trait Implementations

impl Clone for RegisteredAddress

fn clone(&self) -> RegisteredAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RegisteredAddress

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

Formats the value using the given formatter.

impl Display for RegisteredAddress

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

Formats the value using the given formatter.

impl Hash for RegisteredAddress

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 PartialEq for RegisteredAddress

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

impl StructuralPartialEq for RegisteredAddress