diff --git a/Cargo.lock b/Cargo.lock index 8b2feb1..ed59b60 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1980,6 +1980,28 @@ version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" +[[package]] +name = "decimal" +version = "0.1.0" +source = "git+https://github.com/invariant-labs/protocol?rev=14da6bde97849ddbdc75a23005bcdeb8105c3385#14da6bde97849ddbdc75a23005bcdeb8105c3385" +dependencies = [ + "decimal_core", + "integer-sqrt", + "num-traits", + "uint", +] + +[[package]] +name = "decimal_core" +version = "0.1.0" +source = "git+https://github.com/invariant-labs/protocol?rev=14da6bde97849ddbdc75a23005bcdeb8105c3385#14da6bde97849ddbdc75a23005bcdeb8105c3385" +dependencies = [ + "proc-macro2 1.0.86", + "quote 1.0.35", + "regex", + "syn 1.0.109", +] + [[package]] name = "default-env" version = "0.1.1" @@ -2120,6 +2142,40 @@ dependencies = [ "tracing", ] +[[package]] +name = "dex-invariant" +version = "0.0.1" +dependencies = [ + "anchor-lang", + "anchor-spl", + "anyhow", + "arrayref", + "async-trait", + "bytemuck", + "chrono", + "decimal", + "invariant-types", + "itertools 0.10.5", + "num-derive 0.3.3", + "num-traits", + "router-feed-lib", + "router-lib", + "router-test-lib", + "safe-transmute", + "serde", + "sha2 0.10.8", + "solana-account-decoder", + "solana-client", + "solana-logger", + "solana-program", + "solana-program-test", + "solana-sdk", + "spl-associated-token-account 1.1.3", + "thiserror", + "tracing", + "uint", +] + [[package]] name = "dex-openbook-v2" version = "0.0.1" @@ -3509,6 +3565,32 @@ dependencies = [ "cfg-if 1.0.0", ] +[[package]] +name = "integer-sqrt" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "276ec31bcb4a9ee45f58bec6f9ec700ae4cf4f4f8f2fa7e06cb406bd5ffdd770" +dependencies = [ + "num-traits", +] + +[[package]] +name = "invariant-types" +version = "0.1.0" +dependencies = [ + "anchor-lang", + "anyhow", + "arrayref", + "borsh 0.9.3", + "bytemuck", + "decimal", + "num-derive 0.3.3", + "num-traits", + "safe-transmute", + "serde", + "thiserror", +] + [[package]] name = "iovec" version = "0.1.4" diff --git a/lib/dex-invariant/Cargo.toml b/lib/dex-invariant/Cargo.toml new file mode 100644 index 0000000..9a33d9a --- /dev/null +++ b/lib/dex-invariant/Cargo.toml @@ -0,0 +1,41 @@ +[package] +name = "dex-invariant" +version = "0.0.1" +edition = "2021" + +[lib] +doctest = false + +[dependencies] +router-lib = { path = "../router-lib", version = "0.0.1" } +router-feed-lib = { path = "../router-feed-lib", version = "0.1" } +solana-account-decoder = "1.17" +solana-client = { workspace = true } +solana-sdk = { workspace = true } +solana-logger = "1.17" +solana-program = "1.17" +solana-program-test = "1.17" +anchor-lang = "0.29.0" +anchor-spl = "0.29.0" +anyhow = "1.0.86" +itertools = "0.10.5" +async-trait = "0.1.79" +chrono = "0.4.38" +sha2 = "0.10.8" +tracing = "0.1.40" +spl-associated-token-account = "1.0.5" +invariant-types.path = "./src/internal/invariant-types" +decimal = { git = "https://github.com/invariant-labs/protocol", rev = "14da6bde97849ddbdc75a23005bcdeb8105c3385" } + +num-traits = "0.2.18" +thiserror = "1.0.61" +num-derive = "0.3.3" +bytemuck = "1.16.0" +arrayref = "0.3.6" +serde = "1.0" +safe-transmute = "0.11.3" +uint = { workspace = true } + + +[dev-dependencies] +router-test-lib = { path = "../router-test-lib", version = "0.1" } diff --git a/lib/dex-invariant/src/internal/accounts.rs b/lib/dex-invariant/src/internal/accounts.rs new file mode 100644 index 0000000..fe763ed --- /dev/null +++ b/lib/dex-invariant/src/internal/accounts.rs @@ -0,0 +1,136 @@ +use anchor_lang::prelude::*; +use anyhow::Error; +use invariant_types::{SEED, STATE_SEED}; +use router_lib::dex::AccountProviderView; +use solana_sdk::account::ReadableAccount; + +use super::swap::InvariantSwapResult; +use crate::{invariant_edge::InvariantEdge, InvariantDex}; + +#[derive(Clone)] +pub struct InvariantSwapParams<'a> { + pub invariant_swap_result: &'a InvariantSwapResult, + pub owner: Pubkey, + pub source_mint: Pubkey, + pub destination_mint: Pubkey, + pub source_account: Pubkey, + pub destination_account: Pubkey, + pub referral_fee: Option, +} + +#[derive(Clone, Default, Debug)] +pub struct InvariantSwapAccounts { + state: Pubkey, + pool: Pubkey, + tickmap: Pubkey, + token_x: Pubkey, + token_y: Pubkey, + account_x: Pubkey, + account_y: Pubkey, + reserve_x: Pubkey, + reserve_y: Pubkey, + owner: Pubkey, + program_authority: Pubkey, + token_x_program: Pubkey, + token_y_program: Pubkey, + ticks_accounts: Vec, + referral_fee: Option, +} + +impl InvariantSwapAccounts { + pub fn from_pubkeys( + chain_data: &AccountProviderView, + invariant_edge: &InvariantEdge, + pool_pk: Pubkey, + invariant_swap_params: &InvariantSwapParams, + ) -> anyhow::Result<(Self, bool), Error> { + let InvariantSwapParams { + invariant_swap_result, + owner, + source_mint, + destination_mint, + source_account, + destination_account, + referral_fee, + } = invariant_swap_params; + + let (x_to_y, account_x, account_y) = match ( + invariant_edge.pool.token_x.eq(source_mint), + invariant_edge.pool.token_y.eq(destination_mint), + invariant_edge.pool.token_x.eq(destination_mint), + invariant_edge.pool.token_y.eq(source_mint), + ) { + (true, true, _, _) => (true, *source_account, *destination_account), + (_, _, true, true) => (false, *destination_account, *source_account), + _ => return Err(anyhow::Error::msg("Invalid source or destination mint")), + }; + + let ticks_accounts = + InvariantDex::tick_indexes_to_addresses(pool_pk, &invariant_swap_result.used_ticks); + + let token_x_program = *chain_data + .account(&invariant_edge.pool.token_x)? + .account + .owner(); + let token_y_program = *chain_data + .account(&invariant_edge.pool.token_y)? + .account + .owner(); + + let invariant_swap_accounts = Self { + state: Self::get_state_address(crate::ID), + pool: pool_pk, + tickmap: invariant_edge.pool.tickmap, + token_x: invariant_edge.pool.token_x, + token_y: invariant_edge.pool.token_y, + account_x, + account_y, + reserve_x: invariant_edge.pool.token_x_reserve, + reserve_y: invariant_edge.pool.token_y_reserve, + owner: *owner, + program_authority: Self::get_program_authority(crate::ID), + token_x_program, + token_y_program, + ticks_accounts, + referral_fee: *referral_fee, + }; + + Ok((invariant_swap_accounts, x_to_y)) + } + + pub fn to_account_metas(&self) -> Vec { + let mut account_metas: Vec = vec![ + AccountMeta::new_readonly(self.state, false), + AccountMeta::new(self.pool, false), + AccountMeta::new(self.tickmap, false), + AccountMeta::new(self.token_x, false), + AccountMeta::new(self.token_y, false), + AccountMeta::new(self.account_x, false), + AccountMeta::new(self.account_y, false), + AccountMeta::new(self.reserve_x, false), + AccountMeta::new(self.reserve_y, false), + AccountMeta::new(self.owner, true), + AccountMeta::new_readonly(self.program_authority, false), + AccountMeta::new_readonly(self.token_x_program, false), + AccountMeta::new_readonly(self.token_y_program, false), + ]; + + let ticks_metas: Vec = self + .ticks_accounts + .iter() + .map(|tick_address| AccountMeta::new(*tick_address, false)) + .collect(); + + account_metas.extend(ticks_metas); + + account_metas + } + + fn get_program_authority(program_id: Pubkey) -> Pubkey { + Pubkey::find_program_address(&[SEED.as_bytes()], &program_id).0 + } + + fn get_state_address(program_id: Pubkey) -> Pubkey { + Pubkey::find_program_address(&[STATE_SEED.as_bytes()], &program_id).0 + } +} diff --git a/lib/dex-invariant/src/internal/invariant-types/Cargo.toml b/lib/dex-invariant/src/internal/invariant-types/Cargo.toml new file mode 100644 index 0000000..b8943d9 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "invariant-types" +version = "0.1.0" +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + + +[dependencies] +anchor-lang = "0.29.0" +borsh = {version = "0.9.3", features = ["const-generics"]} +decimal = { git = "https://github.com/invariant-labs/protocol", rev = "14da6bde97849ddbdc75a23005bcdeb8105c3385" } +num-traits = "0.2.18" +thiserror = "1.0.61" +num-derive = "0.3.3" +bytemuck = "1.16.0" +arrayref = "0.3.6" +serde = "1.0" +safe-transmute = "0.11.3" +anyhow = "1.0.86" diff --git a/lib/dex-invariant/src/internal/invariant-types/src/decimals.rs b/lib/dex-invariant/src/internal/invariant-types/src/decimals.rs new file mode 100644 index 0000000..854a004 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/decimals.rs @@ -0,0 +1,400 @@ +use core::convert::TryFrom; +use core::convert::TryInto; +pub use decimal::*; + +use anchor_lang::prelude::*; + +use crate::utils::{TrackableError, TrackableResult}; +use crate::{err, function, location}; + +pub const PRICE_LIQUIDITY_DENOMINATOR: u128 = 1__0000_0000__0000_0000__00u128; + +#[decimal(24)] +#[zero_copy] +#[derive( + Default, std::fmt::Debug, PartialEq, Eq, PartialOrd, Ord, AnchorSerialize, AnchorDeserialize, +)] +pub struct Price { + pub v: u128, +} + +#[decimal(6)] +#[account(zero_copy)] +#[derive( + Default, std::fmt::Debug, PartialEq, Eq, PartialOrd, Ord, AnchorSerialize, AnchorDeserialize, +)] +pub struct Liquidity { + pub v: u128, +} + +#[decimal(24)] +#[account(zero_copy)] +#[derive( + Default, std::fmt::Debug, PartialEq, Eq, PartialOrd, Ord, AnchorSerialize, AnchorDeserialize, +)] +pub struct FeeGrowth { + pub v: u128, +} + +#[decimal(12)] +#[account(zero_copy)] +#[derive( + Default, std::fmt::Debug, PartialEq, Eq, PartialOrd, Ord, AnchorSerialize, AnchorDeserialize, +)] +pub struct FixedPoint { + pub v: u128, +} + +// legacy not serializable may implement later +#[decimal(0)] +#[derive(Default, std::fmt::Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)] +pub struct TokenAmount(pub u64); + +impl FeeGrowth { + pub fn unchecked_add(self, other: FeeGrowth) -> FeeGrowth { + FeeGrowth::new(self.get().wrapping_add(other.get())) + } + + pub fn unchecked_sub(self, other: FeeGrowth) -> FeeGrowth { + FeeGrowth::new(self.get().wrapping_sub(other.get())) + } + + pub fn from_fee(liquidity: Liquidity, fee: TokenAmount) -> Self { + FeeGrowth::new( + U256::from(fee.get()) + .checked_mul(FeeGrowth::one()) + .unwrap() + .checked_mul(Liquidity::one()) + .unwrap() + .checked_div(liquidity.here()) + .unwrap() + .try_into() + .unwrap(), + ) + } + + pub fn to_fee(self, liquidity: Liquidity) -> FixedPoint { + FixedPoint::new( + U256::try_from(self.get()) + .unwrap() + .checked_mul(liquidity.here()) + .unwrap() + .checked_div(U256::from(10).pow(U256::from( + FeeGrowth::scale() + Liquidity::scale() - FixedPoint::scale(), + ))) + .unwrap() + .try_into() + .unwrap_or_else(|_| panic!("value too big to parse in `FeeGrowth::to_fee`")), + ) + } +} + +impl FixedPoint { + pub fn unchecked_add(self, other: FixedPoint) -> FixedPoint { + FixedPoint::new(self.get().wrapping_sub(other.get())) + } + + pub fn unchecked_sub(self, other: FixedPoint) -> FixedPoint { + FixedPoint::new(self.get().wrapping_sub(other.get())) + } +} + +impl Price { + pub fn big_div_values_to_token(nominator: U256, denominator: U256) -> Option { + let token_amount = nominator + .checked_mul(Self::one::())? + .checked_div(denominator)? + .checked_div(Self::one::())? + .try_into() + .ok()?; + Some(TokenAmount::new(token_amount)) + } + + pub fn big_div_values_to_token_up(nominator: U256, denominator: U256) -> Option { + let token_amount = nominator + .checked_mul(Self::one::())? + .checked_add(denominator - 1)? + .checked_div(denominator)? + .checked_add(Self::almost_one::())? + .checked_div(Self::one::())? + .try_into() + .ok()?; + + Some(TokenAmount::new(token_amount)) + } + + pub fn big_div_values_up(nominator: U256, denominator: U256) -> Price { + Price::new({ + nominator + .checked_mul(Self::one::()) + .unwrap() + .checked_add(denominator.checked_sub(U256::from(1u32)).unwrap()) + .unwrap() + .checked_div(denominator) + .unwrap() + .try_into() + .unwrap() + }) + } + + pub fn checked_big_div_values_up(nominator: U256, denominator: U256) -> TrackableResult { + Ok(Price::new( + nominator + .checked_mul(Self::one::()) + .ok_or_else(|| err!(TrackableError::MUL))? + .checked_add( + denominator + .checked_sub(U256::from(1u32)) + .ok_or_else(|| err!(TrackableError::SUB))?, + ) + .ok_or_else(|| err!(TrackableError::ADD))? + .checked_div(denominator) + .ok_or_else(|| err!(TrackableError::DIV))? + .try_into() + .map_err(|_| err!(TrackableError::cast::().as_str()))?, + )) + } +} + +#[cfg(test)] +pub mod tests { + use crate::{math::calculate_price_sqrt, structs::MAX_TICK}; + + use super::*; + + #[test] + pub fn test_denominator() { + assert_eq!(Price::from_integer(1).get(), 1_000000_000000_000000_000000); + assert_eq!(Liquidity::from_integer(1).get(), 1_000000); + assert_eq!( + FeeGrowth::from_integer(1).get(), + 1_000000_000000_000000_000000 + ); + assert_eq!(TokenAmount::from_integer(1).get(), 1); + } + + #[test] + pub fn test_ops() { + let result = TokenAmount::from_integer(1).big_mul(Price::from_integer(1)); + assert_eq!(result.get(), 1); + } + + #[test] + fn test_from_fee() { + // One + { + let fee_growth = FeeGrowth::from_fee(Liquidity::from_integer(1), TokenAmount(1)); + assert_eq!(fee_growth, FeeGrowth::from_integer(1)); + } + // Half + { + let fee_growth = FeeGrowth::from_fee(Liquidity::from_integer(2), TokenAmount(1)); + assert_eq!(fee_growth, FeeGrowth::from_scale(5, 1)) + } + // Little + { + let fee_growth = FeeGrowth::from_fee(Liquidity::from_integer(u64::MAX), TokenAmount(1)); + // real 5.42101086242752217003726400434970855712890625 × 10^-20 + // expected 54210 + assert_eq!(fee_growth, FeeGrowth::new(54210)) + } + // Fairly big + { + let fee_growth = + FeeGrowth::from_fee(Liquidity::from_integer(100), TokenAmount(1_000_000)); + assert_eq!(fee_growth, FeeGrowth::from_integer(10000)) + } + } + + #[test] + fn test_to_fee() { + // equal + { + let amount = TokenAmount(100); + let liquidity = Liquidity::from_integer(1_000_000); + + let fee_growth = FeeGrowth::from_fee(liquidity, amount); + let out = fee_growth.to_fee(liquidity); + assert_eq!(out, FixedPoint::from_decimal(amount)); + } + // greater liquidity + { + let amount = TokenAmount(100); + let liquidity_before = Liquidity::from_integer(1_000_000); + let liquidity_after = Liquidity::from_integer(10_000_000); + + let fee_growth = FeeGrowth::from_fee(liquidity_before, amount); + let out = fee_growth.to_fee(liquidity_after); + assert_eq!(out, FixedPoint::from_integer(1000)) + } + // huge liquidity + { + let amount = TokenAmount(100_000_000__000000); + let liquidity = Liquidity::from_integer(2u128.pow(77)); + + let fee_growth = FeeGrowth::from_fee(liquidity, amount); + // real 6.61744490042422139897126953655970282852649688720703125 × 10^-22 + // expected 661744490042422 + assert_eq!(fee_growth, FeeGrowth::new(661744490042422)); + + let out = fee_growth.to_fee(liquidity); + // real 9.9999999999999978859343891977453174784 × 10^25 + // expected 99999999999999978859343891 + assert_eq!(out, FixedPoint::new(99999999999999978859343891)) + } + // overflowing `big_mul` + { + let amount = TokenAmount(600000000000000000); + let liquidity = Liquidity::from_integer(10000000000000000000u128); + + let fee_growth = FeeGrowth::from_fee(liquidity, amount); + // real 0.06 + // expected 0.06 + assert_eq!(fee_growth, FeeGrowth::new(60000000000000000000000)); + + let out = fee_growth.to_fee(liquidity); + // real 600000000000000000 + // expected 99999999999999978859343891 + assert_eq!(out, FixedPoint::from_integer(1) * amount) + } + } + + #[test] + fn test_decimal_ops() { + let liquidity = Liquidity::new(4_902_430_892__340393); + let price: Price = Price::new(9833__489034_289032_430082_130832); + + // real: 4.8208000421189050674873214903955408904296976 × 10^13 + // expected price: 4_8208000421189050674873214903955408904 + // expected liq: 4_8208000421189050674 + + let expected = Liquidity::new(48208000421189050674); + assert_eq!(liquidity.big_mul(price), expected); + assert_eq!(liquidity.big_mul_up(price), expected + Liquidity::new(1)); + + let expected_price = Price::new(48208000421189050674873214903955408904); + assert_eq!(price.big_mul(liquidity), expected_price); + assert_eq!(price.big_mul_up(liquidity), expected_price + Price::new(1)); + } + + #[test] + fn test_big_div_values_to_token() { + // base examples tested in up-level functions + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let almost_max_sqrt_price = calculate_price_sqrt(MAX_TICK - 1); + let almost_min_sqrt_price = calculate_price_sqrt(-MAX_TICK + 1); + + // DOMAIN: + // max_nominator = 22300535562308408361215204585786568048575995442267771385000000000000 (< 2^224) + // max_no_overflow_nominator = 115792089237316195423570985008687907853269984665640564 (< 2^177) + // max_denominator = 4294671819208808709990254332190838 (< 2^112) + // min_denominator = 232846648345740 (< 2^48) + let max_nominator: U256 = U256::from(max_sqrt_price.v) * U256::from(u128::MAX); + let max_no_overflow_nominator: U256 = U256::MAX / Price::one::(); + let min_denominator: U256 = min_sqrt_price.big_mul_to_value_up(almost_min_sqrt_price); + let max_denominator = max_sqrt_price.big_mul_to_value_up(almost_max_sqrt_price); + + // overflow due too large nominator (max nominator) + { + let result = Price::big_div_values_to_token(max_nominator, min_denominator); + assert!(result.is_none()) + } + // overflow due too large nominator (min overflow nominator) + { + let result = + Price::big_div_values_to_token(max_no_overflow_nominator + 1, min_denominator); + assert!(result.is_none()) + } + // result not fits into u64 type (without overflow) + { + let result = Price::big_div_values_to_token(max_no_overflow_nominator, min_denominator); + assert!(result.is_none()) + } + // result fits intro u64 type (with max denominator) + { + let result = + Price::big_div_values_to_token(max_no_overflow_nominator / 2, max_denominator); + assert_eq!(result, Some(TokenAmount(13480900766318407300u64))); + } + } + + #[test] + fn test_big_div_values_to_token_up() { + // base examples tested in up-level functions + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let almost_max_sqrt_price = calculate_price_sqrt(MAX_TICK - 1); + let almost_min_sqrt_price = calculate_price_sqrt(-MAX_TICK + 1); + + // DOMAIN: + // max_nominator = 22300535562308408361215204585786568048575995442267771385000000000000 (< 2^224) + // max_no_overflow_nominator = 115792089237316195423570985008687907853269984665640564 (< 2^177) + // max_denominator = 4294671819208808709990254332190838 (< 2^112) + // min_denominator = 232846648345740 (< 2^48) + let max_nominator: U256 = U256::from(max_sqrt_price.v) * U256::from(u128::MAX); + let max_no_overflow_nominator: U256 = U256::MAX / Price::one::(); + let min_denominator: U256 = min_sqrt_price.big_mul_to_value(almost_min_sqrt_price); + let max_denominator = max_sqrt_price.big_mul_to_value(almost_max_sqrt_price); + + // overflow due too large nominator (max nominator) + { + let result = Price::big_div_values_to_token_up(max_nominator, min_denominator); + assert!(result.is_none()) + } + // overflow due too large nominator (min overflow nominator) + { + let result = + Price::big_div_values_to_token_up(max_no_overflow_nominator + 1, min_denominator); + assert!(result.is_none()) + } + // overflow due too large denominator + { + let result = + Price::big_div_values_to_token_up(max_no_overflow_nominator, max_denominator); + assert!(result.is_none()); + } + // result not fits into u64 type (without overflow) + { + let result = + Price::big_div_values_to_token_up(max_no_overflow_nominator, min_denominator); + assert!(result.is_none()) + } + // result fits intro u64 type (with max denominator) + { + let result = + Price::big_div_values_to_token_up(max_no_overflow_nominator / 2, max_denominator); + assert_eq!(result, Some(TokenAmount(13480900766318407301u64))); + } + } + + #[test] + fn test_price_overflow() { + // max_sqrt_price + { + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + + let result = max_sqrt_price.big_mul_to_value(max_sqrt_price); + let result_up = max_sqrt_price.big_mul_to_value_up(max_sqrt_price); + let expected_result = U256::from(4294886547443978352291489402946609u128); + + // real: 4294841257.231131321329014894029466 + // expected: 4294886547.443978352291489402946609 + assert_eq!(result, expected_result); + assert_eq!(result_up, expected_result); + } + // min_sqrt_price + { + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + + let result = min_sqrt_price.big_mul_to_value(min_sqrt_price); + let result_up = min_sqrt_price.big_mul_to_value_up(min_sqrt_price); + let expected_result = U256::from(232835005780624u128); + + // real: 0.000000000232835005780624 + // expected: 0.000000000232835005780624 + assert_eq!(result, expected_result); + assert_eq!(result_up, expected_result); + } + } +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/errors.rs b/lib/dex-invariant/src/internal/invariant-types/src/errors.rs new file mode 100644 index 0000000..cf24c3d --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/errors.rs @@ -0,0 +1,67 @@ +use anchor_lang::prelude::*; + +#[error_code] +pub enum InvariantErrorCode { + #[msg("Amount is zero")] + ZeroAmount = 0, // 1770 + #[msg("Output would be zero")] + ZeroOutput = 1, // 1771 + #[msg("Not the expected tick")] + WrongTick = 2, // 1772 + #[msg("Price limit is on the wrong side of price")] + WrongLimit = 3, // 1773 + #[msg("Tick index not divisible by spacing or over limit")] + InvalidTickIndex = 4, // 1774 + #[msg("Invalid tick_lower or tick_upper")] + InvalidTickInterval = 5, // 1775 + #[msg("There is no more tick in that direction")] + NoMoreTicks = 6, // 1776 + #[msg("Correct tick not found in context")] + TickNotFound = 7, // 1777 + #[msg("Price would cross swap limit")] + PriceLimitReached = 8, // 1778 + #[msg("Invalid tick liquidity")] + InvalidTickLiquidity = 9, // 1779 + #[msg("Disable empty position pokes")] + EmptyPositionPokes = 10, // 177a + #[msg("Invalid tick liquidity")] + InvalidPositionLiquidity = 11, // 177b + #[msg("Invalid pool liquidity")] + InvalidPoolLiquidity = 12, // 177c + #[msg("Invalid position index")] + InvalidPositionIndex = 13, // 177d + #[msg("Position liquidity would be zero")] + PositionWithoutLiquidity = 14, // 177e + #[msg("You are not admin")] + Unauthorized = 15, // 177f + #[msg("Invalid pool token addresses")] + InvalidPoolTokenAddresses = 16, // 1780 + #[msg("Time cannot be negative")] + NegativeTime = 17, // 1781 + #[msg("Oracle is already initialized")] + OracleAlreadyInitialized = 18, // 1782 + #[msg("Absolute price limit was reached")] + LimitReached = 19, // 1783 + #[msg("Invalid protocol fee")] + InvalidProtocolFee = 20, // 1784 + #[msg("Swap amount out is 0")] + NoGainSwap = 21, // 1785 + #[msg("Provided token account is different than expected")] + InvalidTokenAccount = 22, // 1786 + #[msg("Admin address is different than expected")] + InvalidAdmin = 23, // 1787 + #[msg("Provided authority is different than expected")] + InvalidAuthority = 24, // 1788 + #[msg("Provided token owner is different than expected")] + InvalidOwner = 25, // 1789 + #[msg("Provided token account mint is different than expected mint token")] + InvalidMint = 26, // 178a + #[msg("Provided tickmap is different than expected")] + InvalidTickmap = 27, // 178b + #[msg("Provided tickmap owner is different than program ID")] + InvalidTickmapOwner = 28, // 178c + #[msg("Recipient list address and owner list address should be different")] + InvalidListOwner = 29, // 178d + #[msg("Invalid tick spacing")] + InvalidTickSpacing = 30, // 178e +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/lib.rs b/lib/dex-invariant/src/internal/invariant-types/src/lib.rs new file mode 100644 index 0000000..8fb4ebd --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/lib.rs @@ -0,0 +1,18 @@ +pub mod decimals; +pub mod errors; +pub mod log; +pub mod macros; +pub mod math; +pub mod structs; +pub mod utils; + +use anchor_lang::prelude::*; + +declare_id!("HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt"); +pub const SEED: &str = "Invariant"; +pub const STATE_SEED: &str = "statev1"; +pub const TICK_SEED: &str = "tickv1"; +pub const ANCHOR_DISCRIMINATOR_SIZE: usize = 8; +pub const MAX_VIRTUAL_CROSS: u16 = 10; +pub const MAX_SQRT_PRICE: u128 = 65535383934512647000000000000; +pub const MIN_SQRT_PRICE: u128 = 15258932000000000000; diff --git a/lib/dex-invariant/src/internal/invariant-types/src/log.rs b/lib/dex-invariant/src/internal/invariant-types/src/log.rs new file mode 100644 index 0000000..9de453f --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/log.rs @@ -0,0 +1,549 @@ +use crate::{decimals::*, math::calculate_price_sqrt}; + +const LOG2_SCALE: u8 = 32; +const LOG2_DOUBLE_SCALE: u8 = 64; +const LOG2_ONE: u128 = 1 << LOG2_SCALE; +const LOG2_HALF: u64 = (LOG2_ONE >> 1) as u64; +const LOG2_TWO: u128 = LOG2_ONE << 1; +const LOG2_DOUBLE_ONE: u128 = 1 << LOG2_DOUBLE_SCALE; +const LOG2_SQRT_10001: u64 = 309801; +const LOG2_NEGATIVE_MAX_LOSE: u64 = 300000; // max accuracy in <-MAX_TICK, 0> domain +const LOG2_MIN_BINARY_POSITION: i32 = 15; // accuracy = 2^(-15) +const LOG2_ACCURACY: u64 = 1u64 << (31 - LOG2_MIN_BINARY_POSITION); +const PRICE_DENOMINATOR: u128 = 1_000000_000000_000000_000000; + +fn price_to_x32(decimal: Price) -> u64 { + decimal + .v + .checked_mul(LOG2_ONE) + .unwrap() + .checked_div(PRICE_DENOMINATOR) + .unwrap() as u64 +} + +fn align_tick_to_spacing(accurate_tick: i32, tick_spacing: i32) -> i32 { + match accurate_tick > 0 { + true => accurate_tick - (accurate_tick % tick_spacing), + false => accurate_tick - (accurate_tick.rem_euclid(tick_spacing)), + } +} + +fn log2_floor_x32(mut sqrt_price_x32: u64) -> u64 { + let mut msb = 0; + + if sqrt_price_x32 >= 1u64 << 32 { + sqrt_price_x32 >>= 32; + msb |= 32; + }; + if sqrt_price_x32 >= 1u64 << 16 { + sqrt_price_x32 >>= 16; + msb |= 16; + }; + if sqrt_price_x32 >= 1u64 << 8 { + sqrt_price_x32 >>= 8; + msb |= 8; + }; + if sqrt_price_x32 >= 1u64 << 4 { + sqrt_price_x32 >>= 4; + msb |= 4; + }; + if sqrt_price_x32 >= 1u64 << 2 { + sqrt_price_x32 >>= 2; + msb |= 2; + }; + if sqrt_price_x32 >= 1u64 << 1 { + msb |= 1; + }; + + msb +} + +fn log2_iterative_approximation_x32(mut sqrt_price_x32: u64) -> (bool, u64) { + let mut sign = true; + // log2(x) = -log2(1/x), when x < 1 + if (sqrt_price_x32 as u128) < LOG2_ONE { + sign = false; + sqrt_price_x32 = (LOG2_DOUBLE_ONE / (sqrt_price_x32 as u128 + 1)) as u64 + } + let log2_floor = log2_floor_x32(sqrt_price_x32 >> LOG2_SCALE); + let mut result = log2_floor << LOG2_SCALE; + let mut y: u128 = (sqrt_price_x32 as u128) >> log2_floor; + + if y == LOG2_ONE { + return (sign, result); + }; + let mut delta: u64 = LOG2_HALF; + while delta > LOG2_ACCURACY { + y = y * y / LOG2_ONE; + if y >= LOG2_TWO { + result |= delta; + y >>= 1; + } + delta >>= 1; + } + (sign, result) +} + +pub fn get_tick_at_sqrt_price(sqrt_price_decimal: Price, tick_spacing: u16) -> i32 { + let sqrt_price_x32: u64 = price_to_x32(sqrt_price_decimal); + let (log2_sign, log2_sqrt_price) = log2_iterative_approximation_x32(sqrt_price_x32); + + let abs_floor_tick: i32 = match log2_sign { + true => log2_sqrt_price / LOG2_SQRT_10001, + false => (log2_sqrt_price + LOG2_NEGATIVE_MAX_LOSE) / LOG2_SQRT_10001, + } as i32; + + let nearer_tick = match log2_sign { + true => abs_floor_tick, + false => -abs_floor_tick, + }; + let farther_tick = match log2_sign { + true => abs_floor_tick + 1, + false => -abs_floor_tick - 1, + }; + let farther_tick_with_spacing = align_tick_to_spacing(farther_tick, tick_spacing as i32); + let nearer_tick_with_spacing = align_tick_to_spacing(nearer_tick, tick_spacing as i32); + if farther_tick_with_spacing == nearer_tick_with_spacing { + return nearer_tick_with_spacing; + }; + + let accurate_tick = match log2_sign { + true => { + let farther_tick_sqrt_price_decimal = calculate_price_sqrt(farther_tick); + match sqrt_price_decimal >= farther_tick_sqrt_price_decimal { + true => farther_tick_with_spacing, + false => nearer_tick_with_spacing, + } + } + false => { + let nearer_tick_sqrt_price_decimal = calculate_price_sqrt(nearer_tick); + match nearer_tick_sqrt_price_decimal <= sqrt_price_decimal { + true => nearer_tick_with_spacing, + false => farther_tick_with_spacing, + } + } + }; + match tick_spacing > 1 { + true => align_tick_to_spacing(accurate_tick, tick_spacing as i32), + false => accurate_tick, + } +} + +#[cfg(test)] +mod tests { + use crate::{math::calculate_price_sqrt, structs::MAX_TICK}; + + use super::*; + + #[test] + fn test_price_to_u64() { + // min sqrt price -> sqrt(1.0001)^MIN_TICK + { + let min_sqrt_price_decimal = calculate_price_sqrt(-MAX_TICK); + let min_sqrt_price_x32 = price_to_x32(min_sqrt_price_decimal); + + let expected_min_sqrt_price_x32 = 65536; + assert_eq!(min_sqrt_price_x32, expected_min_sqrt_price_x32); + } + // max sqrt price -> sqrt(1.0001)^MAX_TICK + { + let max_sqrt_price_decimal = calculate_price_sqrt(MAX_TICK); + let max_sqrt_price_x32 = price_to_x32(max_sqrt_price_decimal); + + let expected_max_sqrt_price_x32 = 281472330729535; + assert_eq!(max_sqrt_price_x32, expected_max_sqrt_price_x32); + } + } + + #[test] + fn test_log2_x32() { + // log2 of 1 + { + let sqrt_price_decimal = Price::from_integer(1); + let sqrt_price_x32 = price_to_x32(sqrt_price_decimal); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, true); + assert_eq!(value, 0); + } + // log2 > 0 when x > 1 + { + let sqrt_price_decimal = Price::from_integer(879); + let sqrt_price_x32 = price_to_x32(sqrt_price_decimal); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, true); + assert_eq!(value, 42003464192); + } + // log2 < 0 when x < 1 + { + let sqrt_price_decimal = Price::from_scale(59, 4); + let sqrt_price_x32 = price_to_x32(sqrt_price_decimal); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, false); + assert_eq!(value, 31804489728); + } + // log2 of max sqrt price + { + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + let sqrt_price_x32 = price_to_x32(max_sqrt_price); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, true); + assert_eq!(value, 68719345664); + } + // log2 of min sqrt price + { + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let sqrt_price_x32 = price_to_x32(min_sqrt_price); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, false); + assert_eq!(value, 68719345664); + } + // log2 of sqrt(1.0001^(-19_999)) - 1 + { + let mut sqrt_price_decimal = calculate_price_sqrt(-19_999); + sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let sqrt_price_x32 = price_to_x32(sqrt_price_decimal); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, false); + assert_eq!(value, 6195642368); + } + // log2 of sqrt(1.0001^(19_999)) + 1 + { + let mut sqrt_price_decimal = calculate_price_sqrt(19_999); + sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let sqrt_price_x32 = price_to_x32(sqrt_price_decimal); + let (sign, value) = log2_iterative_approximation_x32(sqrt_price_x32); + assert_eq!(sign, true); + assert_eq!(value, 6195642368); + } + } + + #[test] + fn test_get_tick_at_sqrt_price_x32() { + // around 0 tick + { + // get tick at 1 + { + let sqrt_price_decimal = Price::from_integer(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, 0); + } + // get tick slightly below 1 + { + let sqrt_price_decimal = Price::from_integer(1) - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -1); + } + // get tick slightly above 1 + { + let sqrt_price_decimal = Price::from_integer(1) + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, 0); + } + } + // around 1 tick + { + let sqrt_price_decimal = calculate_price_sqrt(1); + // get tick at sqrt(1.0001) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, 1); + } + // get tick slightly below sqrt(1.0001) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, 0); + } + // get tick slightly above sqrt(1.0001) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, 1); + } + } + // around -1 tick + { + let sqrt_price_decimal = calculate_price_sqrt(-1); + // get tick at sqrt(1.0001^(-1)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -1); + } + // get tick slightly below sqrt(1.0001^(-1)) + { + let sqrt_price_decimal = calculate_price_sqrt(-1) - Price::new(1); + + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -2); + } + // get tick slightly above sqrt(1.0001^(-1)) + { + let sqrt_price_decimal = calculate_price_sqrt(-1) + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -1); + } + } + // around max - 1 tick + { + let sqrt_price_decimal = calculate_price_sqrt(MAX_TICK - 1); + // get tick at sqrt(1.0001^(MAX_TICK - 1)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, MAX_TICK - 1); + } + // get tick slightly below sqrt(1.0001^(MAX_TICK - 1)) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, MAX_TICK - 2); + } + // get tick slightly above sqrt(1.0001^(MAX_TICK - 1)) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, MAX_TICK - 1); + } + } + // around min + 1 tick + { + let sqrt_price_decimal = calculate_price_sqrt(-(MAX_TICK - 1)); + // get tick at sqrt(1.0001^(-MAX_TICK + 1)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -(MAX_TICK - 1)); + } + // get tick slightly below sqrt(1.0001^(-MAX_TICK + 1)) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -MAX_TICK); + } + // get tick slightly above sqrt(1.0001^(-MAX_TICK + 1)) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -(MAX_TICK - 1)); + } + } + //get tick slightly below at max tick + { + let max_sqrt_price = Price::from_scale(655354, 1); + let sqrt_price_decimal = max_sqrt_price - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, MAX_TICK); + } + // around 19_999 tick + { + let expected_tick = 19_999; + let sqrt_price_decimal = calculate_price_sqrt(expected_tick); + // get tick at sqrt(1.0001^19_999) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^19_999) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick - 1); + } + // get tick slightly above sqrt(1.0001^19_999) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + } + // around -19_999 tick + { + let expected_tick = -19_999; + let sqrt_price_decimal = calculate_price_sqrt(expected_tick); + // get tick at sqrt(1.0001^(-19_999)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^(-19_999)) + { + // let sqrt_price_decimal = sqrt_price_decimal - Decimal::new(150); + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick - 1); + } + // get tick slightly above sqrt(1.0001^(-19_999)) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + } + //get tick slightly above at min tick + { + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let sqrt_price_decimal = min_sqrt_price + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, -MAX_TICK); + } + } + + #[test] + fn test_align_tick_with_spacing() { + // zero + { + let accurate_tick = 0; + let tick_spacing = 3; + + let tick_with_spacing = align_tick_to_spacing(accurate_tick, tick_spacing); + assert_eq!(tick_with_spacing, 0); + } + // positive + { + let accurate_tick = 14; + let tick_spacing = 10; + + let tick_with_spacing = align_tick_to_spacing(accurate_tick, tick_spacing); + assert_eq!(tick_with_spacing, 10); + } + // positive at tick + { + let accurate_tick = 20; + let tick_spacing = 10; + + let tick_with_spacing = align_tick_to_spacing(accurate_tick, tick_spacing); + assert_eq!(tick_with_spacing, 20); + } + // negative + { + let accurate_tick = -14; + let tick_spacing = 10; + + let tick_with_spacing = align_tick_to_spacing(accurate_tick, tick_spacing); + assert_eq!(tick_with_spacing, -20); + } + // negative at tick + { + let accurate_tick = -120; + let tick_spacing = 3; + + let tick_with_spacing = align_tick_to_spacing(accurate_tick, tick_spacing); + assert_eq!(tick_with_spacing, -120); + } + } + + #[test] + fn test_all_positive_ticks() { + for n in 0..MAX_TICK { + { + let expected_tick = n; + let sqrt_price_decimal = calculate_price_sqrt(expected_tick); + // get tick at sqrt(1.0001^(n)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick - 1); + } + // get tick slightly above sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + } + } + } + + #[test] + fn test_all_negative_ticks() { + for n in 0..MAX_TICK { + { + let expected_tick = -n; + let sqrt_price_decimal = calculate_price_sqrt(expected_tick); + // get tick at sqrt(1.0001^(n)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick - 1); + } + // get tick slightly above sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, 1); + assert_eq!(tick, expected_tick); + } + } + } + } + + #[test] + fn test_all_positive_tick_spacing_greater_than_1() { + let tick_spacing: i32 = 3; + for n in 0..MAX_TICK { + { + let input_tick = n; + let sqrt_price_decimal = calculate_price_sqrt(input_tick); + // get tick at sqrt(1.0001^(n)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick, tick_spacing); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick - 1, tick_spacing); + assert_eq!(tick, expected_tick); + } + // get tick slightly above sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick, tick_spacing); + assert_eq!(tick, expected_tick); + } + } + } + } + + #[test] + fn test_all_negative_tick_spacing_greater_than_1() { + let tick_spacing: i32 = 4; + for n in 0..MAX_TICK { + { + let input_tick = -n; + let sqrt_price_decimal = calculate_price_sqrt(input_tick); + // get tick at sqrt(1.0001^(n)) + { + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick, tick_spacing); + assert_eq!(tick, expected_tick); + } + // get tick slightly below sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal - Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick - 1, tick_spacing); + assert_eq!(tick, expected_tick); + } + // get tick slightly above sqrt(1.0001^n) + { + let sqrt_price_decimal = sqrt_price_decimal + Price::new(1); + let tick = get_tick_at_sqrt_price(sqrt_price_decimal, tick_spacing as u16); + let expected_tick = align_tick_to_spacing(input_tick, tick_spacing); + assert_eq!(tick, expected_tick); + } + } + } + } +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/macros.rs b/lib/dex-invariant/src/internal/invariant-types/src/macros.rs new file mode 100644 index 0000000..9a34875 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/macros.rs @@ -0,0 +1,8 @@ +#[macro_export] +macro_rules! size { + ($name: ident) => { + impl $name { + pub const LEN: usize = std::mem::size_of::<$name>() + 8; + } + }; +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/math.rs b/lib/dex-invariant/src/internal/invariant-types/src/math.rs new file mode 100644 index 0000000..4e3bb12 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/math.rs @@ -0,0 +1,2129 @@ +use crate::{err, from_result, function, location, ok_or_mark_trace, structs::TickmapView, trace}; +use std::{cell::RefMut, convert::TryInto}; + +use anchor_lang::*; + +use crate::{ + decimals::*, + errors::InvariantErrorCode, + structs::{get_search_limit, Pool, Tick, Tickmap, MAX_TICK, TICK_LIMIT}, + utils::{TrackableError, TrackableResult}, +}; + +#[derive(PartialEq, Debug)] +pub struct SwapResult { + pub next_price_sqrt: Price, + pub amount_in: TokenAmount, + pub amount_out: TokenAmount, + pub fee_amount: TokenAmount, +} + +// converts ticks to price with reduced precision +pub fn calculate_price_sqrt(tick_index: i32) -> Price { + // checking if tick be converted to price (overflows if more) + let tick = tick_index.abs(); + assert!(tick <= MAX_TICK, "tick over bounds"); + + let mut price = FixedPoint::from_integer(1); + + if tick & 0x1 != 0 { + price *= FixedPoint::new(1000049998750); + } + if tick & 0x2 != 0 { + price *= FixedPoint::new(1000100000000); + } + if tick & 0x4 != 0 { + price *= FixedPoint::new(1000200010000); + } + if tick & 0x8 != 0 { + price *= FixedPoint::new(1000400060004); + } + if tick & 0x10 != 0 { + price *= FixedPoint::new(1000800280056); + } + if tick & 0x20 != 0 { + price *= FixedPoint::new(1001601200560); + } + if tick & 0x40 != 0 { + price *= FixedPoint::new(1003204964963); + } + if tick & 0x80 != 0 { + price *= FixedPoint::new(1006420201726); + } + if tick & 0x100 != 0 { + price *= FixedPoint::new(1012881622442); + } + if tick & 0x200 != 0 { + price *= FixedPoint::new(1025929181080); + } + if tick & 0x400 != 0 { + price *= FixedPoint::new(1052530684591); + } + if tick & 0x800 != 0 { + price *= FixedPoint::new(1107820842005); + } + if tick & 0x1000 != 0 { + price *= FixedPoint::new(1227267017980); + } + if tick & 0x2000 != 0 { + price *= FixedPoint::new(1506184333421); + } + if tick & 0x4000 != 0 { + price *= FixedPoint::new(2268591246242); + } + if tick & 0x8000 != 0 { + price *= FixedPoint::new(5146506242525); + } + if tick & 0x0001_0000 != 0 { + price *= FixedPoint::new(26486526504348); + } + if tick & 0x0002_0000 != 0 { + price *= FixedPoint::new(701536086265529); + } + + // Parsing to the Price type by the end by convention (should always have 12 zeros at the end) + if tick_index >= 0 { + Price::from_decimal(price) + } else { + Price::from_decimal(FixedPoint::from_integer(1).big_div(price)) + } +} + +// Finds closes initialized tick in direction of trade +// and compares its price to the price limit of the trade +pub fn get_closer_limit( + sqrt_price_limit: Price, + x_to_y: bool, + current_tick: i32, // tick already scaled by tick_spacing + tick_spacing: u16, + tickmap: &TickmapView, +) -> Result<(Price, Option<(i32, bool)>)> { + // find initalized tick (None also for virtual tick limiated by search scope) + let closes_tick_index = if x_to_y { + tickmap.prev_initialized(current_tick, tick_spacing) + } else { + tickmap.next_initialized(current_tick, tick_spacing) + }; + + match closes_tick_index { + Some(index) => { + let price = calculate_price_sqrt(index); + // trunk-ignore(clippy/if_same_then_else) + if x_to_y && price > sqrt_price_limit { + Ok((price, Some((index, true)))) + } else if !x_to_y && price < sqrt_price_limit { + Ok((price, Some((index, true)))) + } else { + Ok((sqrt_price_limit, None)) + } + } + None => { + let index = get_search_limit(current_tick, tick_spacing, !x_to_y); + let price = calculate_price_sqrt(index); + + require!(current_tick != index, InvariantErrorCode::LimitReached); + + // trunk-ignore(clippy/if_same_then_else) + if x_to_y && price > sqrt_price_limit { + Ok((price, Some((index, false)))) + } else if !x_to_y && price < sqrt_price_limit { + Ok((price, Some((index, false)))) + } else { + Ok((sqrt_price_limit, None)) + } + } + } +} + +pub fn compute_swap_step( + current_price_sqrt: Price, + target_price_sqrt: Price, + liquidity: Liquidity, // pool.liquidity + amount: TokenAmount, // reaming_amount (input or output depending on by_amount_in) + by_amount_in: bool, + fee: FixedPoint, // pool.fee +) -> TrackableResult { + if liquidity.is_zero() { + return Ok(SwapResult { + next_price_sqrt: target_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(0), + }); + } + + let x_to_y = current_price_sqrt >= target_price_sqrt; + + let next_price_sqrt; + let mut amount_in = TokenAmount(0); + let mut amount_out = TokenAmount(0); + + if by_amount_in { + // take fee in input_amount + // U256(2^64) * U256(1e12) - no overflow in intermediate operations + // no overflow in token_amount result + let amount_after_fee = amount.big_mul( + FixedPoint::from_integer(1u8) + .checked_sub(fee) + .map_err(|_| err!("sub underflow"))?, + ); + + amount_in = if x_to_y { + get_delta_x(target_price_sqrt, current_price_sqrt, liquidity, true) + } else { + get_delta_y(current_price_sqrt, target_price_sqrt, liquidity, true) + } + .unwrap_or(TokenAmount(u64::MAX)); + + // if target price was hit it will be the next price + if amount_after_fee >= amount_in { + next_price_sqrt = target_price_sqrt + } else { + // DOMAIN: + // liquidity = U128::MAX + // amount_after_fee = U64::MAX + // current_price_sqrt = entire price space + next_price_sqrt = ok_or_mark_trace!(get_next_sqrt_price_from_input( + current_price_sqrt, + liquidity, + amount_after_fee, + x_to_y, + ))?; + }; + } else { + amount_out = if x_to_y { + get_delta_y(target_price_sqrt, current_price_sqrt, liquidity, false) + } else { + get_delta_x(current_price_sqrt, target_price_sqrt, liquidity, false) + } + .unwrap_or(TokenAmount(u64::MAX)); + + if amount >= amount_out { + next_price_sqrt = target_price_sqrt + } else { + next_price_sqrt = ok_or_mark_trace!(get_next_sqrt_price_from_output( + current_price_sqrt, + liquidity, + amount, + x_to_y + ))?; + } + } + + let not_max = target_price_sqrt != next_price_sqrt; + + if x_to_y { + if not_max || !by_amount_in { + amount_in = get_delta_x(next_price_sqrt, current_price_sqrt, liquidity, true) + .ok_or_else(|| err!("get_delta_x overflow"))?; + }; + if not_max || by_amount_in { + amount_out = get_delta_y(next_price_sqrt, current_price_sqrt, liquidity, false) + .ok_or_else(|| err!("get_delta_y overflow"))?; + } + } else { + if not_max || !by_amount_in { + amount_in = get_delta_y(current_price_sqrt, next_price_sqrt, liquidity, true) + .ok_or_else(|| err!("get_delta_y overflow"))?; + }; + if not_max || by_amount_in { + amount_out = get_delta_x(current_price_sqrt, next_price_sqrt, liquidity, false) + .ok_or_else(|| err!("get_delta_x overflow"))?; + }; + } + + // Amount out can not exceed amount + if !by_amount_in && amount_out > amount { + amount_out = amount; + } + + let fee_amount = if by_amount_in && next_price_sqrt != target_price_sqrt { + // no possible to overflow in intermediate operations + // edge case occurs when the next_price is target_price (minimal distance to target) + amount + .checked_sub(amount_in) + .map_err(|_| err!("sub underflow"))? + } else { + // no possible to overflow in intermediate operations + // edge case when amount_in is maximum and fee is maximum + amount_in.big_mul_up(fee) + }; + + Ok(SwapResult { + next_price_sqrt, + amount_in, + amount_out, + fee_amount, + }) +} + +// delta x = (L * delta_sqrt_price) / (lower_sqrt_price * higher_sqrt_price) +pub fn get_delta_x( + sqrt_price_a: Price, + sqrt_price_b: Price, + liquidity: Liquidity, + up: bool, +) -> Option { + let delta_price = if sqrt_price_a > sqrt_price_b { + sqrt_price_a - sqrt_price_b + } else { + sqrt_price_b - sqrt_price_a + }; + + let nominator = delta_price.big_mul_to_value(liquidity); + match up { + true => Price::big_div_values_to_token_up( + nominator, + sqrt_price_a.big_mul_to_value(sqrt_price_b), + ), + false => Price::big_div_values_to_token( + nominator, + sqrt_price_a.big_mul_to_value_up(sqrt_price_b), + ), + } +} + +// delta y = L * delta_sqrt_price +pub fn get_delta_y( + sqrt_price_a: Price, + sqrt_price_b: Price, + liquidity: Liquidity, + up: bool, +) -> Option { + let delta_price = if sqrt_price_a > sqrt_price_b { + sqrt_price_a - sqrt_price_b + } else { + sqrt_price_b - sqrt_price_a + }; + + match match up { + true => delta_price + .big_mul_to_value_up(liquidity) + .checked_add(Price::almost_one()) + .unwrap() + .checked_div(Price::one()) + .unwrap() + .try_into(), + false => delta_price + .big_mul_to_value(liquidity) + .checked_div(Price::one()) + .unwrap() + .try_into(), + } { + Ok(x) => Some(TokenAmount(x)), + Err(_) => None, + } +} + +fn get_next_sqrt_price_from_input( + price_sqrt: Price, + liquidity: Liquidity, + amount: TokenAmount, + x_to_y: bool, +) -> TrackableResult { + if liquidity.is_zero() { + return Err(err!("getting next price from input with zero liquidity")); + } + if price_sqrt.is_zero() { + return Err(err!("getting next price from input with zero price")); + } + // DOMAIN: + // price_sqrt + // pool.liquidity <1, u128::MAX> + // amount <1, u64::MAX> + + let result = if x_to_y { + // checked + get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, true) + } else { + // checked + get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, true) + }; + ok_or_mark_trace!(result) +} + +fn get_next_sqrt_price_from_output( + price_sqrt: Price, + liquidity: Liquidity, + amount: TokenAmount, + x_to_y: bool, +) -> TrackableResult { + // DOMAIN: + // price_sqrt + // pool.liquidity <1, u128::MAX> + // amount <1, u64::MAX> + + if liquidity.is_zero() { + return Err(err!("getting next price from output with zero liquidity")); + } + if price_sqrt.is_zero() { + return Err(err!("getting next price from output with zero price")); + } + + let result = if x_to_y { + get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, false) + } else { + get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, false) + }; + ok_or_mark_trace!(result) +} + +// L * price / (L +- amount * price) +fn get_next_sqrt_price_x_up( + price_sqrt: Price, + liquidity: Liquidity, + amount: TokenAmount, + add: bool, +) -> TrackableResult { + // DOMAIN: + // In case add always true + // pool.liquidity = U128::MAX + // amount = U64::MAX + // price_sqrt = entire price space + + if amount.is_zero() { + return Ok(price_sqrt); + }; + + // PRICE_LIQUIDITY_DENOMINATOR = 10 ^ (24 - 6) + // max_big_liquidity -> ceil(log2(2^128 * 10^18)) = 188 + // no possibility of overflow here + let big_liquidity = liquidity + .here::() + .checked_mul(U256::from(PRICE_LIQUIDITY_DENOMINATOR)) // extends liquidity precision (operation on U256, so there is no dividing by denominator) + .ok_or_else(|| err!("mul overflow"))?; + + // max(price * amount) + // ceil(log2(max_price * 2^64))= 160 + // U256::from(max_price) * U256::from(2^64) / U256::(1) + // so not possible to overflow here + let denominator = from_result!(match add { + // max_denominator = L + amount * price [maximize all parameters] + // max_denominator 2^128 + 2^64 * 2^96 = 2^161 <- no possible to overflow + true => big_liquidity.checked_add(price_sqrt.big_mul_to_value(amount)), + false => big_liquidity.checked_sub(price_sqrt.big_mul_to_value(amount)), + } + .ok_or_else(|| "big_liquidity -/+ price_sqrt * amount"))?; // never should be triggered + + // max_nominator = (U256::from(max_price) * U256::from(max_liquidity) + 10^6) / 10^6 + // max_nominator = (2^96 * 2^128 + 10^6) / 10^6 + // ceil(log2(2^96 * 2^128 + 10^6)) = 225 + // ceil(log2((2^96 * 2^128 + 10^6)/10^6)) = 205 + // ceil(lg2(max_nominator)) = 205 + // no possibility of overflowing in the result or in intermediate calculations + + // result = div_up(nominator, denominator) -> so maximizing nominator while minimizing denominator + // max_results = (max_nominator * Price::one + min_denominator) / min_denominator + // (2^205 * 10^24 + 1) / 1 = 2^285 <- possible to overflow in result + + // maximize nominator -> (max_nominator * Price::one + max_denominator) + // 2^205 * 10^24 + 2^161 = 2^285 <- possible to overflow in intermediate operations + ok_or_mark_trace!(Price::checked_big_div_values_up( + price_sqrt.big_mul_to_value_up(liquidity), + denominator + )) +} + +// price +- (amount / L) +fn get_next_sqrt_price_y_down( + price_sqrt: Price, + liquidity: Liquidity, + amount: TokenAmount, + add: bool, +) -> TrackableResult { + // DOMAIN: + // price_sqrt + // pool.liquidity <1, u128::MAX> (zero liquidity not possible) + // amount <1, u64::MAX> + + // quotient= amount / L + // PRICE_LIQUIDITY_DENOMINATOR = 10 ^ (24 - 6) + + if add { + // Price::from_scale(amount, TokenAmount::scale()) + // max_nominator = max_amount * 10^24 => 2^144 so possible to overflow here + + // max_denominator = max_liquidity + // max_denominator = U256(u128::MAX) * U256(10^18) + // max_denominator = U256(2^128 * 10^18) ~ 2^188 so no possible to overflow + + // quotient - max quotient nominator + // quotient_max_nominator = U256(max_nominator) * U256(10^24) + // quotient_max_nominator = 2^128 * 10^24 ~ 2^208 so no possible to overflow in intermediate operations + + // max_quotient = max_nominator / min_denominator + // max_quotient = 2^128 * 10^24 / 10^18 ~ 2^148 so possible to overflow in max_quote + let quotient = from_result!(Price::checked_from_decimal(amount) + .map_err(|err| err!(&err))? // TODO: add util macro to map str -> TrackableError + .checked_big_div_by_number( + U256::from(liquidity.get()) + .checked_mul(U256::from(PRICE_LIQUIDITY_DENOMINATOR)) + .ok_or_else(|| err!("mul overflow"))?, + ))?; + // max_quotient = 2^128 + // price_sqrt = 2^96 + // possible to overflow in result + from_result!(price_sqrt.checked_add(quotient)) + } else { + // Price::from_scale - same as case above + let quotient = from_result!(Price::checked_from_decimal(amount) + .map_err(|err| err!(&err))? // TODO: add util macro to map str -> TrackableError + .checked_big_div_by_number_up( + U256::from(liquidity.get()) + .checked_mul(U256::from(PRICE_LIQUIDITY_DENOMINATOR)) + .ok_or_else(|| err!("mul overflow"))?, + ))?; + from_result!(price_sqrt.checked_sub(quotient)) + } +} + +pub fn is_enough_amount_to_push_price( + amount: TokenAmount, + current_price_sqrt: Price, + liquidity: Liquidity, + fee: FixedPoint, + by_amount_in: bool, + x_to_y: bool, +) -> TrackableResult { + if liquidity.is_zero() { + return Ok(true); + } + + let next_price_sqrt = ok_or_mark_trace!(if by_amount_in { + let amount_after_fee = amount.big_mul( + FixedPoint::from_integer(1) + .checked_sub(fee) + .map_err(|_| err!("sub underflow"))?, + ); + get_next_sqrt_price_from_input(current_price_sqrt, liquidity, amount_after_fee, x_to_y) + } else { + get_next_sqrt_price_from_output(current_price_sqrt, liquidity, amount, x_to_y) + })?; + + Ok(current_price_sqrt.ne(&next_price_sqrt)) +} + +pub fn cross_tick(tick: &mut RefMut, pool: &mut Pool) -> Result<()> { + tick.fee_growth_outside_x = pool + .fee_growth_global_x + .unchecked_sub(tick.fee_growth_outside_x); + tick.fee_growth_outside_y = pool + .fee_growth_global_y + .unchecked_sub(tick.fee_growth_outside_y); + + // When going to higher tick net_liquidity should be added and for going lower subtracted + let new_liquidity = if (pool.current_tick_index >= tick.index) ^ tick.sign { + pool.liquidity.checked_add(tick.liquidity_change) + } else { + pool.liquidity.checked_sub(tick.liquidity_change) + }; + + pool.liquidity = new_liquidity.map_err(|_| InvariantErrorCode::InvalidPoolLiquidity)?; + Ok(()) +} + +pub fn cross_tick_no_fee_growth_update(tick: &Tick, pool: &mut Pool) -> Result<()> { + // When going to higher tick net_liquidity should be added and for going lower subtracted + let new_liquidity = if (pool.current_tick_index >= tick.index) ^ tick.sign { + pool.liquidity.checked_add(tick.liquidity_change) + } else { + pool.liquidity.checked_sub(tick.liquidity_change) + }; + + pool.liquidity = new_liquidity.map_err(|_| InvariantErrorCode::InvalidPoolLiquidity)?; + Ok(()) +} + + +pub fn get_max_tick(tick_spacing: u16) -> TrackableResult { + let limit_by_space = TICK_LIMIT + .checked_sub(1) + .ok_or_else(|| err!("sub underflow"))? + .checked_mul(tick_spacing.into()) + .ok_or_else(|| err!("mul overflow"))?; + Ok(limit_by_space.min(MAX_TICK)) +} + +pub fn get_min_tick(tick_spacing: u16) -> TrackableResult { + let limit_by_space = (-TICK_LIMIT) + .checked_add(1) + .ok_or_else(|| err!("add overflow"))? + .checked_mul(tick_spacing.into()) + .ok_or_else(|| err!("mul overflow"))?; + Ok(limit_by_space.max(-MAX_TICK)) +} + +pub fn get_max_sqrt_price(tick_spacing: u16) -> TrackableResult { + let max_tick = get_max_tick(tick_spacing); + Ok(calculate_price_sqrt(max_tick?)) +} + +pub fn get_min_sqrt_price(tick_spacing: u16) -> TrackableResult { + let min_tick = get_min_tick(tick_spacing); + Ok(calculate_price_sqrt(min_tick?)) +} + +#[cfg(test)] +mod tests { + use std::cell::RefCell; + + use decimal::{BetweenDecimals, BigOps, Decimal, Factories}; + + use crate::{ + decimals::{FixedPoint, Liquidity, Price, TokenAmount}, + math::{ + compute_swap_step, cross_tick, get_delta_x, get_delta_y, get_max_sqrt_price, + get_max_tick, get_min_sqrt_price, get_min_tick, get_next_sqrt_price_from_input, + get_next_sqrt_price_from_output, get_next_sqrt_price_x_up, get_next_sqrt_price_y_down, + SwapResult, + }, + structs::{Pool, Tick, MAX_TICK}, + utils::TrackableError, + MAX_SQRT_PRICE, MIN_SQRT_PRICE, + }; + + use super::{calculate_price_sqrt, is_enough_amount_to_push_price, FeeGrowth}; + + #[test] + fn test_compute_swap_step() { + // VALIDATE BASE SAMPLES + // one token by amount in + { + let price = Price::from_integer(1); + let target = Price::new(1004987562112089027021926); + let liquidity = Liquidity::from_integer(2000); + let amount = TokenAmount(1); + let fee = FixedPoint::from_scale(6, 4); + + let result = compute_swap_step(price, target, liquidity, amount, true, fee).unwrap(); + + let expected_result = SwapResult { + next_price_sqrt: price, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(1), + }; + assert_eq!(result, expected_result) + } + // amount out capped at target price + { + let price = Price::from_integer(1); + let target = Price::new(1004987562112089027021926); + let liquidity = Liquidity::from_integer(2000); + let amount = TokenAmount(20); + let fee = FixedPoint::from_scale(6, 4); + + let result_in = compute_swap_step(price, target, liquidity, amount, true, fee).unwrap(); + let result_out = + compute_swap_step(price, target, liquidity, amount, false, fee).unwrap(); + + let expected_result = SwapResult { + next_price_sqrt: target, + amount_in: TokenAmount(10), + amount_out: TokenAmount(9), + fee_amount: TokenAmount(1), + }; + assert_eq!(result_in, expected_result); + assert_eq!(result_out, expected_result); + } + // amount in not capped + { + let price = Price::from_scale(101, 2); + let target = Price::from_integer(10); + let liquidity = Liquidity::from_integer(300000000); + let amount = TokenAmount(1000000); + let fee = FixedPoint::from_scale(6, 4); + + let result = compute_swap_step(price, target, liquidity, amount, true, fee).unwrap(); + let expected_result = SwapResult { + next_price_sqrt: Price::new(1013331333333_333333333333), + amount_in: TokenAmount(999400), + amount_out: TokenAmount(976487), // ((1.013331333333 - 1.01) * 300000000) / (1.013331333333 * 1.01) + fee_amount: TokenAmount(600), + }; + assert_eq!(result, expected_result) + } + // amount out not capped + { + let price = Price::from_integer(101); + let target = Price::from_integer(100); + let liquidity = Liquidity::from_integer(5000000000000u128); + let amount = TokenAmount(2000000); + let fee = FixedPoint::from_scale(6, 4); + + let result = compute_swap_step(price, target, liquidity, amount, false, fee).unwrap(); + let expected_result = SwapResult { + next_price_sqrt: Price::new(100999999600000_000000000000), + amount_in: TokenAmount(197), // (5000000000000 * (101 - 100.9999996)) / (101 * 100.9999996) + amount_out: amount, + fee_amount: TokenAmount(1), + }; + assert_eq!(result, expected_result) + } + // empty swap step when price is at tick + { + let current_price_sqrt = Price::new(999500149965_000000000000); + let target_price_sqrt = Price::new(999500149965_000000000000); + + let liquidity = Liquidity::new(20006000_000000); + let amount = TokenAmount(1_000_000); + let by_amount_in = true; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: current_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(0), + }; + assert_eq!(result, expected_result) + } + // empty swap step by amount out when price is at tick + { + let current_price_sqrt = Price::new(999500149965_000000000000); + let target_price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::new(u128::MAX / 1_000000); + let amount = TokenAmount(1); + let by_amount_in = false; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: Price::new(999500149965_000000000001), + amount_in: TokenAmount(341), + amount_out: TokenAmount(1), + fee_amount: TokenAmount(1), + }; + assert_eq!(result, expected_result) + } + // if liquidity is high, small amount in should not push price + { + let current_price_sqrt = Price::from_scale(999500149965u128, 12); + let target_price_sqrt = Price::from_scale(1999500149965u128, 12); + let liquidity = Liquidity::from_integer(100_000000000000_000000000000u128); + let amount = TokenAmount(10); + let by_amount_in = true; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: current_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(10), + }; + assert_eq!(result, expected_result) + } + // amount_in > u64 for swap to target price and when liquidity > 2^64 + { + let current_price_sqrt = Price::from_integer(1); + let target_price_sqrt = Price::from_scale(100005, 5); // 1.00005 + let liquidity = Liquidity::from_integer(368944000000_000000000000u128); + let amount = TokenAmount(1); + let by_amount_in = true; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: current_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(1), + }; + assert_eq!(result, expected_result) + } + // amount_out > u64 for swap to target price and when liquidity > 2^64 + { + let current_price_sqrt = Price::from_integer(1); + let target_price_sqrt = Price::from_scale(100005, 5); // 1.00005 + let liquidity = Liquidity::from_integer(368944000000_000000000000u128); + let amount = TokenAmount(1); + let by_amount_in = false; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: Price::new(1_000000000000_000000000003), + amount_in: TokenAmount(2), + amount_out: TokenAmount(1), + fee_amount: TokenAmount(1), + }; + assert_eq!(result, expected_result) + } + // liquidity is zero and by amount_in should skip to target price + { + let current_price_sqrt = Price::from_integer(1); + let target_price_sqrt = Price::from_scale(100005, 5); // 1.00005 + let liquidity = Liquidity::new(0); + let amount = TokenAmount(100000); + let by_amount_in = true; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: target_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(0), + }; + assert_eq!(result, expected_result) + } + // liquidity is zero and by amount_out should skip to target price + { + let current_price_sqrt = Price::from_integer(1); + let target_price_sqrt = Price::from_scale(100005, 5); // 1.00005 + let liquidity = Liquidity::new(0); + let amount = TokenAmount(100000); + let by_amount_in = false; + let fee = FixedPoint::from_scale(6, 4); // 0.0006 -> 0.06% + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: target_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(0), + }; + assert_eq!(result, expected_result) + } + // normal swap step but fee is set to 0 + { + let current_price_sqrt = Price::from_scale(99995, 5); // 0.99995 + let target_price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(50000000); + let amount = TokenAmount(1000); + let by_amount_in = true; + let fee = FixedPoint::new(0); + + let result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + amount, + by_amount_in, + fee, + ) + .unwrap(); + let expected_result = SwapResult { + next_price_sqrt: Price::from_scale(99997, 5), + amount_in: TokenAmount(1000), + amount_out: TokenAmount(1000), + fee_amount: TokenAmount(0), + }; + assert_eq!(result, expected_result) + } + // by_amount_out and x_to_y edge cases + { + let target_price_sqrt = calculate_price_sqrt(-10); + let current_price_sqrt = target_price_sqrt + Price::from_integer(1); + let liquidity = Liquidity::from_integer(340282366920938463463374607u128); + let one_token = TokenAmount(1); + let tokens_with_same_output = TokenAmount(85); + let zero_token = TokenAmount(0); + let by_amount_in = false; + let max_fee = FixedPoint::from_scale(9, 1); + let min_fee = FixedPoint::from_integer(0); + + let one_token_result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + one_token, + by_amount_in, + max_fee, + ) + .unwrap(); + let tokens_with_same_output_result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + tokens_with_same_output, + by_amount_in, + max_fee, + ) + .unwrap(); + let zero_token_result = compute_swap_step( + current_price_sqrt, + target_price_sqrt, + liquidity, + zero_token, + by_amount_in, + min_fee, + ) + .unwrap(); + /* + 86x -> [1, 85]y + rounding due to price accuracy + it does not matter if you want 1 or 85 y tokens, will take you the same input amount + */ + let expected_one_token_result = SwapResult { + next_price_sqrt: current_price_sqrt - Price::new(1), + amount_in: TokenAmount(86), + amount_out: TokenAmount(1), + fee_amount: TokenAmount(78), + }; + let expected_tokens_with_same_output_result = SwapResult { + next_price_sqrt: current_price_sqrt - Price::new(1), + amount_in: TokenAmount(86), + amount_out: TokenAmount(85), + fee_amount: TokenAmount(78), + }; + let expected_zero_token_result = SwapResult { + next_price_sqrt: current_price_sqrt, + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: TokenAmount(0), + }; + assert_eq!(one_token_result, expected_one_token_result); + assert_eq!( + tokens_with_same_output_result, + expected_tokens_with_same_output_result + ); + assert_eq!(zero_token_result, expected_zero_token_result); + } + + // VALIDATE DOMAIN + let one_price_sqrt = Price::from_integer(1); + let two_price_sqrt = Price::from_integer(2); + let max_price_sqrt = calculate_price_sqrt(MAX_TICK); + let min_price_sqrt = calculate_price_sqrt(-MAX_TICK); + let one_liquidity = Liquidity::from_integer(1); + let max_liquidity = Liquidity::max_instance(); + let max_amount = TokenAmount::max_instance(); + let max_amount_not_reached_target_price = TokenAmount(TokenAmount::max_value() - 1); + let max_fee = FixedPoint::from_integer(1); + let min_fee = FixedPoint::new(0); + + // 100% fee | max_amount + { + let result = compute_swap_step( + one_price_sqrt, + two_price_sqrt, + one_liquidity, + max_amount, + true, + max_fee, + ) + .unwrap(); + assert_eq!( + result, + SwapResult { + next_price_sqrt: Price::from_integer(1), + amount_in: TokenAmount(0), + amount_out: TokenAmount(0), + fee_amount: max_amount, + } + ) + } + // 0% fee | max_amount | max_liquidity | price slice + { + let (_, cause, stack) = compute_swap_step( + one_price_sqrt, + two_price_sqrt, + max_liquidity, + max_amount, + true, + min_fee, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "get_delta_x overflow"); + assert_eq!(stack.len(), 1); + } + // by_amount_in == true || close to target_price but not reached + { + let big_liquidity = Liquidity::from_integer(100_000_000_000_000u128); + let amount_pushing_price_to_target = TokenAmount(100000000000000); + + let result = compute_swap_step( + one_price_sqrt, + two_price_sqrt, + big_liquidity, + amount_pushing_price_to_target - TokenAmount(1), + true, + min_fee, + ) + .unwrap(); + assert_eq!( + result, + SwapResult { + next_price_sqrt: Price::new(1999999999999990000000000), + amount_in: TokenAmount(99999999999999), + amount_out: TokenAmount(49999999999999), + fee_amount: TokenAmount(0) + } + ) + } + // maximize fee_amount || close to target_price but not reached + { + let non_fee_input = TokenAmount(340282367); + let result = compute_swap_step( + one_price_sqrt, + two_price_sqrt, + max_liquidity, + TokenAmount::max_instance(), + true, + max_fee - FixedPoint::new(19), + ) + .unwrap(); + assert_eq!( + result, + SwapResult { + next_price_sqrt: one_price_sqrt + Price::new(1), + amount_in: non_fee_input, + amount_out: non_fee_input - TokenAmount(1), + fee_amount: TokenAmount::max_instance() - non_fee_input, + } + ) + } + // get_next_sqrt_price_from_input -> get_next_sqrt_price_x_up + { + // by_amount_in == true + // x_to_y == true => current_price_sqrt >= target_price_sqrt == true + + // validate both: trace and panic possibilities + let (_, cause, stack) = compute_swap_step( + max_price_sqrt, + min_price_sqrt, + max_liquidity, + max_amount_not_reached_target_price, + true, + min_fee, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "multiplication overflow"); + assert_eq!(stack.len(), 4); + } + // get_next_sqrt_price_from_input -> get_next_sqrt_price_y_down + { + // by_amount_in == true + // x_to_y == false => current_price_sqrt >= target_price_sqrt == false + + // 1. scale - maximize amount_after_fee => (max_amount, min_fee) && not reached target + { + let (_, cause, stack) = compute_swap_step( + min_price_sqrt, + max_price_sqrt, + max_liquidity, + max_amount_not_reached_target_price, + true, + min_fee, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "checked_from_scale: (multiplier * base) overflow"); + assert_eq!(stack.len(), 3); + } + // 2. checked_big_div - no possible to trigger from compute_swap_step + { + let min_overflow_token_amount = TokenAmount::new(340282366920939); + let result = compute_swap_step( + min_price_sqrt, + max_price_sqrt, + one_liquidity - Liquidity::new(1), + min_overflow_token_amount - TokenAmount(1), + true, + min_fee, + ) + .unwrap(); + assert_eq!( + result, + SwapResult { + next_price_sqrt: max_price_sqrt, + amount_in: TokenAmount(65536), + amount_out: TokenAmount(65535), + fee_amount: TokenAmount(0), + } + ) + } + } + // get_next_sqrt_price_from_output -> get_next_sqrt_price_x_up + { + // by_amount_in == false + // x_to_y == false => current_price_sqrt >= target_price_sqrt == false + // TRY TO UNWRAP IN SUBTRACTION + + // min price different at maximum amount + { + let min_diff = 232_826_265_438_719_159_684u128; + let (_, cause, stack) = compute_swap_step( + max_price_sqrt - Price::new(min_diff), + max_price_sqrt, + max_liquidity, + TokenAmount(TokenAmount::max_value() - 1), + false, + min_fee, + ) + .unwrap_err() + .get(); + assert_eq!(cause, "multiplication overflow"); + assert_eq!(stack.len(), 4); + } + // min price different at maximum amount + { + let result = compute_swap_step( + min_price_sqrt, + max_price_sqrt, + Liquidity::from_integer(281_477_613_507_675u128), + TokenAmount(TokenAmount::max_value() - 1), + false, + min_fee, + ) + .unwrap(); + + assert_eq!( + result, + SwapResult { + next_price_sqrt: Price::new(65535263695369929348256523309), + amount_in: TokenAmount(18446709621273854098), + amount_out: TokenAmount(18446744073709551613), + fee_amount: TokenAmount(0) + } + ); + } + // min token change + { + let result = compute_swap_step( + max_price_sqrt - Price::from_integer(1), + max_price_sqrt, + Liquidity::from_integer(100_000_000_00u128), + TokenAmount(1), + false, + min_fee, + ) + .unwrap(); + + assert_eq!( + result, + SwapResult { + next_price_sqrt: Price::new(65534813412874974599766965330u128), + amount_in: TokenAmount(4294783624), + amount_out: TokenAmount(1), + fee_amount: TokenAmount(0), + } + ); + } + //Fee above 1 && by_amount_in == true + { + let (_, cause, _) = compute_swap_step( + max_price_sqrt - Price::from_integer(1), + max_price_sqrt, + Liquidity::from_integer(100_000_000_00u128), + TokenAmount(1), + true, + FixedPoint::from_integer(1) + FixedPoint::new(1), + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "sub underflow"); + } + //max fee that fits within u64 && by_amount_in == false + { + let result = compute_swap_step( + max_price_sqrt - Price::from_integer(1), + max_price_sqrt, + Liquidity::from_integer(100_000_000_00u128), + TokenAmount::new(u64::MAX), + false, + FixedPoint::from_integer(i32::MAX / 2), + ) + .unwrap(); + + assert_eq!( + result, + SwapResult { + next_price_sqrt: Price::new(65535383934512647000000000000), + amount_in: TokenAmount(10000000000), + amount_out: TokenAmount(2), + fee_amount: TokenAmount(10737418230000000000) + } + ); + } + } + } + + #[test] + fn test_get_next_sqrt_price_y_down() { + // VALIDATE BASE SAMPLES + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(1); + let amount = TokenAmount(1); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, true).unwrap(); + + assert_eq!(result, Price::from_integer(2)); + } + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(2); + let amount = TokenAmount(3); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, true).unwrap(); + + assert_eq!(result, Price::from_scale(25, 1)); + } + { + let price_sqrt = Price::from_integer(2); + let liquidity = Liquidity::from_integer(3); + let amount = TokenAmount(5); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, true).unwrap(); + + assert_eq!( + result, + Price::from_integer(11).big_div(Price::from_integer(3)) + ); + } + { + let price_sqrt = Price::from_integer(24234); + let liquidity = Liquidity::from_integer(3000); + let amount = TokenAmount(5000); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, true).unwrap(); + + assert_eq!( + result, + Price::from_integer(72707).big_div(Price::from_integer(3)) + ); + } + // bool = false + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(2); + let amount = TokenAmount(1); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, false).unwrap(); + + assert_eq!(result, Price::from_scale(5, 1)); + } + { + let price_sqrt = Price::from_integer(100_000); + let liquidity = Liquidity::from_integer(500_000_000); + let amount = TokenAmount(4_000); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, false).unwrap(); + assert_eq!(result, Price::new(99999999992000000_000000000000)); + } + { + let price_sqrt = Price::from_integer(3); + let liquidity = Liquidity::from_integer(222); + let amount = TokenAmount(37); + + let result = get_next_sqrt_price_y_down(price_sqrt, liquidity, amount, false).unwrap(); + + // expected 2.833333333333 + // real 2.999999999999833... + assert_eq!(result, Price::new(2833333333333_333333333333)); + } + + // VALIDATE DOMAIN + let max_amount = TokenAmount::max_instance(); + let min_price = Price::new(1); + let sample_liquidity = Liquidity::new(1); + let min_overflow_token_amount = TokenAmount::new(340282366920939); + let max_price = calculate_price_sqrt(MAX_TICK); + let one_liquidity: Liquidity = Liquidity::from_integer(1); + let max_liquidity = Liquidity::max_instance(); + // max_liquidity + { + let result = get_next_sqrt_price_y_down( + max_price, + max_liquidity, + min_overflow_token_amount - TokenAmount(1), + false, + ) + .unwrap(); + assert_eq!(result, Price::new(65535383934512646999999000000)); + } + // extension TokenAmount to Price decimal overflow + { + { + let result = + get_next_sqrt_price_y_down(min_price, sample_liquidity, max_amount, true) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!(cause, "checked_from_scale: (multiplier * base) overflow"); + assert_eq!(stack.len(), 1); + } + { + let result = + get_next_sqrt_price_y_down(min_price, sample_liquidity, max_amount, false) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!(cause, "checked_from_scale: (multiplier * base) overflow"); + assert_eq!(stack.len(), 1); + } + } + // quotient overflow + { + { + { + let result = get_next_sqrt_price_y_down( + min_price, + one_liquidity - Liquidity::new(1), + min_overflow_token_amount - TokenAmount(1), + true, + ) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!(cause, "checked_big_div_by_number: can't convert to result"); + assert_eq!(stack.len(), 1); + } + { + let result = get_next_sqrt_price_y_down( + min_price, + one_liquidity - Liquidity::new(1), + min_overflow_token_amount - TokenAmount(1), + false, + ) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!( + cause, + "checked_big_div_by_number_up: can't convert to result" + ); + assert_eq!(stack.len(), 1); + } + } + { + let result = get_next_sqrt_price_y_down( + min_price, + one_liquidity, + min_overflow_token_amount - TokenAmount(1), + true, + ) + .unwrap(); + assert_eq!(result, Price::new(340282366920938000000000000000000000001)); + } + } + // overflow in price difference + { + { + let result = get_next_sqrt_price_y_down( + max_price, + one_liquidity, + min_overflow_token_amount - TokenAmount(1), + true, + ) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!(cause, "checked_add: (self + rhs) additional overflow"); + assert_eq!(stack.len(), 1); + } + { + let result = get_next_sqrt_price_y_down( + min_price, + one_liquidity, + min_overflow_token_amount - TokenAmount(1), + false, + ) + .unwrap_err(); + let (_, cause, stack) = result.get(); + assert_eq!(cause, "checked_sub: (self - rhs) subtraction underflow"); + assert_eq!(stack.len(), 1); + } + } + } + + #[test] + fn test_get_delta_x() { + // validate base samples + // zero at zero liquidity + { + let result = get_delta_x( + Price::from_integer(1u8), + Price::from_integer(1u8), + Liquidity::new(0), + false, + ) + .unwrap(); + assert_eq!(result, TokenAmount(0)); + } + // equal at equal liquidity + { + let result = get_delta_x( + Price::from_integer(1u8), + Price::from_integer(2u8), + Liquidity::from_integer(2u8), + false, + ) + .unwrap(); + assert_eq!(result, TokenAmount(1)); + } + // complex + { + let sqrt_price_a = Price::new(234__878_324_943_782_000000000000); + let sqrt_price_b = Price::new(87__854_456_421_658_000000000000); + let liquidity = Liquidity::new(983_983__249_092); + + let result_down = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, false).unwrap(); + let result_up = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, true).unwrap(); + + // 7010.8199533068819376891841727789301497024557314488455622925765280 + assert_eq!(result_down, TokenAmount(7010)); + assert_eq!(result_up, TokenAmount(7011)); + } + // big + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::from_scale(5u8, 1); + let liquidity = Liquidity::from_integer(2u128.pow(64) - 1); + + let result_down = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, false).unwrap(); + let result_up = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, true).unwrap(); + + assert_eq!(result_down, TokenAmount::from_decimal(liquidity)); + assert_eq!(result_up, TokenAmount::from_decimal(liquidity)); + } + // overflow + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::from_scale(5u8, 1); + let liquidity = Liquidity::from_integer(2u128.pow(64)); + + let result_down = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, false); + let result_up = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, true); + + assert!(result_down.is_none()); + assert!(result_up.is_none()); + } + // huge liquidity + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::new(Price::one()) + Price::new(1000000); + let liquidity = Liquidity::from_integer(2u128.pow(80)); + + let result_down = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, false); + let result_up = get_delta_x(sqrt_price_a, sqrt_price_b, liquidity, true); + + assert!(result_down.is_some()); + assert!(result_up.is_some()); + } + + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let almost_max_sqrt_price = calculate_price_sqrt(MAX_TICK - 1); + let almost_min_sqrt_price = calculate_price_sqrt(-MAX_TICK + 1); + + // DOMAIN: + let max_liquidity = Liquidity::new(u128::MAX); + let min_liquidity = Liquidity::new(1); + + // maximize numerator for overflow of TokenAmount -> maximize delta_price and liquidity + { + { + let result = get_delta_x(max_sqrt_price, min_sqrt_price, max_liquidity, true); + assert_eq!(None, result); + } + { + let result = get_delta_x(max_sqrt_price, min_sqrt_price, max_liquidity, false); + assert_eq!(None, result); + } + } + // maximize denominator for overflow of TokenAmount -> maximize prices product + { + { + let result: Option = + get_delta_x(max_sqrt_price, almost_max_sqrt_price, max_liquidity, true); + assert_eq!(None, result); + } + { + let result = + get_delta_x(max_sqrt_price, almost_max_sqrt_price, max_liquidity, false); + assert_eq!(None, result); + } + } + // maximize denominator without overflow of TokenAmount -> maximize prices product + { + { + let result: Option = + get_delta_x(max_sqrt_price, almost_max_sqrt_price, min_liquidity, true); + assert_eq!(Some(TokenAmount(1)), result); + } + { + let result = + get_delta_x(max_sqrt_price, almost_max_sqrt_price, min_liquidity, false); + assert_eq!(Some(TokenAmount(0)), result); + } + } + // minimize denominator on maximize liquidity for overflow of TokenAmount + { + { + let result: Option = + get_delta_x(min_sqrt_price, almost_min_sqrt_price, max_liquidity, true); + assert_eq!(None, result); + } + { + let result = + get_delta_x(min_sqrt_price, almost_min_sqrt_price, max_liquidity, false); + assert_eq!(None, result); + } + } + // minimize denominator on minimize liquidity which fits into TokenAmount + { + { + let result: Option = + get_delta_x(min_sqrt_price, almost_min_sqrt_price, min_liquidity, true); + assert_eq!(Some(TokenAmount(1)), result); + } + { + let result = + get_delta_x(min_sqrt_price, almost_min_sqrt_price, min_liquidity, false); + assert_eq!(Some(TokenAmount(0)), result); + } + } + // maximize denominator with maximum liquidity which fit into TokenAmount + { + let liquidity = Liquidity::new(max_liquidity.v >> 46); + { + let result: Option = + get_delta_x(min_sqrt_price, almost_min_sqrt_price, liquidity, true); + assert_eq!(Some(TokenAmount(15845800777794838947)), result); + } + { + let result = get_delta_x(min_sqrt_price, almost_min_sqrt_price, liquidity, false); + assert_eq!(Some(TokenAmount(15845800777794838946)), result); + } + } + } + + #[test] + fn test_get_delta_y() { + // base samples + // zero at zero liquidity + { + let result = get_delta_y( + Price::from_integer(1), + Price::from_integer(1), + Liquidity::new(0), + false, + ) + .unwrap(); + assert_eq!(result, TokenAmount(0)); + } + // equal at equal liquidity + { + let result = get_delta_y( + Price::from_integer(1), + Price::from_integer(2), + Liquidity::from_integer(2), + false, + ) + .unwrap(); + assert_eq!(result, TokenAmount(2)); + } + // big numbers + { + let sqrt_price_a = Price::new(234__878_324_943_782_000000000000); + let sqrt_price_b = Price::new(87__854_456_421_658_000000000000); + let liquidity = Liquidity::new(983_983__249_092); + + let result_down = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, false).unwrap(); + let result_up = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, true).unwrap(); + + // 144669023.842474597804911408 + assert_eq!(result_down, TokenAmount(144669023)); + assert_eq!(result_up, TokenAmount(144669024)); + } + // big + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::from_integer(2u8); + let liquidity = Liquidity::from_integer(2u128.pow(64) - 1); + + let result_down = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, false).unwrap(); + let result_up = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, true).unwrap(); + + assert_eq!(result_down, TokenAmount::from_decimal(liquidity)); + assert_eq!(result_up, TokenAmount::from_decimal(liquidity)); + } + // overflow + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::from_integer(2u8); + let liquidity = Liquidity::from_integer(2u128.pow(64)); + + let result_down = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, false); + let result_up = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, true); + + assert!(result_down.is_none()); + assert!(result_up.is_none()); + } + // huge liquidity + { + let sqrt_price_a = Price::from_integer(1u8); + let sqrt_price_b = Price::new(Price::one()) + Price::new(1000000); + let liquidity = Liquidity::from_integer(2u128.pow(80)); + + let result_down = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, false); + let result_up = get_delta_y(sqrt_price_a, sqrt_price_b, liquidity, true); + + assert!(result_down.is_some()); + assert!(result_up.is_some()); + } + + // DOMAIN + let max_sqrt_price = calculate_price_sqrt(MAX_TICK); + let min_sqrt_price = calculate_price_sqrt(-MAX_TICK); + let max_liquidity = Liquidity::new(u128::MAX); + // maximize delta_price and liquidity + { + { + let result = get_delta_y(max_sqrt_price, min_sqrt_price, max_liquidity, true); + assert!(result.is_none()); + } + { + let result = get_delta_y(max_sqrt_price, min_sqrt_price, max_liquidity, false); + assert!(result.is_none()); + } + } + } + + #[test] + fn test_get_next_sqrt_price_x_up() { + // basic samples + // Add + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(1); + let amount = TokenAmount(1); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, true); + + assert_eq!(result.unwrap(), Price::from_scale(5, 1)); + } + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(2); + let amount = TokenAmount(3); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, true); + + assert_eq!(result.unwrap(), Price::from_scale(4, 1)); + } + { + let price_sqrt = Price::from_integer(2); + let liquidity = Liquidity::from_integer(3); + let amount = TokenAmount(5); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, true); + + assert_eq!( + result.unwrap(), + Price::new(461538461538461538461539) // rounded up Decimal::from_integer(6).div(Decimal::from_integer(13)) + ); + } + { + let price_sqrt = Price::from_integer(24234); + let liquidity = Liquidity::from_integer(3000); + let amount = TokenAmount(5000); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, true); + + assert_eq!( + result.unwrap(), + Price::new(599985145205615112277488) // rounded up Decimal::from_integer(24234).div(Decimal::from_integer(40391)) + ); + } + // Subtract + { + let price_sqrt = Price::from_integer(1); + let liquidity = Liquidity::from_integer(2); + let amount = TokenAmount(1); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, false); + + assert_eq!(result.unwrap(), Price::from_integer(2)); + } + { + let price_sqrt = Price::from_integer(100_000); + let liquidity = Liquidity::from_integer(500_000_000); + let amount = TokenAmount(4_000); + + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, false); + + assert_eq!(result.unwrap(), Price::from_integer(500_000)); + } + { + let price_sqrt = Price::new(3_333333333333333333333333); + let liquidity = Liquidity::new(222_222222); + let amount = TokenAmount(37); + + // expected 7.490636713462104974072145 + // real 7.4906367134621049740721443... + let result = get_next_sqrt_price_x_up(price_sqrt, liquidity, amount, false); + + assert_eq!(result.unwrap(), Price::new(7490636713462104974072145)); + } + + // DOMAIN: + let max_liquidity = Liquidity::new(u128::MAX); + let min_liquidity = Liquidity::new(1); + let max_price_sqrt = calculate_price_sqrt(MAX_TICK); + let max_amount = TokenAmount(u64::MAX); + { + let result = get_next_sqrt_price_x_up(max_price_sqrt, max_liquidity, max_amount, true) + .unwrap_err(); + + let (_, cause, stack) = result.get(); + assert_eq!(stack.len(), 2); + assert_eq!(cause, TrackableError::MUL); + } + // subtraction underflow (not possible from upper-level function) + { + let (_, cause, stack) = get_next_sqrt_price_x_up( + max_price_sqrt, + min_liquidity, + TokenAmount(u64::MAX), + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "big_liquidity -/+ price_sqrt * amount"); + assert_eq!(stack.len(), 1); + } + // max_liquidity + { + let result = get_next_sqrt_price_y_down( + Price::from_integer(1), + max_liquidity, + TokenAmount(10000), + false, + ) + .unwrap(); + assert_eq!(result, Price::new(999999999999999999999999)); + } + } + + #[test] + fn test_get_next_sqrt_price_from_input() { + { + let (_, cause, _) = get_next_sqrt_price_from_input( + Price::from_integer(1), + Liquidity::from_integer(0), + TokenAmount::from_integer(1), + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "getting next price from input with zero liquidity") + } + { + let (_, cause, _) = get_next_sqrt_price_from_input( + Price::from_integer(0), + Liquidity::from_integer(1), + TokenAmount::from_integer(1), + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "getting next price from input with zero price") + } + } + + #[test] + fn test_get_next_sqrt_price_from_output() { + { + let (_, cause, _) = get_next_sqrt_price_from_output( + Price::from_integer(1), + Liquidity::from_integer(0), + TokenAmount::from_integer(1), + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "getting next price from output with zero liquidity") + } + { + let (_, cause, _) = get_next_sqrt_price_from_output( + Price::from_integer(0), + Liquidity::from_integer(1), + TokenAmount::from_integer(1), + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "getting next price from output with zero price") + } + } + #[test] + fn test_is_enough_amount_to_push_price() { + // Validate traceable error + let min_liquidity = Liquidity::new(1); + let max_price_sqrt = calculate_price_sqrt(MAX_TICK); + let min_fee = FixedPoint::from_integer(0); + { + let (_, cause, stack) = is_enough_amount_to_push_price( + TokenAmount(u64::MAX), + max_price_sqrt, + min_liquidity, + min_fee, + false, + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "big_liquidity -/+ price_sqrt * amount"); + assert_eq!(stack.len(), 3); + } + let fee_over_one = FixedPoint::from_integer(1) + FixedPoint::new(1); + + let (_, cause, _) = is_enough_amount_to_push_price( + TokenAmount::new(1000), + calculate_price_sqrt(10), + Liquidity::new(1), + fee_over_one, + true, + false, + ) + .unwrap_err() + .get(); + + assert_eq!(cause, "sub underflow") + } + + #[test] + fn test_price_limitation() { + { + let global_max_price = calculate_price_sqrt(MAX_TICK); + assert_eq!(global_max_price, Price::new(MAX_SQRT_PRICE)); // ceil(log2(this)) = 96 + let global_min_price = calculate_price_sqrt(-MAX_TICK); + assert_eq!(global_min_price, Price::new(MIN_SQRT_PRICE)); // ceil(log2(this)) = 64 + } + { + let max_price = get_max_sqrt_price(1).unwrap(); + let max_tick: i32 = get_max_tick(1).unwrap(); + assert_eq!(max_price, Price::new(9189293893553000000000000)); + assert_eq!( + calculate_price_sqrt(max_tick), + Price::new(9189293893553000000000000) + ); + + let max_price = get_max_sqrt_price(2).unwrap(); + let max_tick: i32 = get_max_tick(2).unwrap(); + assert_eq!(max_price, Price::new(84443122262186000000000000)); + assert_eq!( + calculate_price_sqrt(max_tick), + Price::new(84443122262186000000000000) + ); + + let max_price = get_max_sqrt_price(5).unwrap(); + let max_tick: i32 = get_max_tick(5).unwrap(); + assert_eq!(max_price, Price::new(65525554855399275000000000000)); + assert_eq!( + calculate_price_sqrt(max_tick), + Price::new(65525554855399275000000000000) + ); + + let max_price = get_max_sqrt_price(10).unwrap(); + let max_tick: i32 = get_max_tick(10).unwrap(); + assert_eq!(max_price, Price::new(65535383934512647000000000000)); + assert_eq!( + calculate_price_sqrt(max_tick), + Price::new(65535383934512647000000000000) + ); + + let max_price = get_max_sqrt_price(100).unwrap(); + let max_tick: i32 = get_max_tick(100).unwrap(); + assert_eq!(max_price, Price::new(65535383934512647000000000000)); + assert_eq!( + calculate_price_sqrt(max_tick), + Price::new(65535383934512647000000000000) + ); + } + { + let min_price = get_min_sqrt_price(1).unwrap(); + let min_tick: i32 = get_min_tick(1).unwrap(); + assert_eq!(min_price, Price::new(108822289458000000000000)); + assert_eq!( + calculate_price_sqrt(min_tick), + Price::new(108822289458000000000000) + ); + + let min_price = get_min_sqrt_price(2).unwrap(); + let min_tick: i32 = get_min_tick(2).unwrap(); + assert_eq!(min_price, Price::new(11842290682000000000000)); + assert_eq!( + calculate_price_sqrt(min_tick), + Price::new(11842290682000000000000) + ); + + let min_price = get_min_sqrt_price(5).unwrap(); + let min_tick: i32 = get_min_tick(5).unwrap(); + assert_eq!(min_price, Price::new(15261221000000000000)); + assert_eq!( + calculate_price_sqrt(min_tick), + Price::new(15261221000000000000) + ); + + let min_price = get_min_sqrt_price(10).unwrap(); + let min_tick: i32 = get_min_tick(10).unwrap(); + assert_eq!(min_price, Price::new(15258932000000000000)); + assert_eq!( + calculate_price_sqrt(min_tick), + Price::new(15258932000000000000) + ); + + let min_price = get_min_sqrt_price(100).unwrap(); + let min_tick: i32 = get_min_tick(100).unwrap(); + assert_eq!(min_price, Price::new(15258932000000000000)); + assert_eq!( + calculate_price_sqrt(min_tick), + Price::new(15258932000000000000) + ); + + get_min_tick(u16::MAX).unwrap_err(); + get_max_tick(u16::MAX).unwrap_err(); + get_max_sqrt_price(u16::MAX).unwrap_err(); + get_min_sqrt_price(u16::MAX).unwrap_err(); + } + } + + #[test] + fn test_cross_tick() { + // add liquidity to pool + { + let mut pool = Pool { + fee_growth_global_x: FeeGrowth::new(45), + fee_growth_global_y: FeeGrowth::new(35), + liquidity: Liquidity::from_integer(4), + current_tick_index: 7, + ..Default::default() + }; + let tick = Tick { + fee_growth_outside_x: FeeGrowth::new(30), + fee_growth_outside_y: FeeGrowth::new(25), + index: 3, + liquidity_change: Liquidity::from_integer(1), + ..Default::default() + }; + let result_pool = Pool { + fee_growth_global_x: FeeGrowth::new(45), + fee_growth_global_y: FeeGrowth::new(35), + liquidity: Liquidity::from_integer(5), + current_tick_index: 7, + ..Default::default() + }; + let result_tick = Tick { + fee_growth_outside_x: FeeGrowth::new(15), + fee_growth_outside_y: FeeGrowth::new(10), + index: 3, + liquidity_change: Liquidity::from_integer(1), + ..Default::default() + }; + + let ref_tick = RefCell::new(tick); + let mut refmut_tick = ref_tick.borrow_mut(); + + cross_tick(&mut refmut_tick, &mut pool).unwrap(); + + assert_eq!(*refmut_tick, result_tick); + assert_eq!(pool, result_pool); + } + { + let mut pool = Pool { + fee_growth_global_x: FeeGrowth::new(68), + fee_growth_global_y: FeeGrowth::new(59), + liquidity: Liquidity::new(0), + current_tick_index: 4, + ..Default::default() + }; + let tick = Tick { + fee_growth_outside_x: FeeGrowth::new(42), + fee_growth_outside_y: FeeGrowth::new(14), + index: 9, + liquidity_change: Liquidity::new(0), + ..Default::default() + }; + let result_pool = Pool { + fee_growth_global_x: FeeGrowth::new(68), + fee_growth_global_y: FeeGrowth::new(59), + liquidity: Liquidity::new(0), + current_tick_index: 4, + ..Default::default() + }; + let result_tick = Tick { + fee_growth_outside_x: FeeGrowth::new(26), + fee_growth_outside_y: FeeGrowth::new(45), + index: 9, + liquidity_change: Liquidity::from_integer(0), + ..Default::default() + }; + + let ref_tick = RefCell::new(tick); + let mut refmut_tick = ref_tick.borrow_mut(); + cross_tick(&mut refmut_tick, &mut pool).unwrap(); + assert_eq!(*refmut_tick, result_tick); + assert_eq!(pool, result_pool); + } + // fee_growth_outside should underflow + { + let mut pool = Pool { + fee_growth_global_x: FeeGrowth::new(3402), + fee_growth_global_y: FeeGrowth::new(3401), + liquidity: Liquidity::new(14), + current_tick_index: 9, + ..Default::default() + }; + let tick = Tick { + fee_growth_outside_x: FeeGrowth::new(26584), + fee_growth_outside_y: FeeGrowth::new(1256588), + index: 45, + liquidity_change: Liquidity::new(10), + ..Default::default() + }; + let result_pool = Pool { + fee_growth_global_x: FeeGrowth::new(3402), + fee_growth_global_y: FeeGrowth::new(3401), + liquidity: Liquidity::new(4), + current_tick_index: 9, + ..Default::default() + }; + let result_tick = Tick { + fee_growth_outside_x: FeeGrowth::new(340282366920938463463374607431768188274), + fee_growth_outside_y: FeeGrowth::new(340282366920938463463374607431766958269), + index: 45, + liquidity_change: Liquidity::new(10), + ..Default::default() + }; + + let fef_tick = RefCell::new(tick); + let mut refmut_tick = fef_tick.borrow_mut(); + cross_tick(&mut refmut_tick, &mut pool).unwrap(); + assert_eq!(*refmut_tick, result_tick); + assert_eq!(pool, result_pool); + } + // seconds_per_liquidity_outside should underflow + { + let mut pool = Pool { + fee_growth_global_x: FeeGrowth::new(145), + fee_growth_global_y: FeeGrowth::new(364), + liquidity: Liquidity::new(14), + current_tick_index: 9, + ..Default::default() + }; + let tick = Tick { + fee_growth_outside_x: FeeGrowth::new(99), + fee_growth_outside_y: FeeGrowth::new(256), + index: 45, + liquidity_change: Liquidity::new(10), + ..Default::default() + }; + let result_pool = Pool { + fee_growth_global_x: FeeGrowth::new(145), + fee_growth_global_y: FeeGrowth::new(364), + liquidity: Liquidity::new(4), + current_tick_index: 9, + ..Default::default() + }; + let result_tick = Tick { + fee_growth_outside_x: FeeGrowth::new(46), + fee_growth_outside_y: FeeGrowth::new(108), + index: 45, + liquidity_change: Liquidity::new(10), + ..Default::default() + }; + + let fef_tick = RefCell::new(tick); + let mut refmut_tick = fef_tick.borrow_mut(); + cross_tick(&mut refmut_tick, &mut pool).unwrap(); + assert_eq!(*refmut_tick, result_tick); + assert_eq!(pool, result_pool); + } + // inconsistent state test cases + { + // underflow of pool.liquidity during cross_tick + { + let mut pool = Pool { + liquidity: Liquidity::from_integer(4), + current_tick_index: 7, + ..Default::default() + }; + let tick = Tick { + index: 10, + liquidity_change: Liquidity::from_integer(5), + ..Default::default() + }; + // state of pool and tick be should unchanged + let result_pool = pool.clone(); + let result_tick = tick.clone(); + + let ref_tick = RefCell::new(tick); + let mut refmut_tick = ref_tick.borrow_mut(); + + cross_tick(&mut refmut_tick, &mut pool).unwrap_err(); + assert_eq!(*refmut_tick, result_tick); + assert_eq!(pool, result_pool); + } + } + } +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/structs/fee_tier.rs b/lib/dex-invariant/src/internal/invariant-types/src/structs/fee_tier.rs new file mode 100644 index 0000000..309527a --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/structs/fee_tier.rs @@ -0,0 +1,12 @@ +use crate::{decimals::FixedPoint, size}; +use anchor_lang::prelude::*; + +#[account(zero_copy(unsafe))] +#[repr(packed)] +#[derive(PartialEq, Default, Debug, AnchorDeserialize)] +pub struct FeeTier { + pub fee: FixedPoint, + pub tick_spacing: u16, + pub bump: u8, +} +size!(FeeTier); diff --git a/lib/dex-invariant/src/internal/invariant-types/src/structs/mod.rs b/lib/dex-invariant/src/internal/invariant-types/src/structs/mod.rs new file mode 100644 index 0000000..55425e3 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/structs/mod.rs @@ -0,0 +1,9 @@ +pub mod fee_tier; +pub mod pool; +pub mod tick; +pub mod tickmap; + +pub use fee_tier::*; +pub use pool::*; +pub use tick::*; +pub use tickmap::*; diff --git a/lib/dex-invariant/src/internal/invariant-types/src/structs/pool.rs b/lib/dex-invariant/src/internal/invariant-types/src/structs/pool.rs new file mode 100644 index 0000000..4c89664 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/structs/pool.rs @@ -0,0 +1,33 @@ +use anchor_lang::prelude::*; + +use crate::{decimals::*, size}; + +#[account(zero_copy(unsafe))] +#[repr(packed)] +#[derive(PartialEq, Default, Debug, AnchorDeserialize)] +pub struct Pool { + pub token_x: Pubkey, + pub token_y: Pubkey, + pub token_x_reserve: Pubkey, + pub token_y_reserve: Pubkey, + pub position_iterator: u128, + pub tick_spacing: u16, + pub fee: FixedPoint, + pub protocol_fee: FixedPoint, + pub liquidity: Liquidity, + pub sqrt_price: Price, + pub current_tick_index: i32, // nearest tick below the current price + pub tickmap: Pubkey, + pub fee_growth_global_x: FeeGrowth, + pub fee_growth_global_y: FeeGrowth, + pub fee_protocol_token_x: u64, // should be changed to TokenAmount when Armani implements tuple structs + pub fee_protocol_token_y: u64, + pub seconds_per_liquidity_global: FixedPoint, + pub start_timestamp: u64, + pub last_timestamp: u64, + pub fee_receiver: Pubkey, + pub oracle_address: Pubkey, + pub oracle_initialized: bool, + pub bump: u8, +} +size!(Pool); diff --git a/lib/dex-invariant/src/internal/invariant-types/src/structs/tick.rs b/lib/dex-invariant/src/internal/invariant-types/src/structs/tick.rs new file mode 100644 index 0000000..ba19c46 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/structs/tick.rs @@ -0,0 +1,20 @@ +use crate::{decimals::*, size}; +use anchor_lang::prelude::*; + +#[account(zero_copy(unsafe))] +#[repr(packed)] +#[derive(PartialEq, Default, Debug, AnchorDeserialize)] +pub struct Tick { + pub pool: Pubkey, + pub index: i32, + pub sign: bool, // true means positive + pub liquidity_change: Liquidity, + pub liquidity_gross: Liquidity, + pub sqrt_price: Price, + pub fee_growth_outside_x: FeeGrowth, + pub fee_growth_outside_y: FeeGrowth, + pub seconds_per_liquidity_outside: FixedPoint, + pub seconds_outside: u64, + pub bump: u8, +} +size!(Tick); diff --git a/lib/dex-invariant/src/internal/invariant-types/src/structs/tickmap.rs b/lib/dex-invariant/src/internal/invariant-types/src/structs/tickmap.rs new file mode 100644 index 0000000..5e6ad78 --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/structs/tickmap.rs @@ -0,0 +1,685 @@ +use std::{convert::TryInto, fmt::Debug}; + +use crate::{size, MAX_VIRTUAL_CROSS}; +use anchor_lang::prelude::*; + +use crate::utils::{TrackableError, TrackableResult}; +use crate::{err, function, location, trace}; + +pub const TICK_LIMIT: i32 = 44_364; // If you change it update length of array as well! +pub const TICK_SEARCH_RANGE: i32 = 256; +pub const MAX_TICK: i32 = 221_818; // log(1.0001, sqrt(2^64-1)) +pub const TICK_CROSSES_PER_IX: usize = 4; +pub const TICKS_BACK_COUNT: usize = 1; +pub const TICKMAP_SIZE: i32 = 2 * TICK_LIMIT - 1; + +const TICKMAP_RANGE: usize = (TICK_CROSSES_PER_IX + TICKS_BACK_COUNT + MAX_VIRTUAL_CROSS as usize) + * TICK_SEARCH_RANGE as usize; +const TICKMAP_SLICE_SIZE: usize = TICKMAP_RANGE / 8 + 2; + +pub fn tick_to_position(tick: i32, tick_spacing: u16) -> (usize, u8) { + assert_eq!( + (tick % tick_spacing as i32), + 0, + "tick not divisible by spacing" + ); + + let bitmap_index = tick + .checked_div(tick_spacing.try_into().unwrap()) + .unwrap() + .checked_add(TICK_LIMIT) + .unwrap(); + + let byte: usize = (bitmap_index.checked_div(8).unwrap()).try_into().unwrap(); + let bit: u8 = (bitmap_index % 8).abs().try_into().unwrap(); + + (byte, bit) +} + +// tick_spacing - spacing already scaled by tick_spacing +pub fn get_search_limit(tick: i32, tick_spacing: u16, up: bool) -> i32 { + let index = tick / tick_spacing as i32; + + // limit unsclaed + let limit = if up { + // ticks are limited by amount of space in the bitmap... + let array_limit = TICK_LIMIT.checked_sub(1).unwrap(); + // ...search range is limited to 256 at the time ... + let range_limit = index.checked_add(TICK_SEARCH_RANGE).unwrap(); + // ...also ticks for prices over 2^64 aren't needed + let price_limit = MAX_TICK.checked_div(tick_spacing as i32).unwrap(); + + array_limit.min(range_limit).min(price_limit) + } else { + let array_limit = (-TICK_LIMIT).checked_add(1).unwrap(); + let range_limit = index.checked_sub(TICK_SEARCH_RANGE).unwrap(); + let price_limit = -MAX_TICK.checked_div(tick_spacing as i32).unwrap(); + + array_limit.max(range_limit).max(price_limit) + }; + + // scaled by tick_spacing + limit.checked_mul(tick_spacing as i32).unwrap() +} + +#[account(zero_copy(unsafe))] +#[repr(packed)] +#[derive(AnchorDeserialize)] +pub struct Tickmap { + pub bitmap: [u8; 11091], // Tick limit / 4 +} + +impl Default for Tickmap { + fn default() -> Self { + Tickmap { bitmap: [0; 11091] } + } +} +impl Debug for Tickmap { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "{:?}", + self.bitmap.iter().fold(0, |acc, v| acc + v.count_ones()) + ) + } +} +size!(Tickmap); + +impl Tickmap { + pub fn get(&self, tick: i32, tick_spacing: u16) -> bool { + let (byte, bit) = tick_to_position(tick, tick_spacing); + let value = (self.bitmap[byte] >> bit) % 2; + + (value) == 1 + } + + pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) { + assert!( + self.get(tick, tick_spacing) != value, + "tick initialize tick again" + ); + + let (byte, bit) = tick_to_position(tick, tick_spacing); + + self.bitmap[byte] ^= 1 << bit; + } +} +pub struct TickmapSlice { + pub data: [u8; TICKMAP_SLICE_SIZE], + pub offset: i32, +} +impl Default for TickmapSlice { + fn default() -> Self { + Self { + data: [0u8; TICKMAP_SLICE_SIZE], + offset: 0, + } + } +} + +impl TickmapSlice { + pub fn calculate_search_range_offset(init_tick: i32, spacing: u16, up: bool) -> i32 { + let search_limit = get_search_limit(init_tick, spacing, up); + let position = tick_to_position(search_limit, spacing).0 as i32; + + if up { + position - TICKMAP_SLICE_SIZE as i32 + 1 + } else { + position + } + } + + pub fn from_slice( + tickmap_data: &[u8], + current_tick_index: i32, + tick_spacing: u16, + x_to_y: bool, + ) -> TrackableResult { + let offset = if x_to_y { + TICK_SEARCH_RANGE - TICKMAP_SLICE_SIZE as i32 * 8 - 8 + } else { + -TICK_SEARCH_RANGE + 8 + }; + + let start_index = ((current_tick_index / tick_spacing as i32 + TICK_LIMIT + offset) / 8) + .max(0) + .min((TICKMAP_SIZE + 1) / 8 - TICKMAP_SLICE_SIZE as i32) + .try_into() + .map_err(|_| err!("Failed to set start_index"))?; + let end_index = (start_index as i32 + TICKMAP_SLICE_SIZE as i32) + .min(tickmap_data.len() as i32) + .try_into() + .map_err(|_| err!("Failed to set end_index"))?; + + let mut data = [0u8; TICKMAP_SLICE_SIZE]; + data[..end_index - start_index].copy_from_slice(&tickmap_data[start_index..end_index]); + + Ok(TickmapSlice { + data, + offset: start_index as i32, + }) + } + + pub fn get(&self, index: usize) -> Option<&u8> { + let index = index.checked_sub(self.offset as usize)?; + self.data.get(index) + } + + pub fn get_mut(&mut self, index: usize) -> Option<&mut u8> { + let index = index.checked_sub(self.offset as usize)?; + self.data.get_mut(index) + } +} + +impl std::ops::Index for TickmapSlice { + type Output = u8; + fn index(&self, index: usize) -> &Self::Output { + self.get(index).unwrap() + } +} + +impl std::ops::IndexMut for TickmapSlice { + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + self.get_mut(index).unwrap() + } +} + +#[derive(Default)] +pub struct TickmapView { + pub bitmap: TickmapSlice, +} + +impl std::fmt::Debug for TickmapView { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + let count = self + .bitmap + .data + .iter() + .fold(0, |acc, v| acc + v.count_ones()); + write!(f, "{:?}", count) + } +} + +impl TickmapView { + pub fn next_initialized(&self, tick: i32, tick_spacing: u16) -> Option { + let limit = get_search_limit(tick, tick_spacing, true); + + // add 1 to not check current tick + let (mut byte, mut bit) = + tick_to_position(tick.checked_add(tick_spacing as i32).unwrap(), tick_spacing); + let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); + + while byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) { + // ignore some bits on first loop + let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); + let mut shifted = self.bitmap[byte] >> bit; + + // go through all bits in byte until it is zero + if shifted != 0 { + while shifted.checked_rem(2).unwrap() == 0 { + shifted >>= 1; + bit = bit.checked_add(1).unwrap(); + } + + return if byte < limiting_byte || (byte == limiting_byte && bit <= limiting_bit) { + let index: i32 = byte + .checked_mul(8) + .unwrap() + .checked_add(bit.into()) + .unwrap() + .try_into() + .unwrap(); + Some( + index + .checked_sub(TICK_LIMIT) + .unwrap() + .checked_mul(tick_spacing.try_into().unwrap()) + .unwrap(), + ) + } else { + None + }; + } + + // go to the text byte + if let Some(value) = byte.checked_add(1) { + byte = value; + } else { + return None; + } + bit = 0; + } + + None + } + + // tick_spacing - spacing already scaled by tick_spacing + pub fn prev_initialized(&self, tick: i32, tick_spacing: u16) -> Option { + // don't subtract 1 to check the current tick + let limit = get_search_limit(tick, tick_spacing, false); // limit scaled by tick_spacing + let (mut byte, mut bit) = tick_to_position(tick as i32, tick_spacing); + let (limiting_byte, limiting_bit) = tick_to_position(limit, tick_spacing); + + while byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) { + // always safe due to limitated domain of bit variable + let mut mask = 1u16.checked_shl(bit.try_into().unwrap()).unwrap(); // left = MSB direction (increase value) + let value = self.bitmap[byte] as u16; + + // enter if some of previous bits are initialized in current byte + if value.checked_rem(mask.checked_shl(1).unwrap()).unwrap() > 0 { + // skip uninitalized ticks + while value & mask == 0 { + mask >>= 1; + bit = bit.checked_sub(1).unwrap(); + } + + // return first initalized tick if limiit is not exceeded, otherswise return None + return if byte > limiting_byte || (byte == limiting_byte && bit >= limiting_bit) { + // no possibility to overflow + let index: i32 = byte + .checked_mul(8) + .unwrap() + .checked_add(bit.into()) + .unwrap() + .try_into() + .unwrap(); + + Some( + index + .checked_sub(TICK_LIMIT) + .unwrap() + .checked_mul(tick_spacing.try_into().unwrap()) + .unwrap(), + ) + } else { + None + }; + } + + // go to the next byte + if let Some(value) = byte.checked_sub(1) { + byte = value; + } else { + return None; + } + bit = 7; + } + + None + } + + pub fn get(&self, tick: i32, tick_spacing: u16) -> bool { + let (byte, bit) = tick_to_position(tick, tick_spacing); + let value = (self.bitmap[byte] >> bit) % 2; + + (value) == 1 + } + + pub fn flip(&mut self, value: bool, tick: i32, tick_spacing: u16) { + assert!( + self.get(tick, tick_spacing) != value, + "tick initialize tick again" + ); + + let (byte, bit) = tick_to_position(tick, tick_spacing); + + self.bitmap[byte] ^= 1 << bit; + } + + pub fn from_slice( + tickmap_data: &[u8], + current_tick_index: i32, + tick_spacing: u16, + x_to_y: bool, + ) -> TrackableResult { + let bitmap = + TickmapSlice::from_slice(tickmap_data, current_tick_index, tick_spacing, x_to_y)?; + Ok(Self { bitmap }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_next_and_prev_initialized() { + // initalized edges + { + for spacing in 1..=10 { + println!("spacing = {}", spacing); + let max_index = match spacing < 5 { + true => TICK_LIMIT - spacing, + false => (MAX_TICK / spacing) * spacing, + }; + let min_index = -max_index; + println!("max_index = {}", max_index); + println!("min_index = {}", min_index); + let offset_high = + TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true); + let offset_low = + TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false); + + let mut map_low = TickmapView { + bitmap: TickmapSlice { + offset: offset_low, + ..Default::default() + }, + }; + let mut map_high = TickmapView { + bitmap: TickmapSlice { + offset: offset_high, + ..Default::default() + }, + }; + map_low.flip(true, min_index, spacing as u16); + map_high.flip(true, max_index, spacing as u16); + + let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing; + + let prev = map_low.prev_initialized(min_index + tick_edge_diff, spacing as u16); + let next = map_high.next_initialized(max_index - tick_edge_diff, spacing as u16); + + if prev.is_some() { + println!("found prev = {}", prev.unwrap()); + } + if next.is_some() { + println!("found next = {}", next.unwrap()); + } + } + } + // unintalized edges + for spacing in 1..=1000 { + let max_index = match spacing < 5 { + true => TICK_LIMIT - spacing, + false => (MAX_TICK / spacing) * spacing, + }; + let min_index = -max_index; + + let tick_edge_diff = TICK_SEARCH_RANGE / spacing * spacing; + + let offset_high = + TickmapSlice::calculate_search_range_offset(max_index, spacing as u16, true); + let offset_low = + TickmapSlice::calculate_search_range_offset(min_index, spacing as u16, false); + let map_low = TickmapView { + bitmap: TickmapSlice { + offset: offset_low, + ..Default::default() + }, + }; + let map_high = TickmapView { + bitmap: TickmapSlice { + offset: offset_high, + ..Default::default() + }, + }; + + let prev = map_low.prev_initialized(min_index + tick_edge_diff, spacing as u16); + let next = map_high.next_initialized(max_index - tick_edge_diff, spacing as u16); + + if prev.is_some() { + println!("found prev = {}", prev.unwrap()); + } + if next.is_some() { + println!("found next = {}", next.unwrap()); + } + } + } + #[test] + fn test_slice_edges() { + let spacing = 1; + // low_bit == 0 + { + let mut tickmap = Tickmap::default(); + let low_byte = 0; + let low_bit = 0; + let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; + + let high_tick = low_tick + TICKMAP_RANGE as i32; + let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = + TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap(); + let tickmap_y_to_x = + TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, false).unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_x_to_y.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + // low_bit == 7 + { + let mut tickmap = Tickmap::default(); + let low_byte = 0; + let low_bit = 7; + let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; + + let high_tick = low_tick + TICKMAP_RANGE as i32; + let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = + TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, true).unwrap(); + let tickmap_y_to_x = + TickmapSlice::from_slice(&tickmap.bitmap, low_tick, spacing, false).unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_x_to_y.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + // high_bit = 7 + { + let mut tickmap = Tickmap::default(); + let high_byte = tickmap.bitmap.len() as i32 - 1; + let high_bit = 7; + let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; + + let low_tick = high_tick - TICKMAP_RANGE as i32; + let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = + TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap(); + let tickmap_y_to_x = + TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, false).unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_x_to_y.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + // high_bit = 0 + { + let mut tickmap = Tickmap::default(); + let high_byte = tickmap.bitmap.len() as i32 - 1; + let high_bit = 0; + let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; + + let low_tick = high_tick - TICKMAP_RANGE as i32; + let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = + TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, true).unwrap(); + let tickmap_y_to_x = + TickmapSlice::from_slice(&tickmap.bitmap, high_tick, spacing, false).unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_x_to_y.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + } + + #[test] + fn test_ticks_back() { + let spacing = 1; + let byte_offset = 10; + let range_offset_with_tick_back = + TICKMAP_SLICE_SIZE as i32 * 8 - TICKS_BACK_COUNT as i32 * TICK_SEARCH_RANGE; + // low_bit == 0 + { + let mut tickmap = Tickmap::default(); + let low_byte = byte_offset; + let low_bit = 0; + let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; + + let high_tick = low_tick + TICKMAP_RANGE as i32; + let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = TickmapSlice::from_slice( + &tickmap.bitmap, + low_tick + range_offset_with_tick_back, + spacing, + true, + ) + .unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_x_to_y.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + // low_bit == 7 + { + let mut tickmap = Tickmap::default(); + let low_byte = byte_offset; + let low_bit = 7; + let low_tick = low_byte * 8 + low_bit - TICK_LIMIT; + + let high_tick = low_tick + TICKMAP_RANGE as i32; + let (high_byte, _high_bit) = tick_to_position(high_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_x_to_y = TickmapSlice::from_slice( + &tickmap.bitmap, + low_tick + range_offset_with_tick_back, + spacing, + true, + ) + .unwrap(); + assert_eq!( + tickmap_x_to_y.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap.bitmap.get(high_byte as usize).unwrap(), + tickmap_x_to_y.get(high_byte as usize).unwrap() + ); + } + // high_bit = 7 + { + let mut tickmap = Tickmap::default(); + let high_byte = tickmap.bitmap.len() as i32 - 1 - byte_offset; + let high_bit = 7; + let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; + + let low_tick = high_tick - TICKMAP_RANGE as i32; + let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_y_to_x = TickmapSlice::from_slice( + &tickmap.bitmap, + high_tick - range_offset_with_tick_back, + spacing, + false, + ) + .unwrap(); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + // high_bit = 0 + { + let mut tickmap = Tickmap::default(); + let high_byte = tickmap.bitmap.len() as i32 - 1 - byte_offset; + let high_bit = 0; + let high_tick = high_byte * 8 + high_bit - TICK_LIMIT; + + let low_tick = high_tick - TICKMAP_RANGE as i32; + let (low_byte, _low_bit) = tick_to_position(low_tick, spacing); + + tickmap.flip(true, low_tick, spacing); + tickmap.flip(true, high_tick, spacing); + let tickmap_y_to_x = TickmapSlice::from_slice( + &tickmap.bitmap, + high_tick - range_offset_with_tick_back, + spacing, + false, + ) + .unwrap(); + assert_eq!( + tickmap_y_to_x.get(low_byte as usize).unwrap(), + tickmap.bitmap.get(low_byte as usize).unwrap() + ); + assert_eq!( + tickmap_y_to_x.get(high_byte as usize).unwrap(), + tickmap.bitmap.get(high_byte as usize).unwrap() + ); + } + } +} diff --git a/lib/dex-invariant/src/internal/invariant-types/src/utils.rs b/lib/dex-invariant/src/internal/invariant-types/src/utils.rs new file mode 100644 index 0000000..c3b11ca --- /dev/null +++ b/lib/dex-invariant/src/internal/invariant-types/src/utils.rs @@ -0,0 +1,236 @@ +use std::{cmp::Ordering, fmt::write}; + +use anchor_lang::prelude::Pubkey; + +use crate::ID; + +pub type TrackableResult = Result; + +#[derive(Debug)] +pub struct TrackableError { + pub cause: String, + pub stack: Vec, +} + +// static error causes +impl TrackableError { + pub const ADD: &'static str = "addition overflow"; + pub const SUB: &'static str = "subtraction underflow"; + pub const MUL: &'static str = "multiplication overflow"; + pub const DIV: &'static str = "division overflow or division by zero"; + pub fn cast() -> String { + format!("conversion to {} type failed", std::any::type_name::()) + } +} +impl std::fmt::Display for TrackableError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "Invariant simulation error: {}", self.cause) + } +} +impl std::error::Error for TrackableError { + fn source(&self) -> Option<&(dyn std::error::Error + 'static)> { + None + } +} + +impl TrackableError { + pub fn new(cause: &str, location: &str) -> Self { + Self { + cause: cause.to_string(), + stack: vec![location.to_string()], + } + } + + pub fn add_trace(&mut self, location: &str) { + self.stack.push(location.to_string()); + } + + pub fn to_string(&self) -> String { + let stack_trace = self.stack.join("\n-> "); + + format!( + "ERROR CAUSED BY: {}\nINVARIANT STACK TRACE:\n-> {}", + self.cause, stack_trace + ) + } + + pub fn get(&self) -> (String, String, Vec) { + ( + self.to_string().clone(), + self.cause.clone(), + self.stack.clone(), + ) + } +} + +pub fn get_pool_address( + first_token: Pubkey, + second_token: Pubkey, + fee: u128, + tick_spacing: u16, +) -> Pubkey { + let inverse = first_token.to_string().cmp(&second_token.to_string()) == Ordering::Less; + let (token_x, token_y) = match inverse { + true => (first_token, second_token), + false => (second_token, first_token), + }; + + let (pool_address, _) = Pubkey::find_program_address( + &[ + b"poolv1", + token_x.as_ref(), + token_y.as_ref(), + &fee.to_le_bytes(), + &tick_spacing.to_le_bytes(), + ], + &ID, + ); + pool_address +} + +#[macro_use] +pub mod trackable_result { + #[macro_export] + macro_rules! from_result { + ($op:expr) => { + match $op { + Ok(ok) => Ok(ok), + Err(err) => Err(err!(&err)), + } + }; + } + + #[macro_export] + macro_rules! err { + ($error:expr) => { + TrackableError::new($error, &location!()) + }; + } + + #[macro_export] + macro_rules! ok_or_mark_trace { + ($op:expr) => { + match $op { + Ok(ok) => Ok(ok), + Err(mut err) => Err(trace!(err)), + } + }; + } + + #[macro_export] + macro_rules! trace { + ($deeper:expr) => {{ + $deeper.add_trace(&location!()); + $deeper + }}; + } + + #[macro_export] + macro_rules! function { + () => {{ + fn f() {} + fn type_name_of(_: T) -> &'static str { + std::any::type_name::() + } + let name = type_name_of(f); + &name[..name.len() - 3] + }}; + } + + #[macro_export] + macro_rules! location { + () => {{ + format!("{}:{}:{}", file!(), function!(), line!()) + }}; + } +} + +#[cfg(test)] +mod trackable_error_tests { + use super::*; + + fn value() -> TrackableResult { + Ok(10u64) + } + + fn inner_fun() -> TrackableResult { + ok_or_mark_trace!(value()) + } + + fn outer_fun() -> TrackableResult { + ok_or_mark_trace!(inner_fun()) + } + + fn trigger_error() -> TrackableResult { + let _ = ok_or_mark_trace!(outer_fun())?; // unwrap without propagate error + Err(err!("trigger error")) + } + + fn trigger_result_error() -> Result { + Err("trigger error [result])".to_string()) + } + + fn inner_fun_err() -> TrackableResult { + ok_or_mark_trace!(trigger_error()) + } + + fn outer_fun_err() -> TrackableResult { + ok_or_mark_trace!(inner_fun_err()) + } + + fn inner_fun_from_result() -> TrackableResult { + from_result!(trigger_result_error()) + } + + fn outer_fun_from_result() -> TrackableResult { + ok_or_mark_trace!(inner_fun_from_result()) + } + + #[test] + fn test_trackable_result_type_flow() { + // ok + { + let value = outer_fun().unwrap(); + assert_eq!(value, 10u64); + } + // error + { + let result = outer_fun_err(); + let err = result.unwrap_err(); + let (format, cause, stack) = err.get(); + + println!("{}", format); + assert_eq!(stack.len(), 3); + assert_eq!(cause, "trigger error"); + } + // from_result + { + let err = outer_fun_from_result().unwrap_err(); + let (format, cause, stack) = err.get(); + println!("{}", format); + assert_eq!(stack.len(), 2); + assert_eq!(cause, "trigger error [result])"); + } + } +} + +#[cfg(test)] +mod tests { + use std::str::FromStr; + + #[test] + fn test_get_pool_address() { + use super::*; + let token_x = Pubkey::from_str("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v").unwrap(); + let token_y = Pubkey::from_str("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB").unwrap(); + let fee = 10000000; + let tick_spacing = 1; + + let pool_address_1 = get_pool_address(token_x, token_y, fee, tick_spacing); + let pool_address_2 = get_pool_address(token_y, token_x, fee, tick_spacing); + let expected = Pubkey::from_str("BRt1iVYDNoohkL1upEb8UfHE8yji6gEDAmuN9Y4yekyc").unwrap(); + + assert_eq!(pool_address_1, expected); + assert_eq!(pool_address_2, expected); + } +} diff --git a/lib/dex-invariant/src/internal/mod.rs b/lib/dex-invariant/src/internal/mod.rs new file mode 100644 index 0000000..174cbc9 --- /dev/null +++ b/lib/dex-invariant/src/internal/mod.rs @@ -0,0 +1,3 @@ +pub mod accounts; +pub mod swap; +pub mod tickmap_slice; diff --git a/lib/dex-invariant/src/internal/swap.rs b/lib/dex-invariant/src/internal/swap.rs new file mode 100644 index 0000000..dace76f --- /dev/null +++ b/lib/dex-invariant/src/internal/swap.rs @@ -0,0 +1,43 @@ +use invariant_types::{ + decimals::{CheckedOps, Decimal, Price, TokenAmount}, + log::get_tick_at_sqrt_price, + math::{ + compute_swap_step, cross_tick, get_closer_limit, get_max_sqrt_price, get_max_tick, + get_min_sqrt_price, get_min_tick, is_enough_amount_to_push_price, + }, + structs::{TICKS_BACK_COUNT, TICK_CROSSES_PER_IX}, + MAX_VIRTUAL_CROSS, +}; + +pub struct InvariantSimulationParams { + pub in_amount: u64, + pub x_to_y: bool, + pub by_amount_in: bool, + pub sqrt_price_limit: Price, +} + +#[derive(Clone, Default)] +pub struct InvariantSwapResult { + pub in_amount: u64, + pub out_amount: u64, + pub fee_amount: u64, + pub starting_sqrt_price: Price, + pub ending_sqrt_price: Price, + pub used_ticks: Vec, + pub global_insufficient_liquidity: bool, +} + +impl InvariantSwapResult { + pub fn break_swap_loop_early( + ticks_used: u16, + virtual_ticks_crossed: u16, + ) -> Result { + let break_loop = ticks_used + .checked_add(virtual_ticks_crossed) + .ok_or_else(|| "virtual ticks crossed + ticks crossed overflow")? + >= TICK_CROSSES_PER_IX as u16 + MAX_VIRTUAL_CROSS + || TICK_CROSSES_PER_IX <= ticks_used as usize; + + Ok(break_loop) + } +} diff --git a/lib/dex-invariant/src/internal/tickmap_slice.rs b/lib/dex-invariant/src/internal/tickmap_slice.rs new file mode 100644 index 0000000..e69de29 diff --git a/lib/dex-invariant/src/invariant_dex.rs b/lib/dex-invariant/src/invariant_dex.rs new file mode 100644 index 0000000..a1d6a81 --- /dev/null +++ b/lib/dex-invariant/src/invariant_dex.rs @@ -0,0 +1,487 @@ +use std::{ + collections::{HashMap, HashSet}, + sync::Arc, +}; + +use anchor_lang::{AnchorDeserialize, Id}; +use anchor_spl::{ + token::spl_token::{self, state::AccountState}, + token_2022::Token2022, +}; +use anyhow::{Context, Ok}; +use async_trait::async_trait; +use invariant_types::{ + math::{calculate_price_sqrt, get_max_tick, get_min_tick}, + structs::{Pool, Tick, Tickmap, TickmapView, TICK_CROSSES_PER_IX, TICK_LIMIT}, + ANCHOR_DISCRIMINATOR_SIZE, TICK_SEED, +}; +use router_feed_lib::router_rpc_client::{RouterRpcClient, RouterRpcClientTrait}; +use router_lib::dex::{ + AccountProviderView, DexEdge, DexEdgeIdentifier, DexInterface, DexSubscriptionMode, Quote, + SwapInstruction, +}; +use solana_account_decoder::UiAccountEncoding; +use solana_client::{ + rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig}, + rpc_filter::RpcFilterType, +}; +use solana_sdk::{account::ReadableAccount, program_pack::Pack, pubkey::Pubkey}; +use tracing::info; + +use crate::{ + invariant_edge::{InvariantEdge, InvariantEdgeIdentifier, InvariantSimulationParams}, + invariant_ix_builder::build_swap_ix, +}; + +pub struct InvariantDex { + pub edges: HashMap>>, +} + +#[derive(Debug)] +pub enum PriceDirection { + UP, + DOWN, +} + +impl InvariantDex { + pub fn deserialize(data: &[u8]) -> anyhow::Result + where + T: AnchorDeserialize, + { + T::try_from_slice(Self::extract_from_anchor_account(data)) + .map_err(|e| anyhow::anyhow!("Error deserializing account data: {:?}", e)) + } + + pub fn deserialize_tickmap_view( + data: &[u8], + current_tick_index: i32, + tick_spacing: u16, + x_to_y: bool, + ) -> anyhow::Result +where { + let tickmap_data = Self::extract_from_anchor_account(&data); + TickmapView::from_slice(tickmap_data, current_tick_index, tick_spacing, x_to_y) + .map_err(|e| anyhow::anyhow!("Error deserializing tickmap {:?}", e)) + } + + pub fn extract_from_anchor_account(data: &[u8]) -> &[u8] { + data.split_at(ANCHOR_DISCRIMINATOR_SIZE).1 + } + + pub fn tick_indexes_to_addresses(pool_address: Pubkey, indexes: &[i32]) -> Vec { + let pubkeys: Vec = indexes + .iter() + .map(|i| Self::tick_index_to_address(pool_address, *i)) + .collect(); + pubkeys + } + + pub fn tick_index_to_address(pool_address: Pubkey, i: i32) -> Pubkey { + let (pubkey, _) = Pubkey::find_program_address( + &[ + TICK_SEED.as_bytes(), + pool_address.as_ref(), + &i.to_le_bytes(), + ], + &crate::ID, + ); + pubkey + } + + pub fn get_closest_ticks_addresses( + pool: &Pool, + tickmap: &TickmapView, + pool_address: Pubkey, + direction: PriceDirection, + ) -> anyhow::Result> { + let indexes = Self::find_closest_tick_indexes( + &pool, + &tickmap.bitmap.data, + TICK_CROSSES_PER_IX, + tickmap.bitmap.offset, + direction, + )?; + + Ok(Self::tick_indexes_to_addresses(pool_address, &indexes)) + } + + fn find_closest_tick_indexes( + pool: &Pool, + bitmap: &[u8], + amount_limit: usize, + chunk_offset: i32, + direction: PriceDirection, + ) -> anyhow::Result> { + let tick_spacing: i32 = pool.tick_spacing.into(); + let current: i32 = pool.current_tick_index / tick_spacing + TICK_LIMIT - chunk_offset * 8; + let tickmap = bitmap; + + let mut found: Vec = Vec::new(); + if tickmap.len() != 0 { + let range = tickmap.len() as i32 * 8 - 1; + + let (mut above, mut below, mut reached_limit) = (0 as i32, range, false); + + let max = below; + let min = above; + + let tick_offset = chunk_offset * 8; + while !reached_limit && found.len() < amount_limit { + match direction { + PriceDirection::UP => { + let value_above: u8 = tickmap[(above / 8) as usize] & (1 << (above % 8)); + if value_above != 0 { + if above > current { + found.push(above + tick_offset); + } else if found.len() >= 1 { + found[0] = above + tick_offset; + } else { + found.push(above + tick_offset); + } + } + reached_limit = above >= max || found.len() >= amount_limit; + above += 1; + } + PriceDirection::DOWN => { + let value_below: u8 = tickmap[(below / 8) as usize] & (1 << (below % 8)); + if value_below != 0 { + if below <= current { + found.push(below + tick_offset); + } else if found.len() >= 1 { + found[0] = below + tick_offset; + } else { + found.push(below + tick_offset); + } + } + reached_limit = below <= min || found.len() >= amount_limit; + below -= 1; + } + } + } + } + Ok(found + .iter() + .map(|i: &i32| (i - TICK_LIMIT) * tick_spacing) + .collect()) + } + + fn find_all_tick_indexes(tick_spacing: u16, tickmap: &Tickmap) -> anyhow::Result> { + let tick_spacing: i32 = tick_spacing.into(); + let tickmap = tickmap.bitmap; + + let max_tick = get_max_tick(tick_spacing as u16)? / tick_spacing + TICK_LIMIT; + let min_tick = get_min_tick(tick_spacing as u16)? / tick_spacing + TICK_LIMIT; + let mut tick = min_tick; + let mut found = Vec::new(); + while tick <= max_tick { + let tick_value: u8 = tickmap[(tick / 8) as usize] & (1 << (tick % 8)); + if tick_value != 0 { + found.push(tick); + } + tick += 1; + } + + Ok(found + .iter() + .map(|i: &i32| (i - TICK_LIMIT) * tick_spacing) + .collect()) + } + + fn load_edge( + id: &InvariantEdgeIdentifier, + chain_data: &AccountProviderView, + ) -> anyhow::Result { + let pool_account_data = chain_data.account(&id.pool)?; + let pool = Self::deserialize::(pool_account_data.account.data())?; + + let tickmap_account_data = chain_data.account(&pool.tickmap)?; + let tickmap = Self::deserialize_tickmap_view( + &tickmap_account_data.account.data(), + pool.current_tick_index, + pool.tick_spacing, + id.x_to_y, + )?; + + let price_direction = match id.x_to_y { + true => PriceDirection::DOWN, + false => PriceDirection::UP, + }; + + let tick_pks = + &Self::get_closest_ticks_addresses(&pool, &tickmap, id.pool, price_direction)?; + let mut ticks = Vec::with_capacity(tick_pks.len()); + + for tick_pk in tick_pks { + let tick_data = chain_data.account(&tick_pk)?; + let tick = + Self::deserialize::(tick_data.account.data()).unwrap_or(Default::default()); + ticks.push(tick) + } + + Ok(InvariantEdge { + ticks, + pool, + tickmap, + }) + } +} + +#[async_trait] +impl DexInterface for InvariantDex { + async fn initialize( + rpc: &mut RouterRpcClient, + _options: HashMap, + ) -> anyhow::Result> + where + Self: Sized, + { + let mut pools = fetch_invariant_accounts(rpc, crate::id()).await?; + + let reserves = pools + .iter() + .flat_map(|x| [x.1.token_x_reserve, x.1.token_y_reserve]) + .collect::>(); + + let vaults = rpc.get_multiple_accounts(&reserves).await?; + let banned_reserves = vaults + .iter() + .filter(|(_, reserve)| { + reserve.owner == Token2022::id() + || spl_token::state::Account::unpack(reserve.data()) + .unwrap() + .state + == AccountState::Frozen + }) + .map(|(pk, _)| pk) + .collect::>(); + + pools.retain(|p| { + !(banned_reserves.contains(&p.1.token_x_reserve) + || banned_reserves.contains(&p.1.token_y_reserve)) + }); + + info!("Number of Invariant Pools: {:?}", pools.len()); + + let edge_pairs: Vec<(Arc, Arc)> = pools + .iter() + .map(|(pool_pk, pool)| { + ( + Arc::new(InvariantEdgeIdentifier { + pool: *pool_pk, + token_x: pool.token_x, + token_y: pool.token_y, + x_to_y: true, + }), + Arc::new(InvariantEdgeIdentifier { + pool: *pool_pk, + token_x: pool.token_x, + token_y: pool.token_y, + x_to_y: false, + }), + ) + }) + .into_iter() + .collect(); + let tickmaps = pools.iter().map(|p| p.1.tickmap).collect(); + let tickmaps = rpc.get_multiple_accounts(&tickmaps).await?; + + let edges_per_pk = { + let mut map = HashMap::new(); + let pools_with_edge_pairs = pools.iter().zip(tickmaps.iter()).zip(edge_pairs.iter()); + for (((pool_pk, pool), (tickmap_pk, tickmap_acc)), (edge_x_to_y, edge_y_to_x)) in + pools_with_edge_pairs + { + let entry: Vec> = + vec![edge_x_to_y.clone(), edge_y_to_x.clone()]; + map.insert(*pool_pk, entry.clone()); + map.insert(*tickmap_pk, entry.clone()); + + let tickmap_account_data = tickmap_acc.data(); + let tickmap = Self::deserialize::(tickmap_account_data)?; + let indexes = Self::find_all_tick_indexes(pool.tick_spacing, &tickmap)?; + for tick in indexes { + map.insert(Self::tick_index_to_address(*pool_pk, tick), entry.clone()); + } + } + map + }; + + Ok(Arc::new(InvariantDex { + edges: edges_per_pk, + })) + } + + fn name(&self) -> String { + "Invariant".to_string() + } + + fn subscription_mode(&self) -> DexSubscriptionMode { + DexSubscriptionMode::Programs(HashSet::from([crate::ID])) + } + + fn program_ids(&self) -> HashSet { + [crate::id()].into_iter().collect() + } + + fn edges_per_pk(&self) -> HashMap>> { + self.edges.clone() + } + + fn load( + &self, + id: &Arc, + chain_data: &AccountProviderView, + ) -> anyhow::Result> { + let id = id + .as_any() + .downcast_ref::() + .unwrap(); + let edge = Self::load_edge(id, chain_data)?; + + Ok(Arc::new(edge)) + } + + fn quote( + &self, + id: &Arc, + edge: &Arc, + _chain_data: &AccountProviderView, + in_amount: u64, + ) -> anyhow::Result { + let edge = edge.as_any().downcast_ref::().unwrap(); + let id = id + .as_any() + .downcast_ref::() + .unwrap(); + + let x_to_y = id.x_to_y; + let sqrt_price_limit = if x_to_y { + calculate_price_sqrt(get_min_tick(edge.pool.tick_spacing)?) + } else { + calculate_price_sqrt(get_max_tick(edge.pool.tick_spacing)?) + }; + + let simulation = edge + .simulate_invariant_swap(&InvariantSimulationParams { + x_to_y, + in_amount, + sqrt_price_limit, + by_amount_in: true, + }) + .map_err(|e| anyhow::format_err!(e)) + .with_context(|| format!("pool {} x_to_y {}", id.pool, id.x_to_y))?; + + let fee_mint = if x_to_y { id.token_x } else { id.token_y }; + + Ok(Quote { + in_amount: simulation.in_amount, + out_amount: simulation.out_amount, + fee_amount: simulation.fee_amount, + fee_mint: fee_mint, + }) + } + + fn build_swap_ix( + &self, + id: &Arc, + chain_data: &AccountProviderView, + wallet_pk: &Pubkey, + in_amount: u64, + out_amount: u64, + max_slippage_bps: i32, + ) -> anyhow::Result { + let id = { + id.as_any() + .downcast_ref::() + .unwrap() + }; + + let edge = Self::load_edge(id, chain_data)?; + + let swap_ix = build_swap_ix( + id, + &edge, + chain_data, + wallet_pk, + in_amount, + out_amount, + max_slippage_bps, + )?; + + Ok(swap_ix) + } + + fn supports_exact_out(&self, _id: &Arc) -> bool { + false + } + + fn quote_exact_out( + &self, + id: &Arc, + edge: &Arc, + _chain_data: &AccountProviderView, + out_amount: u64, + ) -> anyhow::Result { + anyhow::bail!("Not supported"); + + let edge = edge.as_any().downcast_ref::().unwrap(); + let id = id + .as_any() + .downcast_ref::() + .unwrap(); + + let x_to_y = id.x_to_y; + let sqrt_price_limit = if x_to_y { + calculate_price_sqrt(get_min_tick(edge.pool.tick_spacing)?) + } else { + calculate_price_sqrt(get_max_tick(edge.pool.tick_spacing)?) + }; + + let simulation = edge + .simulate_invariant_swap(&InvariantSimulationParams { + x_to_y, + in_amount: out_amount, + sqrt_price_limit, + by_amount_in: true, + }) + .map_err(|e| anyhow::format_err!(e)) + .with_context(|| format!("pool {} x_to_y {}", id.pool, id.x_to_y))?; + + let fee_mint = if x_to_y { id.token_x } else { id.token_y }; + + Ok(Quote { + in_amount: simulation.in_amount, + out_amount: simulation.out_amount, + fee_amount: simulation.fee_amount, + fee_mint: fee_mint, + }) + } +} + +async fn fetch_invariant_accounts( + rpc: &mut RouterRpcClient, + program_id: Pubkey, +) -> anyhow::Result> { + let config = RpcProgramAccountsConfig { + filters: Some(vec![RpcFilterType::DataSize(Pool::LEN as u64)]), + account_config: RpcAccountInfoConfig { + encoding: Some(UiAccountEncoding::Base64), + ..Default::default() + }, + ..Default::default() + }; + + let snapshot = rpc + .get_program_accounts_with_config(&program_id, config) + .await?; + + let result = snapshot + .iter() + .filter_map(|account| { + let pool = InvariantDex::deserialize::(account.data.as_slice()); + pool.ok().map(|x| (account.pubkey, x)) + }) + .collect(); + + Ok(result) +} diff --git a/lib/dex-invariant/src/invariant_edge.rs b/lib/dex-invariant/src/invariant_edge.rs new file mode 100644 index 0000000..0f19c56 --- /dev/null +++ b/lib/dex-invariant/src/invariant_edge.rs @@ -0,0 +1,284 @@ +use crate::internal::swap::InvariantSwapResult; +use decimal::*; +use invariant_types::{ + decimals::{Price, TokenAmount}, + log::get_tick_at_sqrt_price, + math::{ + compute_swap_step, cross_tick_no_fee_growth_update, get_closer_limit, get_max_tick, + get_min_tick, is_enough_amount_to_push_price, + }, + structs::{Pool, Tick, TickmapView, TICKS_BACK_COUNT, TICK_CROSSES_PER_IX}, +}; +use solana_program::pubkey::Pubkey; +use std::any::Any; + +use router_lib::dex::{DexEdge, DexEdgeIdentifier}; + +#[derive(Debug, Default, PartialEq, Eq)] +pub struct InvariantEdgeIdentifier { + pub pool: Pubkey, + pub token_x: Pubkey, + pub token_y: Pubkey, + pub x_to_y: bool, +} + +impl DexEdgeIdentifier for InvariantEdgeIdentifier { + fn key(&self) -> Pubkey { + self.pool + } + + fn desc(&self) -> String { + format!("Invariant_{}", self.pool) + } + + fn input_mint(&self) -> Pubkey { + if self.x_to_y { + self.token_x + } else { + self.token_y + } + } + + fn output_mint(&self) -> Pubkey { + if self.x_to_y { + self.token_y + } else { + self.token_x + } + } + + fn accounts_needed(&self) -> usize { + 13 // total accounts without ticks + - 2 // user output ATA + user wallet address + + TICK_CROSSES_PER_IX + TICKS_BACK_COUNT + } + + fn as_any(&self) -> &dyn Any { + self + } +} + +#[derive(Default, Debug)] +pub struct InvariantEdge { + pub ticks: Vec, + pub pool: Pool, + pub tickmap: TickmapView, +} + +#[derive(Debug, Default)] +pub struct InvariantSimulationParams { + pub x_to_y: bool, + pub in_amount: u64, + pub sqrt_price_limit: Price, + pub by_amount_in: bool, +} + +impl InvariantEdge { + pub fn simulate_invariant_swap( + &self, + invariant_simulation_params: &InvariantSimulationParams, + ) -> Result { + let InvariantSimulationParams { + x_to_y, + in_amount, + sqrt_price_limit, + by_amount_in, + } = *invariant_simulation_params; + + let mut pool = self.pool.clone(); + let tickmap = &self.tickmap; + let ticks = self.ticks.to_vec(); + let starting_sqrt_price = pool.sqrt_price; + let current_tick_index = pool.current_tick_index; + let pool = &mut pool; + + let (mut remaining_amount, mut total_amount_in, mut total_amount_out, mut total_fee_amount) = ( + TokenAmount::new(in_amount), + TokenAmount::new(0), + TokenAmount::new(0), + TokenAmount::new(0), + ); + let (mut used_ticks, mut virtual_cross_counter, mut global_insufficient_liquidity) = + (Vec::new(), 0u16, false); + + let mut current_tick_array_index = 0; + while current_tick_array_index < ticks.len() { + let index = ticks[current_tick_array_index].index; + let skip = if x_to_y { + index > current_tick_index + } else { + index <= current_tick_index + }; + if skip { + current_tick_array_index += 1; + } else { + break; + } + } + + while !remaining_amount.is_zero() { + let (swap_limit, limiting_tick) = match get_closer_limit( + sqrt_price_limit, + x_to_y, + pool.current_tick_index, + pool.tick_spacing, + tickmap, + ) { + Ok((swap_limit, limiting_tick)) => (swap_limit, limiting_tick), + Err(_) => { + global_insufficient_liquidity = true; + break; + } + }; + + let result = compute_swap_step( + pool.sqrt_price, + swap_limit, + pool.liquidity, + remaining_amount, + by_amount_in, + pool.fee, + ) + .map_err(|e| { + let (formatted, _, _) = e.get(); + formatted + })?; + + remaining_amount = + remaining_amount.checked_sub(result.amount_in.checked_add(result.fee_amount)?)?; + pool.sqrt_price = result.next_price_sqrt; + total_amount_in = total_amount_in + .checked_add(result.amount_in)? + .checked_add(result.fee_amount)?; + total_amount_out = total_amount_out.checked_add(result.amount_out)?; + total_fee_amount = total_fee_amount.checked_add(result.fee_amount)?; + + if { pool.sqrt_price } == sqrt_price_limit && !remaining_amount.is_zero() { + global_insufficient_liquidity = true; + break; + } + let reached_tick_limit = match x_to_y { + true => { + pool.current_tick_index + <= get_min_tick(pool.tick_spacing).map_err(|err| err.cause)? + } + false => { + pool.current_tick_index + >= get_max_tick(pool.tick_spacing).map_err(|err| err.cause)? + } + }; + if reached_tick_limit { + global_insufficient_liquidity = true; + break; + } + // crossing tick + if result.next_price_sqrt == swap_limit && limiting_tick.is_some() { + let (tick_index, initialized) = limiting_tick.unwrap(); + let is_enough_amount_to_cross = is_enough_amount_to_push_price( + remaining_amount, + result.next_price_sqrt, + pool.liquidity, + pool.fee, + by_amount_in, + x_to_y, + ) + .map_err(|e| { + let (formatted, _, _) = e.get(); + formatted + })?; + + if initialized { + // tick to fallback to in case no tick is found + used_ticks.push(tick_index); + let default_tick = Tick { + index: tick_index, + ..Default::default() + }; + + // ticks should be sorted in the same order as the swap + let tick = &match ticks.get(current_tick_array_index) { + Some(tick) => { + if tick.index != tick_index { + default_tick + } else { + current_tick_array_index += 1; + *tick + } + } + None => default_tick, + }; + + // crossing tick + if !x_to_y || is_enough_amount_to_cross { + if cross_tick_no_fee_growth_update(tick, pool).is_err() { + global_insufficient_liquidity = true; + break; + } + } else if !remaining_amount.is_zero() { + total_amount_in = total_amount_in + .checked_add(remaining_amount) + .map_err(|_| "add overflow")?; + remaining_amount = TokenAmount(0); + } + } else { + virtual_cross_counter = + virtual_cross_counter.checked_add(1).ok_or("add overflow")?; + if InvariantSwapResult::break_swap_loop_early( + used_ticks.len() as u16, + virtual_cross_counter, + )? { + global_insufficient_liquidity = true; + break; + } + } + + pool.current_tick_index = if x_to_y && is_enough_amount_to_cross { + tick_index + .checked_sub(pool.tick_spacing as i32) + .ok_or("sub overflow")? + } else { + tick_index + }; + } else { + if pool + .current_tick_index + .checked_rem(pool.tick_spacing.into()) + .unwrap() + != 0 + { + return Err("Internal Invariant Error: Invalid tick".to_string()); + } + pool.current_tick_index = + get_tick_at_sqrt_price(result.next_price_sqrt, pool.tick_spacing); + virtual_cross_counter = + virtual_cross_counter.checked_add(1).ok_or("add overflow")?; + if InvariantSwapResult::break_swap_loop_early( + used_ticks.len() as u16, + virtual_cross_counter, + )? { + global_insufficient_liquidity = true; + break; + } + } + } + + if global_insufficient_liquidity { + return Err("Insufficient liquidity".to_owned()); + } + + Ok(InvariantSwapResult { + in_amount: total_amount_in.0, + out_amount: total_amount_out.0, + fee_amount: total_fee_amount.0, + starting_sqrt_price: starting_sqrt_price, + ending_sqrt_price: pool.sqrt_price, + used_ticks, + global_insufficient_liquidity, + }) + } +} +impl DexEdge for InvariantEdge { + fn as_any(&self) -> &dyn Any { + self + } +} diff --git a/lib/dex-invariant/src/invariant_ix_builder.rs b/lib/dex-invariant/src/invariant_ix_builder.rs new file mode 100644 index 0000000..a8b887b --- /dev/null +++ b/lib/dex-invariant/src/invariant_ix_builder.rs @@ -0,0 +1,84 @@ +use crate::internal::accounts::{InvariantSwapAccounts, InvariantSwapParams}; +use crate::invariant_edge::{InvariantEdge, InvariantEdgeIdentifier, InvariantSimulationParams}; +use anchor_spl::associated_token::get_associated_token_address; +use anyhow::Context; +use invariant_types::math::{get_max_sqrt_price, get_min_sqrt_price}; +use router_lib::dex::{AccountProviderView, DexEdgeIdentifier, SwapInstruction}; +use sha2::{Digest, Sha256}; +use solana_program::instruction::Instruction; +use solana_program::pubkey::Pubkey; + +pub fn build_swap_ix( + id: &InvariantEdgeIdentifier, + edge: &InvariantEdge, + chain_data: &AccountProviderView, + wallet_pk: &Pubkey, + in_amount: u64, + _out_amount: u64, + _max_slippage_bps: i32, +) -> anyhow::Result { + let by_amount_in = true; + + let (source_mint, destination_mint) = (id.input_mint(), id.output_mint()); + + let (source_account, destination_account) = ( + get_associated_token_address(wallet_pk, &source_mint), + get_associated_token_address(wallet_pk, &destination_mint), + ); + + let sqrt_price_limit = if id.x_to_y { + get_min_sqrt_price(edge.pool.tick_spacing)? + } else { + get_max_sqrt_price(edge.pool.tick_spacing)? + }; + + let invariant_swap_result = &edge + .simulate_invariant_swap(&InvariantSimulationParams { + x_to_y: id.x_to_y, + in_amount, + sqrt_price_limit, + by_amount_in, + }) + .map_err(|e| anyhow::format_err!(e)) + .with_context(|| format!("pool {} x_to_y {}", id.pool, id.x_to_y))?; + + let swap_params = InvariantSwapParams { + source_account, + destination_account, + source_mint, + destination_mint, + owner: *wallet_pk, + invariant_swap_result, + referral_fee: None, + }; + + let (swap_accounts, _x_to_y) = + InvariantSwapAccounts::from_pubkeys(chain_data, edge, id.pool, &swap_params)?; + let metas = swap_accounts.to_account_metas(); + + let discriminator = &Sha256::digest(b"global:swap")[0..8]; + + let expected_size = 8 + 1 + 8 + 1 + 16; + let mut ix_data: Vec = Vec::with_capacity(expected_size); + ix_data.extend_from_slice(discriminator); + ix_data.push(id.x_to_y as u8); + ix_data.extend_from_slice(&in_amount.to_le_bytes()); + ix_data.push(by_amount_in as u8); // by amount in + ix_data.extend_from_slice(&sqrt_price_limit.v.to_le_bytes()); + + assert_eq!(expected_size, ix_data.len()); + + let result = SwapInstruction { + instruction: Instruction { + program_id: crate::ID, + accounts: metas, + data: ix_data, + }, + out_pubkey: destination_account, + out_mint: destination_mint, + in_amount_offset: 9, + cu_estimate: Some(120000), //p95 + }; + + Ok(result) +} diff --git a/lib/dex-invariant/src/lib.rs b/lib/dex-invariant/src/lib.rs new file mode 100644 index 0000000..ecb5e70 --- /dev/null +++ b/lib/dex-invariant/src/lib.rs @@ -0,0 +1,13 @@ +mod internal; +mod invariant_dex; +mod invariant_edge; +mod invariant_ix_builder; + +pub use invariant_dex::InvariantDex; + +use solana_sdk::declare_id; + +// SOL +// declare_id!("HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt"); +// eclipse +declare_id!("iNvTyprs4TX8m6UeUEkeqDFjAL9zRCRWcexK9Sd4WEU"); diff --git a/lib/dex-invariant/tests/test_invariant.rs b/lib/dex-invariant/tests/test_invariant.rs new file mode 100644 index 0000000..62e0522 --- /dev/null +++ b/lib/dex-invariant/tests/test_invariant.rs @@ -0,0 +1,40 @@ +use solana_program_test::tokio; +use std::collections::HashMap; +use std::env; + +use router_lib::dex::DexInterface; +use router_lib::test_tools::{generate_dex_rpc_dump, rpc}; + +#[tokio::test] +async fn test_dump_input_data_invariant() -> anyhow::Result<()> { + let options = HashMap::from([]); + + if router_test_lib::config_should_dump_mainnet_data() { + invariant_step_1(&options).await?; + } + + invariant_step_2(&options).await?; + + Ok(()) +} + +async fn invariant_step_1(options: &HashMap) -> anyhow::Result<()> { + let rpc_url = env::var("RPC_HTTP_URL")?; + + let (mut rpc_client, chain_data) = rpc::rpc_dumper_client(rpc_url, "invariant_swap.lz4"); + let dex = dex_invariant::InvariantDex::initialize(&mut rpc_client, options.clone()).await?; + + generate_dex_rpc_dump::run_dump_mainnet_data(dex, rpc_client, chain_data).await?; + + Ok(()) +} + +async fn invariant_step_2(options: &HashMap) -> anyhow::Result<()> { + let (mut rpc_client, chain_data) = rpc::rpc_replayer_client("invariant_swap.lz4"); + + let dex = dex_invariant::InvariantDex::initialize(&mut rpc_client, options.clone()).await?; + + generate_dex_rpc_dump::run_dump_swap_ix("invariant_swap.lz4", dex, chain_data).await?; + + Ok(()) +} diff --git a/programs/simulator/tests/cases/test_swap_from_dump.rs b/programs/simulator/tests/cases/test_swap_from_dump.rs index c601ef6..87aa22d 100644 --- a/programs/simulator/tests/cases/test_swap_from_dump.rs +++ b/programs/simulator/tests/cases/test_swap_from_dump.rs @@ -72,6 +72,11 @@ async fn test_quote_match_swap_for_infinity() -> anyhow::Result<()> { run_all_swap_from_dump("infinity_swap.lz4").await? } +#[tokio::test] +async fn test_quote_match_swap_for_invariant() -> anyhow::Result<()> { + run_all_swap_from_dump("invariant_swap.lz4").await? +} + async fn run_all_swap_from_dump(dump_name: &str) -> Result, Error> { tracing_subscriber::fmt::init(); diff --git a/programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so b/programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so new file mode 100644 index 0000000..2d2e604 Binary files /dev/null and b/programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so differ diff --git a/programs/simulator/tests/fixtures/iNvTyprs4TX8m6UeUEkeqDFjAL9zRCRWcexK9Sd4WEU.so b/programs/simulator/tests/fixtures/iNvTyprs4TX8m6UeUEkeqDFjAL9zRCRWcexK9Sd4WEU.so new file mode 100644 index 0000000..2f271ac Binary files /dev/null and b/programs/simulator/tests/fixtures/iNvTyprs4TX8m6UeUEkeqDFjAL9zRCRWcexK9Sd4WEU.so differ