Enum stable_swap_client::instruction::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)

Tuple Fields

0: 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)

Tuple Fields

0: SwapData

Swap the tokens in the pool.

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

Deposit(DepositData)

Tuple Fields

0: 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. [writable] token_a $authority can transfer amount,
3. [writable] token_b $authority can transfer amount,
4. [writable] token_a Base Account to deposit into.
5. [writable] token_b Base Account to deposit into.
6. [writable] Pool MINT account, $authority is the owner.
7. [writable] Pool Account to deposit the generated tokens, user is the owner.
8. [] Token program id
9. [] Clock sysvar

Withdraw(WithdrawData)

Tuple Fields

0: WithdrawData

Withdraw tokens from the pool at the current ratio.

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

WithdrawOne(WithdrawOneData)

Tuple Fields

0: WithdrawOneData

Withdraw one token from the pool at the current ratio.

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

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 Debug for SwapInstruction

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

Formats the value using the given formatter.

impl PartialEq<SwapInstruction> for SwapInstruction

fn eq(&self, other: &SwapInstruction) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &SwapInstruction) -> bool

This method tests for !=.

impl StructuralPartialEq for SwapInstruction