From 44fb77ce1747e8bf893ee8770fcf50f832ed6bc4 Mon Sep 17 00:00:00 2001 From: Sushant Chandla Date: Thu, 7 Nov 2024 05:30:08 -0300 Subject: [PATCH] remove gamma git dependency --- Cargo.lock | 124 +- Cargo.toml | 1 - Testing.md | 1 + lib/dex-gamma/Cargo.toml | 3 +- lib/dex-gamma/src/edge.rs | 90 +- lib/dex-gamma/src/gamma_cp.rs | 70 +- lib/dex-gamma/src/gamma_cp_ix_builder.rs | 20 +- lib/gamma/Cargo.toml | 17 + lib/gamma/src/curve/calculator.rs | 134 ++ lib/gamma/src/curve/constant_product.rs | 42 + lib/gamma/src/curve/mod.rs | 5 + lib/gamma/src/fees/dynamic_fee.rs | 218 +++ lib/gamma/src/fees/mod.rs | 21 + lib/gamma/src/fees/static_fees.rs | 21 + lib/gamma/src/gamma.json | 1786 ++++++++++++++++++++++ lib/gamma/src/lib.rs | 39 + lib/gamma/src/utils/math.rs | 28 + lib/gamma/src/utils/mod.rs | 2 + 18 files changed, 2494 insertions(+), 128 deletions(-) create mode 100644 lib/gamma/Cargo.toml create mode 100644 lib/gamma/src/curve/calculator.rs create mode 100644 lib/gamma/src/curve/constant_product.rs create mode 100644 lib/gamma/src/curve/mod.rs create mode 100644 lib/gamma/src/fees/dynamic_fee.rs create mode 100644 lib/gamma/src/fees/mod.rs create mode 100644 lib/gamma/src/fees/static_fees.rs create mode 100644 lib/gamma/src/gamma.json create mode 100644 lib/gamma/src/lib.rs create mode 100644 lib/gamma/src/utils/math.rs create mode 100644 lib/gamma/src/utils/mod.rs diff --git a/Cargo.lock b/Cargo.lock index 8392e1e..ea9e4d5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -123,7 +123,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5f619f1d04f53621925ba8a2e633ba5a6081f2ae14758cbb67f38fd823e0a3e" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "proc-macro2 1.0.86", "quote 1.0.35", "syn 1.0.109", @@ -135,7 +135,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7f2a3e1df4685f18d12a943a9f2a7456305401af21a07c9fe076ef9ecd6e400" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "bs58 0.5.1", "proc-macro2 1.0.86", "quote 1.0.35", @@ -148,7 +148,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9423945cb55627f0b30903288e78baf6f62c6c8ab28fb344b6b25f1ffee3dca7" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "quote 1.0.35", "syn 1.0.109", ] @@ -159,7 +159,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "93ed12720033cc3c3bf3cfa293349c2275cd5ab99936e33dd4bf283aaad3e241" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "quote 1.0.35", "syn 1.0.109", ] @@ -170,7 +170,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eef4dc0371eba2d8c8b54794b0b0eb786a234a559b77593d6f80825b6d2c77a2" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "proc-macro2 1.0.86", "quote 1.0.35", "syn 1.0.109", @@ -182,7 +182,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b18c4f191331e078d4a6a080954d1576241c29c56638783322a18d308ab27e4f" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "quote 1.0.35", "syn 1.0.109", ] @@ -212,7 +212,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5de10d6e9620d3bcea56c56151cad83c5992f50d5960b3a9bebc4a50390ddc3c" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "quote 1.0.35", "syn 1.0.109", ] @@ -223,7 +223,7 @@ version = "0.29.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4e2e5be518ec6053d90a2a7f26843dbee607583c779e6c8395951b9739bdfbe" dependencies = [ - "anchor-syn", + "anchor-syn 0.29.0", "borsh-derive-internal 0.10.3", "proc-macro2 1.0.86", "quote 1.0.35", @@ -241,6 +241,52 @@ dependencies = [ "syn 1.0.109", ] +[[package]] +name = "anchor-gen" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a3b9def91d1f0c23b99be210afea0990f931a1edae439ea30e0da50baeaea8f" +dependencies = [ + "anchor-generate-cpi-crate", + "anchor-generate-cpi-interface", +] + +[[package]] +name = "anchor-generate-cpi-crate" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03e8733d55b8492bde0d6f219c25769786758ff9e5e90a16e6a348f91284af50" +dependencies = [ + "anchor-idl", + "syn 1.0.109", +] + +[[package]] +name = "anchor-generate-cpi-interface" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7092a50cf959ebf53460162cb07e88d4cc8ea7fa8c45292e80503a3186033daf" +dependencies = [ + "anchor-idl", + "darling 0.14.4", + "syn 1.0.109", +] + +[[package]] +name = "anchor-idl" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3de2665dc06ee0bd3c7d08f47f136a3d5b1e34b7ac1bc632c86a812add04d68b" +dependencies = [ + "anchor-syn 0.24.2", + "darling 0.14.4", + "heck 0.4.1", + "proc-macro2 1.0.86", + "quote 1.0.35", + "serde_json", + "syn 1.0.109", +] + [[package]] name = "anchor-lang" version = "0.29.0" @@ -280,6 +326,25 @@ dependencies = [ "spl-token-2022 0.9.0", ] +[[package]] +name = "anchor-syn" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "03549dc2eae0b20beba6333b14520e511822a6321cdb1760f841064a69347316" +dependencies = [ + "anyhow", + "bs58 0.3.1", + "heck 0.3.3", + "proc-macro2 1.0.86", + "proc-macro2-diagnostics", + "quote 1.0.35", + "serde", + "serde_json", + "sha2 0.9.9", + "syn 1.0.109", + "thiserror", +] + [[package]] name = "anchor-syn" version = "0.29.0" @@ -2114,6 +2179,7 @@ name = "dex-gamma" version = "0.1.0" dependencies = [ "anchor-client", + "anchor-gen", "anchor-lang", "anchor-spl", "anyhow", @@ -2901,16 +2967,10 @@ dependencies = [ [[package]] name = "gamma" version = "0.1.0" -source = "git+https://github.com/GooseFX1/gamma-swap/?branch=testing#38fdd63239a3be9ea73a1bddb6813c74672150ef" dependencies = [ + "anchor-gen", "anchor-lang", - "anchor-spl", - "referral", - "solana-security-txt", - "spl-math", - "spl-memo 4.0.0", - "spl-token 4.0.0", - "uint", + "num-traits", ] [[package]] @@ -4574,9 +4634,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.18" +version = "0.2.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" dependencies = [ "autocfg 1.2.0", ] @@ -5275,6 +5335,19 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "proc-macro2-diagnostics" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bf29726d67464d49fa6224a1d07936a8c08bb3fba727c7493f6cf1616fdaada" +dependencies = [ + "proc-macro2 1.0.86", + "quote 1.0.35", + "syn 1.0.109", + "version_check 0.9.4", + "yansi", +] + [[package]] name = "prometheus" version = "0.13.4" @@ -5876,15 +5949,6 @@ dependencies = [ "thiserror", ] -[[package]] -name = "referral" -version = "0.1.0" -source = "git+https://github.com/GooseFX1/gfx-referral.git?branch=make-types-public#3d353a8027bcaca1de6c7062b7e90450030e56ba" -dependencies = [ - "anchor-lang", - "anchor-spl", -] - [[package]] name = "regex" version = "1.10.4" @@ -10525,6 +10589,12 @@ dependencies = [ "rustix", ] +[[package]] +name = "yansi" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" + [[package]] name = "yasna" version = "0.5.2" diff --git a/Cargo.toml b/Cargo.toml index e68d468..55b3e82 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -22,7 +22,6 @@ reqwest = { version = "0.11.27", features = ["json"] } whirlpools-client = { git = "https://github.com/blockworks-foundation/whirlpools-client/", features = ["no-entrypoint"] } openbook-v2 = { git = "https://github.com/openbook-dex/openbook-v2", tag = "v0.2.7", features = ["no-entrypoint", "client"] } raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap/", features = ["no-entrypoint", "client"] } -gamma = { git = "https://github.com/GooseFX1/gamma-swap/", features = ["no-entrypoint", "client"], branch="testing" } stable-swap = { version = "1.8.1", features = ["no-entrypoint", "client"] } stable-swap-client = { version = "1.8.1" } stable-swap-math = { version = "1.8.1" } diff --git a/Testing.md b/Testing.md index b976961..2739db8 100644 --- a/Testing.md +++ b/Testing.md @@ -53,6 +53,7 @@ cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::te cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_orca cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_cropper cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_raydium_cp +cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_gamma cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_raydium cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_openbook_v2 cargo test-sbf --package simulator -- --nocapture cases::test_swap_from_dump::test_quote_match_swap_for_infinity diff --git a/lib/dex-gamma/Cargo.toml b/lib/dex-gamma/Cargo.toml index c5c9541..02679cc 100644 --- a/lib/dex-gamma/Cargo.toml +++ b/lib/dex-gamma/Cargo.toml @@ -15,6 +15,7 @@ solana-logger = "1.17" solana-program = "1.17" solana-program-test = "1.17" anchor-lang = "0.29.0" +anchor-gen = "0.3.1" anchor-client = "0.29.0" anchor-spl = "0.29.0" anyhow = "1.0.86" @@ -29,7 +30,7 @@ serde_derive = "1.0" mango-feeds-connector = { workspace = true } # gamma -gamma = { workspace = true } +gamma = { path="../gamma" } [dev-dependencies] router-test-lib = { path = "../router-test-lib", version = "0.1" } \ No newline at end of file diff --git a/lib/dex-gamma/src/edge.rs b/lib/dex-gamma/src/edge.rs index dd951fb..73c1b3e 100644 --- a/lib/dex-gamma/src/edge.rs +++ b/lib/dex-gamma/src/edge.rs @@ -5,8 +5,8 @@ use anchor_spl::token_2022::spl_token_2022::extension::{ BaseStateWithExtensions, StateWithExtensions, }; use anchor_spl::token_2022::spl_token_2022::state::Mint; -use gamma::curve::{CurveCalculator, TradeDirection}; -use gamma::states::{AmmConfig, ObservationState, PoolState, PoolStatusBitIndex}; +use gamma::curve::CurveCalculator; +use gamma::{AmmConfig, ObservationState, PoolState, PoolStatusBitIndex}; use mango_feeds_connector::chain_data::AccountData; use solana_program::clock::Clock; use solana_program::pubkey::Pubkey; @@ -114,32 +114,24 @@ pub fn swap_base_input( // Calculate the trade amounts - let (trade_direction, total_input_token_amount, total_output_token_amount) = - if input_vault_key == pool_state.token_0_vault - && output_vault_key == pool_state.token_1_vault - { - let (total_input_token_amount, total_output_token_amount) = - vault_amount_without_fee(pool_state, input_vault_amount, output_vault_amount)?; + let (total_input_token_amount, total_output_token_amount) = if input_vault_key + == pool_state.token0_vault + && output_vault_key == pool_state.token1_vault + { + let (total_input_token_amount, total_output_token_amount) = + vault_amount_without_fee(pool_state, input_vault_amount, output_vault_amount)?; - ( - TradeDirection::ZeroForOne, - total_input_token_amount, - total_output_token_amount, - ) - } else if input_vault_key == pool_state.token_1_vault - && output_vault_key == pool_state.token_0_vault - { - let (total_output_token_amount, total_input_token_amount) = - vault_amount_without_fee(pool_state, output_vault_amount, input_vault_amount)?; + (total_input_token_amount, total_output_token_amount) + } else if input_vault_key == pool_state.token1_vault + && output_vault_key == pool_state.token0_vault + { + let (total_output_token_amount, total_input_token_amount) = + vault_amount_without_fee(pool_state, output_vault_amount, input_vault_amount)?; - ( - TradeDirection::OneForZero, - total_input_token_amount, - total_output_token_amount, - ) - } else { - anyhow::bail!("Invalid vault"); - }; + (total_input_token_amount, total_output_token_amount) + } else { + anyhow::bail!("Invalid vault"); + }; let Ok(result) = CurveCalculator::swap_base_input( u128::from(actual_amount_in), @@ -150,7 +142,6 @@ pub fn swap_base_input( amm_config.fund_fee_rate, block_timestamp, &observation_state, - trade_direction, ) else { anyhow::bail!("Can't swap"); }; @@ -210,32 +201,24 @@ pub fn swap_base_output( }; // Calculate the trade amounts - let (trade_direction, total_input_token_amount, total_output_token_amount) = - if input_vault_key == pool_state.token_0_vault - && output_vault_key == pool_state.token_1_vault - { - let (total_input_token_amount, total_output_token_amount) = - vault_amount_without_fee(pool_state, input_vault_amount, output_vault_amount)?; + let (total_input_token_amount, total_output_token_amount) = if input_vault_key + == pool_state.token0_vault + && output_vault_key == pool_state.token1_vault + { + let (total_input_token_amount, total_output_token_amount) = + vault_amount_without_fee(pool_state, input_vault_amount, output_vault_amount)?; - ( - TradeDirection::ZeroForOne, - total_input_token_amount, - total_output_token_amount, - ) - } else if input_vault_key == pool_state.token_1_vault - && output_vault_key == pool_state.token_0_vault - { - let (total_output_token_amount, total_input_token_amount) = - vault_amount_without_fee(pool_state, output_vault_amount, input_vault_amount)?; + (total_input_token_amount, total_output_token_amount) + } else if input_vault_key == pool_state.token1_vault + && output_vault_key == pool_state.token0_vault + { + let (total_output_token_amount, total_input_token_amount) = + vault_amount_without_fee(pool_state, output_vault_amount, input_vault_amount)?; - ( - TradeDirection::OneForZero, - total_input_token_amount, - total_output_token_amount, - ) - } else { - anyhow::bail!("Invalid vault"); - }; + (total_input_token_amount, total_output_token_amount) + } else { + anyhow::bail!("Invalid vault"); + }; if total_output_token_amount < output_amount { anyhow::bail!("Vault does not contain enough tokens"); @@ -250,7 +233,6 @@ pub fn swap_base_output( amm_config.fund_fee_rate, block_timestamp, observation_state, - trade_direction, ) else { anyhow::bail!("Can't swap"); }; @@ -292,10 +274,10 @@ pub fn vault_amount_without_fee( ) -> anyhow::Result<(u64, u64)> { Ok(( vault_0 - .checked_sub(pool.protocol_fees_token_0 + pool.fund_fees_token_0) + .checked_sub(pool.protocol_fees_token0 + pool.fund_fees_token0) .ok_or(anyhow::format_err!("invalid sub"))?, vault_1 - .checked_sub(pool.protocol_fees_token_1 + pool.fund_fees_token_1) + .checked_sub(pool.protocol_fees_token1 + pool.fund_fees_token1) .ok_or(anyhow::format_err!("invalid sub"))?, )) } diff --git a/lib/dex-gamma/src/gamma_cp.rs b/lib/dex-gamma/src/gamma_cp.rs index 2acad64..ccf8bdd 100644 --- a/lib/dex-gamma/src/gamma_cp.rs +++ b/lib/dex-gamma/src/gamma_cp.rs @@ -7,7 +7,7 @@ use anchor_spl::token_2022::spl_token_2022; use anyhow::Context; use async_trait::async_trait; use gamma::program::Gamma; -use gamma::states::{AmmConfig, ObservationState, PoolState, PoolStatusBitIndex}; +use gamma::{AmmConfig, ObservationState, PoolState, PoolStatusBitIndex}; use itertools::Itertools; use router_feed_lib::router_rpc_client::{RouterRpcClient, RouterRpcClientTrait}; use router_lib::dex::{ @@ -50,7 +50,7 @@ impl DexInterface for GammaCpDex { let vaults = pools .iter() - .flat_map(|x| [x.1.token_0_vault, x.1.token_1_vault]) + .flat_map(|x| [x.1.token0_vault, x.1.token1_vault]) .collect::>(); let vaults = rpc.get_multiple_accounts(&vaults).await?; let banned_vaults = vaults @@ -66,12 +66,12 @@ impl DexInterface for GammaCpDex { let pools = pools .iter() .filter(|(_pool_pk, pool)| { - pool.token_0_program == Token::id() && pool.token_1_program == Token::id() + pool.token0_program == Token::id() && pool.token1_program == Token::id() // TODO Remove filter when 2022 are working }) .filter(|(_pool_pk, pool)| { - !banned_vaults.contains(&pool.token_0_vault) - && !banned_vaults.contains(&pool.token_1_vault) + !banned_vaults.contains(&pool.token0_vault) + && !banned_vaults.contains(&pool.token1_vault) }) .collect_vec(); @@ -81,14 +81,14 @@ impl DexInterface for GammaCpDex { ( Arc::new(GammaEdgeIdentifier { pool: *pool_pk, - mint_a: pool.token_0_mint, - mint_b: pool.token_1_mint, + mint_a: pool.token0_mint, + mint_b: pool.token1_mint, is_a_to_b: true, }), Arc::new(GammaEdgeIdentifier { pool: *pool_pk, - mint_a: pool.token_1_mint, - mint_b: pool.token_0_mint, + mint_a: pool.token1_mint, + mint_b: pool.token0_mint, is_a_to_b: false, }), ) @@ -108,15 +108,15 @@ impl DexInterface for GammaCpDex { utils::insert_or_extend(&mut map, pool_pk, &entry); utils::insert_or_extend(&mut map, &pool.amm_config, &entry); - utils::insert_or_extend(&mut map, &pool.token_0_vault, &entry); - utils::insert_or_extend(&mut map, &pool.token_1_vault, &entry); + utils::insert_or_extend(&mut map, &pool.token0_vault, &entry); + utils::insert_or_extend(&mut map, &pool.token1_vault, &entry); needed_accounts.insert(*pool_pk); needed_accounts.insert(pool.amm_config); - needed_accounts.insert(pool.token_0_vault); - needed_accounts.insert(pool.token_1_vault); - needed_accounts.insert(pool.token_0_mint); - needed_accounts.insert(pool.token_1_mint); + needed_accounts.insert(pool.token0_vault); + needed_accounts.insert(pool.token1_vault); + needed_accounts.insert(pool.token0_mint); + needed_accounts.insert(pool.token1_mint); } map }; @@ -162,14 +162,14 @@ impl DexInterface for GammaCpDex { let config_account = chain_data.account(&pool.amm_config)?; let config = AmmConfig::try_deserialize(&mut config_account.account.data())?; - let vault_0_account = chain_data.account(&pool.token_0_vault)?; + let vault_0_account = chain_data.account(&pool.token0_vault)?; let vault_0 = spl_token_2022::state::Account::unpack(vault_0_account.account.data())?; - let vault_1_account = chain_data.account(&pool.token_1_vault)?; + let vault_1_account = chain_data.account(&pool.token1_vault)?; let vault_1 = spl_token_2022::state::Account::unpack(vault_1_account.account.data())?; - let mint_0_account = chain_data.account(&pool.token_0_mint)?; - let mint_1_account = chain_data.account(&pool.token_1_mint)?; + let mint_0_account = chain_data.account(&pool.token0_mint)?; + let mint_1_account = chain_data.account(&pool.token1_mint)?; let transfer_0_fee = crate::edge::get_transfer_config(&mint_0_account)?; let transfer_1_fee = crate::edge::get_transfer_config(&mint_1_account)?; @@ -203,7 +203,7 @@ impl DexInterface for GammaCpDex { in_amount: 0, out_amount: 0, fee_amount: 0, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, }); } @@ -214,7 +214,7 @@ impl DexInterface for GammaCpDex { in_amount: 0, out_amount: 0, fee_amount: 0, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, }); } @@ -223,10 +223,10 @@ impl DexInterface for GammaCpDex { &edge.pool, &edge.config, &edge.observation_state, - edge.pool.token_0_vault, + edge.pool.token0_vault, edge.vault_0_amount, &edge.mint_0, - edge.pool.token_1_vault, + edge.pool.token1_vault, edge.vault_1_amount, &edge.mint_1, in_amount, @@ -237,17 +237,17 @@ impl DexInterface for GammaCpDex { in_amount: result.0, out_amount: result.1, fee_amount: result.2, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, } } else { let result = swap_base_input( &edge.pool, &edge.config, &edge.observation_state, - edge.pool.token_1_vault, + edge.pool.token1_vault, edge.vault_1_amount, &edge.mint_1, - edge.pool.token_0_vault, + edge.pool.token0_vault, edge.vault_0_amount, &edge.mint_0, in_amount, @@ -258,7 +258,7 @@ impl DexInterface for GammaCpDex { in_amount: result.0, out_amount: result.1, fee_amount: result.2, - fee_mint: edge.pool.token_1_mint, + fee_mint: edge.pool.token1_mint, } }; Ok(quote) @@ -303,7 +303,7 @@ impl DexInterface for GammaCpDex { in_amount: u64::MAX, out_amount: 0, fee_amount: 0, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, }); } @@ -314,7 +314,7 @@ impl DexInterface for GammaCpDex { in_amount: u64::MAX, out_amount: 0, fee_amount: 0, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, }); } @@ -323,10 +323,10 @@ impl DexInterface for GammaCpDex { &edge.pool, &edge.config, &edge.observation_state, - edge.pool.token_0_vault, + edge.pool.token0_vault, edge.vault_0_amount, &edge.mint_0, - edge.pool.token_1_vault, + edge.pool.token1_vault, edge.vault_1_amount, &edge.mint_1, out_amount, @@ -337,17 +337,17 @@ impl DexInterface for GammaCpDex { in_amount: result.0, out_amount: result.1, fee_amount: result.2, - fee_mint: edge.pool.token_0_mint, + fee_mint: edge.pool.token0_mint, } } else { let result = swap_base_output( &edge.pool, &edge.config, &edge.observation_state, - edge.pool.token_1_vault, + edge.pool.token1_vault, edge.vault_1_amount, &edge.mint_1, - edge.pool.token_0_vault, + edge.pool.token0_vault, edge.vault_0_amount, &edge.mint_0, out_amount, @@ -358,7 +358,7 @@ impl DexInterface for GammaCpDex { in_amount: result.0, out_amount: result.1, fee_amount: result.2, - fee_mint: edge.pool.token_1_mint, + fee_mint: edge.pool.token1_mint, } }; Ok(quote) diff --git a/lib/dex-gamma/src/gamma_cp_ix_builder.rs b/lib/dex-gamma/src/gamma_cp_ix_builder.rs index 0b53f86..1e08c17 100644 --- a/lib/dex-gamma/src/gamma_cp_ix_builder.rs +++ b/lib/dex-gamma/src/gamma_cp_ix_builder.rs @@ -2,7 +2,7 @@ use crate::edge::GammaEdgeIdentifier; use anchor_lang::{AccountDeserialize, Id, InstructionData, ToAccountMetas}; use anchor_spl::associated_token::get_associated_token_address; use gamma::program::Gamma; -use gamma::states::PoolState; +use gamma::PoolState; use gamma::AUTH_SEED; use router_lib::dex::{AccountProviderView, SwapInstruction}; use solana_program::instruction::Instruction; @@ -25,19 +25,19 @@ pub fn build_swap_ix( ((out_amount as f64 * (10_000f64 - max_slippage_bps as f64)) / 10_000f64).floor() as u64; let (input_token_mint, output_token_mint) = if id.is_a_to_b { - (pool.token_0_mint, pool.token_1_mint) + (pool.token0_mint, pool.token1_mint) } else { - (pool.token_1_mint, pool.token_0_mint) + (pool.token1_mint, pool.token0_mint) }; let (input_token_program, output_token_program) = if id.is_a_to_b { - (pool.token_0_program, pool.token_1_program) + (pool.token0_program, pool.token1_program) } else { - (pool.token_1_program, pool.token_0_program) + (pool.token1_program, pool.token0_program) }; let (input_vault, output_vault) = if id.is_a_to_b { - (pool.token_0_vault, pool.token_1_vault) + (pool.token0_vault, pool.token1_vault) } else { - (pool.token_1_vault, pool.token_0_vault) + (pool.token1_vault, pool.token0_vault) }; let (input_token_account, output_token_account) = ( @@ -46,12 +46,12 @@ pub fn build_swap_ix( ); let instruction = gamma::instruction::SwapBaseInput { - amount_in: amount, - minimum_amount_out: other_amount_threshold, + _amount_in: amount, + _minimum_amount_out: other_amount_threshold, }; let (authority, __bump) = Pubkey::find_program_address(&[AUTH_SEED.as_bytes()], &Gamma::id()); - let accounts = gamma::accounts::Swap { + let accounts = gamma::accounts::SwapBaseInput { payer: *wallet_pk, authority, amm_config: pool.amm_config, diff --git a/lib/gamma/Cargo.toml b/lib/gamma/Cargo.toml new file mode 100644 index 0000000..3496eb7 --- /dev/null +++ b/lib/gamma/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "gamma" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib", "lib"] +name = "gamma" + +[features] +no-entrypoint = [] +cpi = ["no-entrypoint"] + +[dependencies] +anchor-lang = "0.29.0" +anchor-gen = "0.3.1" +num-traits = "0.2.19" \ No newline at end of file diff --git a/lib/gamma/src/curve/calculator.rs b/lib/gamma/src/curve/calculator.rs new file mode 100644 index 0000000..26636e3 --- /dev/null +++ b/lib/gamma/src/curve/calculator.rs @@ -0,0 +1,134 @@ +use crate::fees::{DynamicFee, FeeType}; +use crate::GammaError; +use crate::ObservationState; +use crate::{curve::constant_product::ConstantProductCurve, fees::StaticFee}; +use anchor_lang::prelude::*; +use std::fmt::Debug; + +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum TradeDirection { + ZeroForOne, + OneForZero, +} + +impl TradeDirection { + pub fn opposite(&self) -> TradeDirection { + match self { + TradeDirection::ZeroForOne => TradeDirection::OneForZero, + TradeDirection::OneForZero => TradeDirection::ZeroForOne, + } + } +} + +#[derive(Debug, PartialEq)] +pub struct SwapResult { + pub new_swap_source_amount: u128, + pub new_swap_destination_amount: u128, + pub source_amount_swapped: u128, + pub destination_amount_swapped: u128, + pub dynamic_fee: u128, + pub protocol_fee: u128, + pub fund_fee: u128, +} + +/// Concrete struct to wrap around the trait object which performs calculation. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct CurveCalculator {} + +impl CurveCalculator { + pub fn swap_base_input( + source_amount_to_be_swapped: u128, + swap_source_amount: u128, + swap_destination_amount: u128, + trade_fee_rate: u64, + protocol_fee_rate: u64, + fund_fee_rate: u64, + block_timestamp: u64, + observation_state: &ObservationState, + // TODO: add fee type here once that is configurable on pool level/ or we can use it from pool_state + ) -> Result { + let dynamic_fee = DynamicFee::dynamic_fee( + source_amount_to_be_swapped, + block_timestamp, + observation_state, + FeeType::Volatility, + trade_fee_rate, + )?; + + let protocol_fee = StaticFee::protocol_fee(dynamic_fee, protocol_fee_rate) + .ok_or(GammaError::InvalidFee)?; + let fund_fee = + StaticFee::fund_fee(dynamic_fee, fund_fee_rate).ok_or(GammaError::InvalidFee)?; + + let source_amount_after_fees = source_amount_to_be_swapped + .checked_sub(dynamic_fee) + .ok_or(GammaError::MathOverflow)?; + let destination_amount_swapped = ConstantProductCurve::swap_base_input_without_fees( + source_amount_after_fees, + swap_source_amount, + swap_destination_amount, + )?; + + Ok(SwapResult { + new_swap_source_amount: swap_source_amount + .checked_add(source_amount_to_be_swapped) + .ok_or(GammaError::MathOverflow)?, + new_swap_destination_amount: swap_destination_amount + .checked_sub(destination_amount_swapped) + .ok_or(GammaError::MathOverflow)?, + source_amount_swapped: source_amount_to_be_swapped, + destination_amount_swapped, + dynamic_fee, + protocol_fee, + fund_fee, + }) + } + + /// Subtract fees and calculate how much source token will be required + pub fn swap_base_output( + destination_amount_to_be_swapped: u128, + swap_source_amount: u128, + swap_destination_amount: u128, + trade_fee_rate: u64, + protocol_fee_rate: u64, + fund_fee_rate: u64, + block_timestamp: u64, + observation_state: &ObservationState, + ) -> Result { + let source_amount_swapped = ConstantProductCurve::swap_base_output_without_fees( + destination_amount_to_be_swapped, + swap_source_amount, + swap_destination_amount, + )?; + + let source_amount = DynamicFee::calculate_pre_fee_amount( + block_timestamp, + source_amount_swapped, + observation_state, + FeeType::Volatility, + trade_fee_rate, + )?; + + let dynamic_fee = source_amount + .checked_sub(source_amount_swapped) + .ok_or(GammaError::MathOverflow)?; + let protocol_fee = StaticFee::protocol_fee(dynamic_fee, protocol_fee_rate) + .ok_or(GammaError::MathOverflow)?; + let fund_fee = + StaticFee::fund_fee(dynamic_fee, fund_fee_rate).ok_or(GammaError::MathOverflow)?; + + Ok(SwapResult { + new_swap_source_amount: swap_source_amount + .checked_add(source_amount) + .ok_or(GammaError::MathOverflow)?, + new_swap_destination_amount: swap_destination_amount + .checked_sub(destination_amount_to_be_swapped) + .ok_or(GammaError::MathOverflow)?, + source_amount_swapped: source_amount, + destination_amount_swapped: destination_amount_to_be_swapped, + protocol_fee, + fund_fee, + dynamic_fee, + }) + } +} diff --git a/lib/gamma/src/curve/constant_product.rs b/lib/gamma/src/curve/constant_product.rs new file mode 100644 index 0000000..400aa9d --- /dev/null +++ b/lib/gamma/src/curve/constant_product.rs @@ -0,0 +1,42 @@ +use crate::utils::math::CheckedCeilDiv; +use crate::GammaError; +use anchor_lang::prelude::*; + +#[derive(Clone, Debug, Default, PartialEq)] +pub struct ConstantProductCurve; + +impl ConstantProductCurve { + pub fn swap_base_input_without_fees( + source_amount_to_be_swapped: u128, + swap_source_amount: u128, + swap_destination_amount: u128, + ) -> Result { + let numerator = source_amount_to_be_swapped + .checked_mul(swap_destination_amount) + .ok_or(GammaError::MathOverflow)?; + let denominator = swap_source_amount + .checked_add(source_amount_to_be_swapped) + .ok_or(GammaError::MathOverflow)?; + let destination_amount_swapped = numerator + .checked_div(denominator) + .ok_or(GammaError::MathOverflow)?; + Ok(destination_amount_swapped) + } + + pub fn swap_base_output_without_fees( + destination_amount_to_be_swapped: u128, + swap_source_amount: u128, + swap_destination_amount: u128, + ) -> Result { + let numerator = swap_source_amount + .checked_mul(destination_amount_to_be_swapped) + .ok_or(GammaError::MathOverflow)?; + let denominator = swap_destination_amount + .checked_sub(destination_amount_to_be_swapped) + .ok_or(GammaError::MathOverflow)?; + let (source_amount_swapped, _) = numerator + .checked_ceil_div(denominator) + .ok_or(GammaError::MathOverflow)?; + Ok(source_amount_swapped) + } +} diff --git a/lib/gamma/src/curve/mod.rs b/lib/gamma/src/curve/mod.rs new file mode 100644 index 0000000..56b3c5b --- /dev/null +++ b/lib/gamma/src/curve/mod.rs @@ -0,0 +1,5 @@ +pub mod calculator; +pub mod constant_product; + +pub use calculator::*; +pub use constant_product::*; diff --git a/lib/gamma/src/fees/dynamic_fee.rs b/lib/gamma/src/fees/dynamic_fee.rs new file mode 100644 index 0000000..b83719b --- /dev/null +++ b/lib/gamma/src/fees/dynamic_fee.rs @@ -0,0 +1,218 @@ +use super::{ceil_div, FEE_RATE_DENOMINATOR_VALUE}; +use crate::GammaError; +use crate::{Observation, ObservationState}; +use anchor_lang::prelude::*; + +use num_traits::cast::ToPrimitive; +use num_traits::identities::Zero; + +pub const OBSERVATION_NUM: usize = 100; + +pub const MAX_FEE_VOLATILITY: u64 = 10000; // 1% max fee +pub const VOLATILITY_WINDOW: u64 = 3600; // 1 hour window for volatility calculation + +const MAX_FEE: u64 = 100000; // 10% max fee +const VOLATILITY_FACTOR: u64 = 300_000; // Adjust based on desired sensitivity + +pub enum FeeType { + Volatility, +} + +struct ObservationWithIndex { + observation: Observation, + index: u16, +} + +pub struct DynamicFee {} + +impl DynamicFee { + pub fn dynamic_fee( + amount: u128, + block_timestamp: u64, + observation_state: &ObservationState, + fee_type: FeeType, + base_fees: u64, + ) -> Result { + let dynamic_fee_rate = + Self::calculate_dynamic_fee(block_timestamp, observation_state, fee_type, base_fees)?; + + Ok(ceil_div( + amount, + u128::from(dynamic_fee_rate), + u128::from(FEE_RATE_DENOMINATOR_VALUE), + ) + .ok_or(GammaError::MathOverflow)?) + } + + fn calculate_dynamic_fee( + block_timestamp: u64, + observation_state: &ObservationState, + fee_type: FeeType, + base_fees: u64, + ) -> Result { + match fee_type { + FeeType::Volatility => { + Self::calculate_volatile_fee(block_timestamp, observation_state, base_fees) + } + } + } + + fn calculate_volatile_fee( + block_timestamp: u64, + observation_state: &ObservationState, + base_fees: u64, + ) -> Result { + let (min_price, max_price, twap_price) = + Self::get_price_range(observation_state, block_timestamp, VOLATILITY_WINDOW)?; + if min_price == 0 || max_price == 0 || twap_price == 0 || twap_price == 1 { + return Ok(base_fees); + } + + let log_max_price = (max_price as f64).ln(); + let log_min_price = (min_price as f64).ln(); + let log_twap_price = (twap_price as f64).ln(); + + let volatility_numerator = (log_max_price - log_min_price).abs(); + let volatility_denominator = log_twap_price.abs(); + + if volatility_denominator.is_zero() { + return Ok(base_fees); + } + + let volatility = volatility_numerator / volatility_denominator; + + let volatility_component_calculated = (VOLATILITY_FACTOR as f64 * volatility) + .to_u64() + .ok_or(GammaError::MathOverflow)?; + + let dynamic_fee = base_fees + .checked_add(volatility_component_calculated) + .ok_or(GammaError::MathOverflow)?; + + Ok(std::cmp::min(dynamic_fee, MAX_FEE)) + } + + fn get_price_range( + observation_state: &ObservationState, + current_time: u64, + window: u64, + ) -> Result<(u128, u128, u128)> { + let mut min_price = u128::MAX; + let mut max_price = 0u128; + let mut descending_order_observations = observation_state + .observations + .iter() + .enumerate() + .filter(|(_, observation)| { + observation.block_timestamp != 0 + && observation.cumulative_token0_price_x32 != 0 + && observation.cumulative_token1_price_x32 != 0 + && current_time.saturating_sub(observation.block_timestamp) <= window + }) + .map(|(index, observation)| ObservationWithIndex { + index: index as u16, + observation: *observation, + }) + .collect::>(); + + // Sort observations by timestamp (newest first) + descending_order_observations.sort_by(|a, b| { + { b.observation.block_timestamp }.cmp(&{ a.observation.block_timestamp }) + }); + + if descending_order_observations.len() < 2 { + return Ok((0, 0, 0)); + } + + let newest_obs = descending_order_observations.first().unwrap(); + let oldest_obs = descending_order_observations.last().unwrap(); + + let total_time_delta = newest_obs + .observation + .block_timestamp + .saturating_sub(oldest_obs.observation.block_timestamp) + as u128; + + if total_time_delta == 0 { + return Ok((0, 0, 0)); + } + + let twap_price = newest_obs + .observation + .cumulative_token0_price_x32 + .checked_sub(oldest_obs.observation.cumulative_token0_price_x32) + .ok_or(GammaError::MathOverflow)? + .checked_div(total_time_delta) + .ok_or(GammaError::MathOverflow)?; + + for observation_with_index in descending_order_observations { + let last_observation_index = if observation_with_index.index == 0 { + OBSERVATION_NUM - 1 + } else { + observation_with_index.index as usize - 1 + }; + + if observation_state.observations[last_observation_index].block_timestamp == 0 { + continue; + } + + if observation_state.observations[last_observation_index].block_timestamp + > observation_with_index.observation.block_timestamp + { + break; + } + + let obs = observation_state.observations[last_observation_index]; + let next_obs = observation_with_index.observation; + + let time_delta = next_obs.block_timestamp.saturating_sub(obs.block_timestamp) as u128; + + if time_delta == 0 { + continue; + } + + let price = next_obs + .cumulative_token0_price_x32 + .checked_sub(obs.cumulative_token0_price_x32) + .ok_or(GammaError::MathOverflow)? + .checked_div(time_delta) + .ok_or(GammaError::MathOverflow)?; + + min_price = min_price.min(price); + max_price = max_price.max(price); + } + + Ok((min_price, max_price, twap_price)) + } + + pub fn calculate_pre_fee_amount( + block_timestamp: u64, + post_fee_amount: u128, + observation_state: &ObservationState, + fee_type: FeeType, + base_fees: u64, + ) -> Result { + let dynamic_fee_rate = + Self::calculate_dynamic_fee(block_timestamp, observation_state, fee_type, base_fees)?; + if dynamic_fee_rate == 0 { + Ok(post_fee_amount) + } else { + let numerator = post_fee_amount + .checked_mul(u128::from(FEE_RATE_DENOMINATOR_VALUE)) + .ok_or(GammaError::MathOverflow)?; + let denominator = u128::from(FEE_RATE_DENOMINATOR_VALUE) + .checked_sub(u128::from(dynamic_fee_rate)) + .ok_or(GammaError::MathOverflow)?; + + let result = numerator + .checked_add(denominator) + .ok_or(GammaError::MathOverflow)? + .checked_sub(1) + .ok_or(GammaError::MathOverflow)? + .checked_div(denominator) + .ok_or(GammaError::MathOverflow)?; + + Ok(result) + } + } +} diff --git a/lib/gamma/src/fees/mod.rs b/lib/gamma/src/fees/mod.rs new file mode 100644 index 0000000..0a8ff69 --- /dev/null +++ b/lib/gamma/src/fees/mod.rs @@ -0,0 +1,21 @@ +pub mod dynamic_fee; +pub mod static_fees; + +pub use dynamic_fee::*; +pub use static_fees::*; + +pub const FEE_RATE_DENOMINATOR_VALUE: u64 = 1_000_000; + +pub fn ceil_div(token_amount: u128, fee_numerator: u128, fee_denominator: u128) -> Option { + token_amount + .checked_mul(fee_numerator)? + .checked_add(fee_denominator)? + .checked_sub(1)? + .checked_div(fee_denominator) +} + +pub fn floor_div(token_amount: u128, fee_numerator: u128, fee_denominator: u128) -> Option { + token_amount + .checked_mul(fee_numerator)? + .checked_div(fee_denominator) +} diff --git a/lib/gamma/src/fees/static_fees.rs b/lib/gamma/src/fees/static_fees.rs new file mode 100644 index 0000000..770e365 --- /dev/null +++ b/lib/gamma/src/fees/static_fees.rs @@ -0,0 +1,21 @@ +use super::{floor_div, FEE_RATE_DENOMINATOR_VALUE}; + +pub struct StaticFee {} + +impl StaticFee { + pub fn protocol_fee(amount: u128, protocol_fee_rate: u64) -> Option { + floor_div( + amount, + u128::from(protocol_fee_rate), + u128::from(FEE_RATE_DENOMINATOR_VALUE), + ) + } + + pub fn fund_fee(amount: u128, fund_fee_rate: u64) -> Option { + floor_div( + amount, + u128::from(fund_fee_rate), + u128::from(FEE_RATE_DENOMINATOR_VALUE), + ) + } +} diff --git a/lib/gamma/src/gamma.json b/lib/gamma/src/gamma.json new file mode 100644 index 0000000..583db95 --- /dev/null +++ b/lib/gamma/src/gamma.json @@ -0,0 +1,1786 @@ +{ + "version": "0.1.0", + "name": "gamma", + "instructions": [ + { + "name": "createAmmConfig", + "docs": [ + "The configuation of AMM protocol, include trade fee and protocol fee", + "# Arguments", + "", + "* `ctx`- The accounts needed by instruction.", + "* `index` - The index of amm config, there may be multiple config.", + "* `trade_fee_rate` - Trade fee rate, can be changed.", + "* `protocol_fee_rate` - The rate of protocol fee within tarde fee.", + "* `fund_fee_rate` - The rate of fund fee within tarde fee.", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": true, + "isSigner": true, + "docs": [ + "Address to be set as protocol owner." + ] + }, + { + "name": "ammConfig", + "isMut": true, + "isSigner": false, + "docs": [ + "Initialize AmmConfig state account to store protocol owner address and fee rates" + ] + }, + { + "name": "systemProgram", + "isMut": false, + "isSigner": false + } + ], + "args": [ + { + "name": "index", + "type": "u16" + }, + { + "name": "tradeFeeRate", + "type": "u64" + }, + { + "name": "protocolFeeRate", + "type": "u64" + }, + { + "name": "fundFeeRate", + "type": "u64" + }, + { + "name": "createPoolFee", + "type": "u64" + }, + { + "name": "maxOpenTime", + "type": "u64" + } + ] + }, + { + "name": "createSwapReferral", + "docs": [ + "Initialize swap referrals for an existing AMM config", + "# Arguments", + "", + "* `ctx` - The accounts needed by the instruction, including those used by cpi to the referral program", + "* `name` - The project name, passed to the referral program. Must be less than 50 chars in length", + "* `default_share_bps` - Percentage share of fees to referrers. Must be less than 10_000" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "Address to be set as protocol owner." + ] + }, + { + "name": "payer", + "isMut": true, + "isSigner": true + }, + { + "name": "ammConfig", + "isMut": true, + "isSigner": false, + "docs": [ + "The config acts as the base for its referral project" + ] + }, + { + "name": "project", + "isMut": false, + "isSigner": false + }, + { + "name": "systemProgram", + "isMut": false, + "isSigner": false + }, + { + "name": "referralProgram", + "isMut": false, + "isSigner": false + } + ], + "args": [ + { + "name": "name", + "type": "string" + }, + { + "name": "defaultShareBps", + "type": "u16" + } + ] + }, + { + "name": "updateAmmConfig", + "docs": [ + "Updates the owner of the amm config", + "Must be called by the current owner or admin", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `trade_fee_rate`- The new trade fee rate of amm config, be set when `param` is 0", + "* `protocol_fee_rate`- The new protocol fee rate of amm config, be set when `param` is 1", + "* `fund_fee_rate`- The new fund fee rate of amm config, be set when `param` is 2", + "* `new_owner`- The config's new owner, be set when `param` is 3", + "* `new_fund_owner`- The config's new fund owner, be set when `param` is 4", + "* `param`- The vaule can be 0 | 1 | 2 | 3 | 4, otherwise will report a error", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "The amm config owner or admin" + ] + }, + { + "name": "ammConfig", + "isMut": true, + "isSigner": false, + "docs": [ + "The amm config account to update" + ] + } + ], + "args": [ + { + "name": "param", + "type": "u16" + }, + { + "name": "value", + "type": "u64" + } + ] + }, + { + "name": "updatePoolStatus", + "docs": [ + "Update pool status for given vaule", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `status` - The vaule of status", + "" + ], + "accounts": [ + { + "name": "authority", + "isMut": false, + "isSigner": true + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false + } + ], + "args": [ + { + "name": "status", + "type": "u8" + } + ] + }, + { + "name": "collectProtocolFee", + "docs": [ + "Collect the protocol fee accrued to the pool", + "", + "# Arguments", + "", + "* `ctx` - The context of accounts", + "* `amount_0_requested` - The maximum amount of token_0 to send, can be 0 to collect fees in only token_1", + "* `amount_1_requested` - The maximum amount of token_1 to send, can be 0 to collect fees in only token_0", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "Only admin or owner can collect fee now" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool state stores accumulated protocol fee amount" + ] + }, + { + "name": "ammConfig", + "isMut": false, + "isSigner": false, + "docs": [ + "Amm config account stores owner" + ] + }, + { + "name": "token0Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_0" + ] + }, + { + "name": "token1Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_1" + ] + }, + { + "name": "vault0Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_0 vault" + ] + }, + { + "name": "vault1Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_1 vault" + ] + }, + { + "name": "recipientToken0Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that receives the collected token_0 protocol fees" + ] + }, + { + "name": "recipientToken1Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that receives the collected token_1 protocol fees" + ] + }, + { + "name": "tokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "The SPL program to perform token transfers" + ] + }, + { + "name": "tokenProgram2022", + "isMut": false, + "isSigner": false, + "docs": [ + "The SPL program 2022 to perform token transfers" + ] + } + ], + "args": [ + { + "name": "amount0Requested", + "type": "u64" + }, + { + "name": "amount1Requested", + "type": "u64" + } + ] + }, + { + "name": "collectFundFee", + "docs": [ + "Collect the fund fee accrued to the pool", + "", + "# Arguments", + "", + "* `ctx` - The context of accounts", + "* `amount_0_requested` - The maximum amount of token_0 to send, can be 0 to collect fees in only token_1", + "* `amount_1_requested` - The maximum amount of token_1 to send, can be 0 to collect fees in only token_0", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "Only admin or fund_owner can collect fee now" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool state stores accumulated protocol fee amount" + ] + }, + { + "name": "ammConfig", + "isMut": false, + "isSigner": false, + "docs": [ + "Amm config account stores fund_owner" + ] + }, + { + "name": "token0Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_0" + ] + }, + { + "name": "token1Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_1" + ] + }, + { + "name": "vault0Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_0 vault" + ] + }, + { + "name": "vault1Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_1 vault" + ] + }, + { + "name": "recipientToken0Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that receives the collected token_0 fund fees" + ] + }, + { + "name": "recipientToken1Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that receives the collected token_1 fund fees" + ] + }, + { + "name": "tokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "The SPL program to perform token transfers" + ] + }, + { + "name": "tokenProgram2022", + "isMut": false, + "isSigner": false, + "docs": [ + "The SPL program 2022 to perform token transfers" + ] + } + ], + "args": [ + { + "name": "amount0Requested", + "type": "u64" + }, + { + "name": "amount1Requested", + "type": "u64" + } + ] + }, + { + "name": "initialize", + "docs": [ + "Creates a pool for the given token pair and the initial price", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `init_amount_0` - the initial amount_0 to deposit", + "* `init_amount_1` - the initial amount_1 to deposit", + "* `open_time` - the timestamp allowed for swap", + "" + ], + "accounts": [ + { + "name": "creator", + "isMut": true, + "isSigner": true, + "docs": [ + "Address paying to create the pool. It can be anyone." + ] + }, + { + "name": "ammConfig", + "isMut": false, + "isSigner": false, + "docs": [ + "Which amm config the pool belongs to" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false, + "docs": [ + "sign transactions on behalf of the pool", + "for vault and lp_mint" + ] + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "Initialize an account to store the pool state" + ] + }, + { + "name": "userPoolLiquidity", + "isMut": true, + "isSigner": false + }, + { + "name": "token0Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "Token_0 mint, the key must smaller than token_1 mint." + ] + }, + { + "name": "token1Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "Token_1 mint, the key must greater than token_0 mint." + ] + }, + { + "name": "creatorToken0", + "isMut": true, + "isSigner": false, + "docs": [ + "creator token 0 account" + ] + }, + { + "name": "creatorToken1", + "isMut": true, + "isSigner": false, + "docs": [ + "creator token 1 account" + ] + }, + { + "name": "token0Vault", + "isMut": true, + "isSigner": false + }, + { + "name": "token1Vault", + "isMut": true, + "isSigner": false + }, + { + "name": "createPoolFee", + "isMut": true, + "isSigner": false, + "docs": [ + "create pool fee account" + ] + }, + { + "name": "observationState", + "isMut": true, + "isSigner": false, + "docs": [ + "an account to store oracle observations" + ] + }, + { + "name": "tokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "Program to create mint account and mint tokens" + ] + }, + { + "name": "token0Program", + "isMut": false, + "isSigner": false, + "docs": [ + "Spl token program or token program 2022" + ] + }, + { + "name": "token1Program", + "isMut": false, + "isSigner": false, + "docs": [ + "Spl token program or token program 2022" + ] + }, + { + "name": "associatedTokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "Program to create an ATA for receiving position NFT" + ] + }, + { + "name": "systemProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "To create a new program account" + ] + }, + { + "name": "rent", + "isMut": false, + "isSigner": false, + "docs": [ + "Sysvar for program account" + ] + } + ], + "args": [ + { + "name": "initAmount0", + "type": "u64" + }, + { + "name": "initAmount1", + "type": "u64" + }, + { + "name": "openTime", + "type": "u64" + } + ] + }, + { + "name": "initUserPoolLiquidity", + "accounts": [ + { + "name": "user", + "isMut": true, + "isSigner": true + }, + { + "name": "poolState", + "isMut": false, + "isSigner": false + }, + { + "name": "userPoolLiquidity", + "isMut": true, + "isSigner": false + }, + { + "name": "systemProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "To create a new program account" + ] + } + ], + "args": [] + }, + { + "name": "deposit", + "docs": [ + "Creates a pool for the given token pair and the initial price", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `lp_token_amount` - Pool token amount to transfer. token_a and token_b amount are set by the current exchange rate and size of the pool", + "* `maximum_token_0_amount` - Maximum token 0 amount to deposit, prevents excessive slippage", + "* `maximum_token_1_amount` - Maximum token 1 amount to deposit, prevents excessive slippage", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "Pays to mint the position" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool state the owner is depositing into" + ] + }, + { + "name": "userPoolLiquidity", + "isMut": true, + "isSigner": false + }, + { + "name": "token0Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The payer's token account to deposit token_0" + ] + }, + { + "name": "token1Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The payer's token account to deposit token_1" + ] + }, + { + "name": "token0Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool vault for token_0 to deposit into", + "The address that holds pool tokens for token_0" + ] + }, + { + "name": "token1Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool vault for token_1 to deposit into", + "The address that holds pool tokens for token_1" + ] + }, + { + "name": "tokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "token Program" + ] + }, + { + "name": "tokenProgram2022", + "isMut": false, + "isSigner": false, + "docs": [ + "Token program 2022" + ] + }, + { + "name": "vault0Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_0 vault" + ] + }, + { + "name": "vault1Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_1 vault" + ] + } + ], + "args": [ + { + "name": "lpTokenAmount", + "type": "u64" + }, + { + "name": "maximumToken0Amount", + "type": "u64" + }, + { + "name": "maximumToken1Amount", + "type": "u64" + } + ] + }, + { + "name": "withdraw", + "docs": [ + "Withdraw lp for token0 ande token1", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `lp_token_amount` - Amount of pool tokens to burn. User receives an output of token a and b based on the percentage of the pool tokens that are returned.", + "* `minimum_token_0_amount` - Minimum amount of token 0 to receive, prevents excessive slippage", + "* `minimum_token_1_amount` - Minimum amount of token 1 to receive, prevents excessive slippage", + "" + ], + "accounts": [ + { + "name": "owner", + "isMut": false, + "isSigner": true, + "docs": [ + "Pays to mint the position" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "Pool state account" + ] + }, + { + "name": "userPoolLiquidity", + "isMut": true, + "isSigner": false, + "docs": [ + "User pool liquidity account" + ] + }, + { + "name": "token0Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The owner's token account for receive token_0" + ] + }, + { + "name": "token1Account", + "isMut": true, + "isSigner": false, + "docs": [ + "The owner's token account for receive token_1" + ] + }, + { + "name": "token0Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_0" + ] + }, + { + "name": "token1Vault", + "isMut": true, + "isSigner": false, + "docs": [ + "The address that holds pool tokens for token_1" + ] + }, + { + "name": "tokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "token Program" + ] + }, + { + "name": "tokenProgram2022", + "isMut": false, + "isSigner": false, + "docs": [ + "Token program 2022" + ] + }, + { + "name": "vault0Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_0 vault" + ] + }, + { + "name": "vault1Mint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of token_1 vault" + ] + }, + { + "name": "memoProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "memo program" + ] + } + ], + "args": [ + { + "name": "lpTokenAmount", + "type": "u64" + }, + { + "name": "minimumToken0Amount", + "type": "u64" + }, + { + "name": "minimumToken1Amount", + "type": "u64" + } + ] + }, + { + "name": "swapBaseInput", + "docs": [ + "Swap the tokens in the pool base input amount", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `amount_in` - input amount to transfer, output to DESTINATION is based on the exchange rate", + "* `minimum_amount_out` - Minimum amount of output token, prevents excessive slippage", + "" + ], + "accounts": [ + { + "name": "payer", + "isMut": false, + "isSigner": true, + "docs": [ + "The user performing the swap" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "ammConfig", + "isMut": false, + "isSigner": false, + "docs": [ + "The factory state to read protocol fees" + ] + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "The program account of the pool in which the swap will be performed" + ] + }, + { + "name": "inputTokenAccount", + "isMut": true, + "isSigner": false, + "docs": [ + "The user token account for input token" + ] + }, + { + "name": "outputTokenAccount", + "isMut": true, + "isSigner": false, + "docs": [ + "The user token account for output token" + ] + }, + { + "name": "inputVault", + "isMut": true, + "isSigner": false, + "docs": [ + "The vault token account for input token" + ] + }, + { + "name": "outputVault", + "isMut": true, + "isSigner": false, + "docs": [ + "The vault token account for output token" + ] + }, + { + "name": "inputTokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "SPL program for input token transfers" + ] + }, + { + "name": "outputTokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "SPL program for output token transfers" + ] + }, + { + "name": "inputTokenMint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of input token" + ] + }, + { + "name": "outputTokenMint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of output token" + ] + }, + { + "name": "observationState", + "isMut": true, + "isSigner": false, + "docs": [ + "The program account for the most recent oracle observation" + ] + } + ], + "args": [ + { + "name": "amountIn", + "type": "u64" + }, + { + "name": "minimumAmountOut", + "type": "u64" + } + ] + }, + { + "name": "swapBaseOutput", + "docs": [ + "Swap the tokens in the pool base output amount", + "", + "# Arguments", + "", + "* `ctx`- The context of accounts", + "* `max_amount_in` - input amount prevents excessive slippage", + "* `amount_out` - amount of output token", + "" + ], + "accounts": [ + { + "name": "payer", + "isMut": false, + "isSigner": true, + "docs": [ + "The user performing the swap" + ] + }, + { + "name": "authority", + "isMut": false, + "isSigner": false + }, + { + "name": "ammConfig", + "isMut": false, + "isSigner": false, + "docs": [ + "The factory state to read protocol fees" + ] + }, + { + "name": "poolState", + "isMut": true, + "isSigner": false, + "docs": [ + "The program account of the pool in which the swap will be performed" + ] + }, + { + "name": "inputTokenAccount", + "isMut": true, + "isSigner": false, + "docs": [ + "The user token account for input token" + ] + }, + { + "name": "outputTokenAccount", + "isMut": true, + "isSigner": false, + "docs": [ + "The user token account for output token" + ] + }, + { + "name": "inputVault", + "isMut": true, + "isSigner": false, + "docs": [ + "The vault token account for input token" + ] + }, + { + "name": "outputVault", + "isMut": true, + "isSigner": false, + "docs": [ + "The vault token account for output token" + ] + }, + { + "name": "inputTokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "SPL program for input token transfers" + ] + }, + { + "name": "outputTokenProgram", + "isMut": false, + "isSigner": false, + "docs": [ + "SPL program for output token transfers" + ] + }, + { + "name": "inputTokenMint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of input token" + ] + }, + { + "name": "outputTokenMint", + "isMut": false, + "isSigner": false, + "docs": [ + "The mint of output token" + ] + }, + { + "name": "observationState", + "isMut": true, + "isSigner": false, + "docs": [ + "The program account for the most recent oracle observation" + ] + } + ], + "args": [ + { + "name": "maxAmountIn", + "type": "u64" + }, + { + "name": "amountOut", + "type": "u64" + } + ] + } + ], + "accounts": [ + { + "name": "AmmConfig", + "type": { + "kind": "struct", + "fields": [ + { + "name": "bump", + "type": "u8" + }, + { + "name": "disableCreatePool", + "type": "bool" + }, + { + "name": "index", + "docs": [ + "Config index" + ], + "type": "u16" + }, + { + "name": "tradeFeeRate", + "docs": [ + "The trade fee, denominated in hundredths of bip (10^-6)" + ], + "type": "u64" + }, + { + "name": "protocolFeeRate", + "docs": [ + "The protocol fee" + ], + "type": "u64" + }, + { + "name": "fundFeeRate", + "docs": [ + "The fund fee, denominated in hundredths of bip (10^-6)" + ], + "type": "u64" + }, + { + "name": "createPoolFee", + "docs": [ + "Fee for creating a new pool" + ], + "type": "u64" + }, + { + "name": "protocolOwner", + "docs": [ + "Address of the protocol fee owner" + ], + "type": "publicKey" + }, + { + "name": "fundOwner", + "docs": [ + "Address of the fund fee owner" + ], + "type": "publicKey" + }, + { + "name": "referralProject", + "docs": [ + "Address of the referral project" + ], + "type": "publicKey" + }, + { + "name": "maxOpenTime", + "docs": [ + "Max open time for a pool in seconds" + ], + "type": "u64" + }, + { + "name": "padding", + "docs": [ + "padding" + ], + "type": { + "array": [ + "u64", + 11 + ] + } + } + ] + } + }, + { + "name": "ObservationState", + "type": { + "kind": "struct", + "fields": [ + { + "name": "initialized", + "docs": [ + "Whether the ObservationState is enabled" + ], + "type": "bool" + }, + { + "name": "observationIndex", + "docs": [ + "The most recently updated index of the observations array" + ], + "type": "u16" + }, + { + "name": "poolId", + "type": "publicKey" + }, + { + "name": "observations", + "docs": [ + "observation array" + ], + "type": { + "array": [ + { + "defined": "Observation" + }, + 100 + ] + } + }, + { + "name": "padding", + "docs": [ + "padding" + ], + "type": { + "array": [ + "u64", + 4 + ] + } + } + ] + } + }, + { + "name": "PoolState", + "type": { + "kind": "struct", + "fields": [ + { + "name": "ammConfig", + "docs": [ + "To which AmmConfig the pool belongs to" + ], + "type": "publicKey" + }, + { + "name": "poolCreator", + "docs": [ + "Pool Creator" + ], + "type": "publicKey" + }, + { + "name": "token0Vault", + "docs": [ + "Vault to store Token A of the pool" + ], + "type": "publicKey" + }, + { + "name": "token1Vault", + "docs": [ + "Vault to store Token B of the pool" + ], + "type": "publicKey" + }, + { + "name": "padding1", + "docs": [ + "Pool tokens are issued when Token A or Token B are deposited", + "Pool tokens can be withdrawn back to the original Token A or Token B" + ], + "type": { + "array": [ + "u8", + 32 + ] + } + }, + { + "name": "token0Mint", + "docs": [ + "Mint info of Token A" + ], + "type": "publicKey" + }, + { + "name": "token1Mint", + "docs": [ + "Mint info of Token B" + ], + "type": "publicKey" + }, + { + "name": "token0Program", + "docs": [ + "token_0 program" + ], + "type": "publicKey" + }, + { + "name": "token1Program", + "docs": [ + "token_1_program" + ], + "type": "publicKey" + }, + { + "name": "observationKey", + "docs": [ + "Observation account to store the oracle data" + ], + "type": "publicKey" + }, + { + "name": "authBump", + "type": "u8" + }, + { + "name": "status", + "docs": [ + "Bitwise represenation of the state of the pool", + "Bit0: 1 - Disable Deposit(value will be 1), 0 - Deposit can be done(normal)", + "Bit1: 1 - Disable Withdraw(value will be 2), 0 - Withdraw can be done(normal)", + "Bit2: 1 - Disable Swap(value will be 4), 0 - Swap can be done(normal)" + ], + "type": "u8" + }, + { + "name": "padding2", + "docs": [ + "lp_mint decimals" + ], + "type": "u8" + }, + { + "name": "mint0Decimals", + "docs": [ + "mint0 and mint1 decimals" + ], + "type": "u8" + }, + { + "name": "mint1Decimals", + "type": "u8" + }, + { + "name": "lpSupply", + "docs": [ + "True circulating supply of lp_mint tokens without burns and lock-ups" + ], + "type": "u64" + }, + { + "name": "protocolFeesToken0", + "docs": [ + "The amount of token_0 and token_1 owed to Liquidity Provider" + ], + "type": "u64" + }, + { + "name": "protocolFeesToken1", + "type": "u64" + }, + { + "name": "fundFeesToken0", + "type": "u64" + }, + { + "name": "fundFeesToken1", + "type": "u64" + }, + { + "name": "openTime", + "docs": [ + "The timestamp allowed for swap in the pool" + ], + "type": "u64" + }, + { + "name": "recentEpoch", + "docs": [ + "recent epoch" + ], + "type": "u64" + }, + { + "name": "cumulativeTradeFeesToken0", + "docs": [ + "Trade fees of token_0 after every swap" + ], + "type": "u128" + }, + { + "name": "cumulativeTradeFeesToken1", + "docs": [ + "Trade fees of token_1 after every swap" + ], + "type": "u128" + }, + { + "name": "cumulativeVolumeToken0", + "docs": [ + "Cummulative volume of token_0" + ], + "type": "u128" + }, + { + "name": "cumulativeVolumeToken1", + "docs": [ + "Cummulative volume of token_1" + ], + "type": "u128" + }, + { + "name": "filterPeriod", + "docs": [ + "Filter period determine high frequency trading time window." + ], + "type": "u32" + }, + { + "name": "decayPeriod", + "docs": [ + "Decay period determine when the volatile fee start decay / decrease." + ], + "type": "u32" + }, + { + "name": "reductionFactor", + "docs": [ + "Reduction factor controls the volatile fee rate decrement rate." + ], + "type": "u32" + }, + { + "name": "variableFeeControl", + "docs": [ + "Used to scale the variable fee component depending on the dynamic of the market" + ], + "type": "u32" + }, + { + "name": "volatilityV2BaseFee", + "type": "u64" + }, + { + "name": "volatilityV2MaxFee", + "type": "u64" + }, + { + "name": "volatilityV2VolatilityFactor", + "type": "u64" + }, + { + "name": "volatilityV2ImbalanceFactor", + "type": "u64" + }, + { + "name": "padding", + "docs": [ + "padding" + ], + "type": { + "array": [ + "u64", + 17 + ] + } + } + ] + } + }, + { + "name": "UserPoolLiquidity", + "type": { + "kind": "struct", + "fields": [ + { + "name": "user", + "type": "publicKey" + }, + { + "name": "poolState", + "type": "publicKey" + }, + { + "name": "token0Deposited", + "type": "u128" + }, + { + "name": "token1Deposited", + "type": "u128" + }, + { + "name": "token0Withdrawn", + "type": "u128" + }, + { + "name": "token1Withdrawn", + "type": "u128" + }, + { + "name": "lpTokensOwned", + "type": "u128" + }, + { + "name": "referrer", + "type": "publicKey" + } + ] + } + } + ], + "types": [ + { + "name": "Observation", + "docs": [ + "The element of observations in ObservationState" + ], + "type": { + "kind": "struct", + "fields": [ + { + "name": "blockTimestamp", + "docs": [ + "The block timestamp of the observation" + ], + "type": "u64" + }, + { + "name": "cumulativeToken0PriceX32", + "docs": [ + "The cumulative of token0 price during the duration time, Q32.32, the remaining 64 bit for overflow" + ], + "type": "u128" + }, + { + "name": "cumulativeToken1PriceX32", + "docs": [ + "The cumulative of token1 price during the duration time, Q32.32, the remaining 64 bit for overflow" + ], + "type": "u128" + } + ] + } + } + ], + "events": [ + { + "name": "LpChangeEvent", + "fields": [ + { + "name": "poolId", + "type": "publicKey", + "index": true + }, + { + "name": "lpAmountBefore", + "type": "u64", + "index": false + }, + { + "name": "token0VaultBefore", + "type": "u64", + "index": false + }, + { + "name": "token1VaultBefore", + "type": "u64", + "index": false + }, + { + "name": "token0Amount", + "type": "u64", + "index": false + }, + { + "name": "token1Amount", + "type": "u64", + "index": false + }, + { + "name": "token0TransferFee", + "type": "u64", + "index": false + }, + { + "name": "token1TransferFee", + "type": "u64", + "index": false + }, + { + "name": "changeType", + "type": "u8", + "index": false + } + ] + }, + { + "name": "SwapEvent", + "fields": [ + { + "name": "poolId", + "type": "publicKey", + "index": true + }, + { + "name": "inputVaultBefore", + "type": "u64", + "index": false + }, + { + "name": "outputVaultBefore", + "type": "u64", + "index": false + }, + { + "name": "inputAmount", + "type": "u64", + "index": false + }, + { + "name": "outputAmount", + "type": "u64", + "index": false + }, + { + "name": "inputTransferFee", + "type": "u64", + "index": false + }, + { + "name": "outputTransferFee", + "type": "u64", + "index": false + }, + { + "name": "baseInput", + "type": "bool", + "index": false + } + ] + } + ], + "errors": [ + { + "code": 6000, + "name": "NotApproved", + "msg": "Not approved" + }, + { + "code": 6001, + "name": "InvalidOwner", + "msg": "Input account owner is not the program address" + }, + { + "code": 6002, + "name": "EmptySupply", + "msg": "Input token account empty" + }, + { + "code": 6003, + "name": "InvalidInput", + "msg": "InvalidInput" + }, + { + "code": 6004, + "name": "IncorrectLpMint", + "msg": "Address of the provided lp token mint is incorrect" + }, + { + "code": 6005, + "name": "ExceededSlippage", + "msg": "Exceeds desired slippage limit" + }, + { + "code": 6006, + "name": "ZeroTradingTokens", + "msg": "Given pool token amount results in zero trading tokens" + }, + { + "code": 6007, + "name": "NotSupportMint", + "msg": "Not support token_2022 mint extension" + }, + { + "code": 6008, + "name": "InvalidVault", + "msg": "invaild vault" + }, + { + "code": 6009, + "name": "InitLpAmountTooLess", + "msg": "Init lp amount is too less(Because 100 amount lp will be locked)" + }, + { + "code": 6010, + "name": "MathError", + "msg": "Math error" + }, + { + "code": 6011, + "name": "DynamicFeeIsNegative", + "msg": "Invalid calculation, dynamic fee is negative" + }, + { + "code": 6012, + "name": "MathOverflow", + "msg": "Math overflow" + }, + { + "code": 6013, + "name": "ClockError", + "msg": "Clock error" + }, + { + "code": 6014, + "name": "InvalidFee", + "msg": "Invalid fee" + }, + { + "code": 6015, + "name": "InvalidOpenTime", + "msg": "Invalid open time" + } + ] +} \ No newline at end of file diff --git a/lib/gamma/src/lib.rs b/lib/gamma/src/lib.rs new file mode 100644 index 0000000..31a69d0 --- /dev/null +++ b/lib/gamma/src/lib.rs @@ -0,0 +1,39 @@ +pub mod curve; +use std::ops::BitAnd; +pub mod fees; +pub mod utils; + +declare_id!("GAMMA7meSFWaBXF25oSUgmGRwaW6sCMFLmBNiMSdbHVT"); + +anchor_gen::generate_cpi_crate!("src/gamma.json"); + +pub const AUTH_SEED: &str = "vault_and_lp_mint_auth_seed"; + +#[derive(PartialEq, Eq)] +pub enum PoolStatusBitFlag { + Enable, + Disable, +} + +pub enum PoolStatusBitIndex { + Deposit, + Withdraw, + Swap, +} + +impl PoolState { + pub const LEN: usize = 8 + 10 * 32 + 5 * 1 + 7 * 8 + 16 * 4 + 23 * 8; + + pub fn get_status_by_bit(&self, bit: PoolStatusBitIndex) -> bool { + let status = u8::from(1) << (bit as u8); + self.status.bitand(status) == 0 + } +} + +#[error_code] +pub enum GammaError { + #[msg("Math overflow")] + MathOverflow, + #[msg("Invalid fee")] + InvalidFee, +} diff --git a/lib/gamma/src/utils/math.rs b/lib/gamma/src/utils/math.rs new file mode 100644 index 0000000..970de71 --- /dev/null +++ b/lib/gamma/src/utils/math.rs @@ -0,0 +1,28 @@ +pub trait CheckedCeilDiv: Sized { + /// Perform ceiling division + fn checked_ceil_div(&self, rhs: Self) -> Option<(Self, Self)>; +} + +impl CheckedCeilDiv for u128 { + fn checked_ceil_div(&self, mut rhs: Self) -> Option<(Self, Self)> { + let mut quotient = self.checked_div(rhs)?; + if quotient == 0 { + if self.checked_mul(2 as u128)? >= rhs { + return Some((1, 0)); + } else { + return Some((0, 0)); + } + } + + let remainder = self.checked_rem(rhs)?; + if remainder > 0 { + quotient = quotient.checked_add(1)?; + rhs = self.checked_div(quotient)?; + let remainder = self.checked_rem(quotient)?; + if remainder > 0 { + rhs = rhs.checked_add(1)?; + } + } + Some((quotient, rhs)) + } +} diff --git a/lib/gamma/src/utils/mod.rs b/lib/gamma/src/utils/mod.rs new file mode 100644 index 0000000..f36d306 --- /dev/null +++ b/lib/gamma/src/utils/mod.rs @@ -0,0 +1,2 @@ +pub mod math; +pub use math::*;