Enum SwapInstruction 

#[repr(C)]
pub enum SwapInstruction {
    Initialize(InitializeData),
    Swap(SwapData),
    Deposit(DepositData),
    Withdraw(WithdrawData),
    WithdrawOne(WithdrawOneData),
}

Instructions supported by the SwapInfo program.

Variants

Initialize(InitializeData)

Initializes a new SwapInfo.

0. [writable, signer] New StableSwap to create.
1. [] $authority derived from create_program_address(&[StableSwap account])
2. [] admin Account.
3. [] admin_fee_a admin fee Account for token_a.
4. [] admin_fee_b admin fee Account for token_b.
5. [] token_a Account. Must be non zero, owned by $authority.
6. [] token_b Account. Must be non zero, owned by $authority.
7. [writable] Pool Token Mint. Must be empty, owned by $authority.

Swap(SwapData)

Swap the tokens in the pool.

0. []StableSwap
1. [] $authority
2. [signer] User authority.
3. [writable] token_(A|B) SOURCE Account, amount is transferable by $authority,
4. [writable] token_(A|B) Base Account to swap INTO. Must be the SOURCE token.
5. [writable] token_(A|B) Base Account to swap FROM. Must be the DESTINATION token.
6. [writable] token_(A|B) DESTINATION Account assigned to USER as the owner.
7. [writable] token_(A|B) admin fee Account. Must have same mint as DESTINATION token.
8. [] Token program id

Deposit(DepositData)

Deposit some tokens into the pool. The output is a “pool” token representing ownership into the pool. Inputs are converted to the current ratio.

0. []StableSwap
1. [] $authority
2. [signer] User authority.
3. [writable] token_a $authority can transfer amount,
4. [writable] token_b $authority can transfer amount,
5. [writable] token_a Base Account to deposit into.
6. [writable] token_b Base Account to deposit into.
7. [writable] Pool MINT account, $authority is the owner.
8. [writable] Pool Account to deposit the generated tokens, user is the owner.
9. [] Token program id

Withdraw(WithdrawData)

Withdraw tokens from the pool at the current ratio.

0. []StableSwap
1. [] $authority
2. [signer] User authority.
3. [writable] Pool mint account, $authority is the owner
4. [writable] SOURCE Pool account, amount is transferable by $authority.
5. [writable] token_a Swap Account to withdraw FROM.
6. [writable] token_b Swap Account to withdraw FROM.
7. [writable] token_a user Account to credit.
8. [writable] token_b user Account to credit.
9. [writable] admin_fee_a admin fee Account for token_a.
10. [writable] admin_fee_b admin fee Account for token_b.
11. [] Token program id

WithdrawOne(WithdrawOneData)

Withdraw one token from the pool at the current ratio.

0. []StableSwap
1. [] $authority
2. [signer] User authority.
3. [writable] Pool mint account, $authority is the owner
4. [writable] SOURCE Pool account, amount is transferable by $authority.
5. [writable] token_(A|B) BASE token Swap Account to withdraw FROM.
6. [writable] token_(A|B) QUOTE token Swap Account to exchange to base token.
7. [writable] token_(A|B) BASE token user Account to credit.
8. [writable] token_(A|B) admin fee Account. Must have same mint as BASE token.
9. [] Token program id

Implementations

impl SwapInstruction

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

Unpacks a byte buffer into a SwapInstruction.

pub fn pack(&self) -> Vec<u8>

Packs a SwapInstruction into a byte buffer.

Trait Implementations

impl Clone for SwapInstruction

fn clone(&self) -> SwapInstruction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SwapInstruction

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

Formats the value using the given formatter.

impl PartialEq for SwapInstruction

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

impl StructuralPartialEq for SwapInstruction