Struct Pool 

pub struct Pool {

    pub discriminator: [u8; 8],
    pub version: u8,
    pub bump: [u8; 1],
    pub pool_id: [u8; 32],
    pub created_at: i64,
    pub updated_at: i64,
    pub expiry: i64,
    pub owner: Pubkey,
    pub whitelist: Pubkey,
    pub rent_payer: Pubkey,
    pub currency: Currency,
    pub amount: u64,
    pub price_offset: i32,
    pub nfts_held: u32,
    pub stats: PoolStats,
    pub shared_escrow: NullableAddress,
    pub cosigner: NullableAddress,
    pub maker_broker: NullableAddress,
    pub max_taker_sell_count: u32,
    pub config: PoolConfig,
    pub reserved: [u8; 100],
}

Pool is the main state account in the AMM program and represents the AMM pool where trades can happen. Pool accounts are Program Derived Addresses derived from the seeds: "pool", owner, and identifier.

Fields

discriminator: [u8; 8]

version: u8

Pool version, used to control upgrades.

bump: [u8; 1]

Bump seed for the pool PDA.

pool_id: [u8; 32]

Owner-chosen identifier for the pool

created_at: i64

Unix timestamp of the pool creation, in seconds.

updated_at: i64

Unix timestamp of the last time the pool has been updated, in seconds.

expiry: i64

Unix timestamp of when the pool expires, in seconds.

owner: Pubkey

The owner of the pool.

whitelist: Pubkey

The whitelist of the pool, determining which NFTs can be deposited or sold into the pool.

rent_payer: Pubkey

currency: Currency

amount: u64

The amount of currency held in the pool.

price_offset: i32

The difference between the number of buys and sells where a postive number indicates the taker has BOUGHT more NFTs than sold and a negative number indicates the taker has SOLD more NFTs than bought. This is used to calculate the current price of the pool.

nfts_held: u32

The number of NFTs currently held in the pool.

stats: PoolStats

Various stats about the pool, including the number of buys and sells.

shared_escrow: NullableAddress

If an escrow account is present, it means it’s a shared-escrow pool where liquidity is shared with other pools. Default pubkey is interpreted as no value.

cosigner: NullableAddress

An offchain actor that signs off to make sure an offchain condition is met (eg trait present). Default pubkey is interpreted as no value.

maker_broker: NullableAddress

Maker broker fees will be sent to this address if populated. Default pubkey is interpreted as no value.

max_taker_sell_count: u32

Limit how many buys a pool can execute - useful for shared escrow pools, else keeps buying into infinity.

config: PoolConfig

Pool configuration values.

reserved: [u8; 100]

Reserved space for future upgrades.

Implementations

impl Pool

pub const LEN: usize = 447usize

pub const PREFIX: &'static [u8]

Prefix values used to generate a PDA for this account.

Values are positional and appear in the following order:

0. Pool::PREFIX
1. owner (Pubkey)
2. pool_id ([u8; 32])

pub fn create_pda( owner: Pubkey, pool_id: [u8; 32], bump: u8, ) -> Result<Pubkey, PubkeyError>

pub fn find_pda(owner: &Pubkey, pool_id: [u8; 32]) -> (Pubkey, u8)

pub fn from_bytes(data: &[u8]) -> Result<Self, Error>

impl Pool

pub fn shift_price( &self, price_offset: i32, side: TakerSide, ) -> Result<u64, TensorAmmError>

Shifts the price of a pool by a certain offset.

pub fn current_price(&self, side: TakerSide) -> Result<u64, TensorAmmError>

Calculate the price of the pool after shifting it by a certain offset.

pub fn calc_mm_fee(&self, current_price: u64) -> Result<u64, TensorAmmError>

Calculate the fee the MM receives when providing liquidity to a two-sided pool.

Trait Implementations

impl BorshDeserialize for Pool

where [u8; 8]: BorshDeserialize, u8: BorshDeserialize, [u8; 1]: BorshDeserialize, [u8; 32]: BorshDeserialize, i64: BorshDeserialize, Pubkey: BorshDeserialize, Currency: BorshDeserialize, u64: BorshDeserialize, i32: BorshDeserialize, u32: BorshDeserialize, PoolStats: BorshDeserialize, NullableAddress: BorshDeserialize, PoolConfig: BorshDeserialize, [u8; 100]: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Pool

where [u8; 8]: BorshSerialize, u8: BorshSerialize, [u8; 1]: BorshSerialize, [u8; 32]: BorshSerialize, i64: BorshSerialize, Pubkey: BorshSerialize, Currency: BorshSerialize, u64: BorshSerialize, i32: BorshSerialize, u32: BorshSerialize, PoolStats: BorshSerialize, NullableAddress: BorshSerialize, PoolConfig: BorshSerialize, [u8; 100]: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for Pool

fn clone(&self) -> Pool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pool

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

Formats the value using the given formatter.

impl PartialEq for Pool

fn eq(&self, other: &Pool) -> 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<'a> TryFrom<&AccountInfo<'a>> for Pool

type Error = Error

The type returned in the event of a conversion error.

fn try_from(account_info: &AccountInfo<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Pool

impl StructuralPartialEq for Pool