Struct SwapInfo 

#[repr(C)]
pub struct SwapInfo {

    pub is_initialized: bool,
    pub is_paused: bool,
    pub nonce: u8,
    pub initial_amp_factor: u64,
    pub target_amp_factor: u64,
    pub start_ramp_ts: i64,
    pub stop_ramp_ts: i64,
    pub future_admin_deadline: i64,
    pub future_admin_key: Pubkey,
    pub admin_key: Pubkey,
    pub token_a: SwapTokenInfo,
    pub token_b: SwapTokenInfo,
    pub pool_mint: Pubkey,
    pub fees: Fees,
}

Program states.

Fields

is_initialized: bool

Initialized state

is_paused: bool

Paused state

nonce: u8

Nonce used in program address The program address is created deterministically with the nonce, swap program id, and swap account pubkey. This program address has authority over the swap’s token A account, token B account, and pool token mint.

initial_amp_factor: u64

Initial amplification coefficient (A)

target_amp_factor: u64

Target amplification coefficient (A)

start_ramp_ts: i64

Ramp A start timestamp

stop_ramp_ts: i64

Ramp A stop timestamp

future_admin_deadline: i64

Deadline to transfer admin control to future_admin_key

future_admin_key: Pubkey

Public key of the admin account to be applied

admin_key: Pubkey

Public key of admin account to execute admin instructions

token_a: SwapTokenInfo

Token A

token_b: SwapTokenInfo

Token B

pool_mint: Pubkey

Pool tokens are issued when A or B tokens are deposited. Pool tokens can be withdrawn back to the original A or B token.

fees: Fees

Fees

Trait Implementations

impl Clone for SwapInfo

fn clone(&self) -> SwapInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SwapInfo

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

Formats the value using the given formatter.

impl IsInitialized for SwapInfo

fn is_initialized(&self) -> bool

Is initialized

impl Pack for SwapInfo

const LEN: usize = 395usize

The length, in bytes, of the packed representation

fn get_packed_len() -> usize

Get the packed length

fn unpack(input: &[u8]) -> Result<Self, ProgramError>

where Self: IsInitialized,

Unpack from slice and check if initialized

fn unpack_unchecked(input: &[u8]) -> Result<Self, ProgramError>

Unpack from slice without checking if initialized

fn pack(src: Self, dst: &mut [u8]) -> Result<(), ProgramError>

Pack into slice

impl PartialEq for SwapInfo

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

impl Sealed for SwapInfo

impl StructuralPartialEq for SwapInfo