blockworks-foundation
/
autobahn
mirror of https://github.com/blockworks-foundation/autobahn.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Invariant integration (#30) 

* add internal setup

* remove compression from getProgramAccounts

* add autobahn .so

* add working testnet

* update version to 0.29.0

* remove debug logs

* fix swap simulation

* fix dex

* use mainnet address

* add default tick and remove fee growth calculations

* add smaller tickmap
improve error handling
fix swap limits

* add find all tick indexes

* remove dbg logs

* update edge identifier

* remove unused imports

* improve error handling

* remove pool filtering

* add decimal as a package

* remove testnet fixture

* add token2022 support

* Revert "add autobahn .so"

This reverts commit 515d2ddc53.

* Revert "remove compression from getProgramAccounts"

This reverts commit ca7bf93787.
This commit is contained in:
Michał Smykała 2024-11-06 16:43:49 +01:00 committed by GitHub
parent fa5a08973f
commit 465a601600
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
27 changed files with 5404 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
Cargo.lock generated
View File

@ -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"

41
lib/dex-invariant/Cargo.toml Normal file
View File

@ -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" }

136
lib/dex-invariant/src/internal/accounts.rs Normal file
View File

@ -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<Pubkey>,
}
#[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<Pubkey>,
referral_fee: Option<Pubkey>,
}
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<AccountMeta> {
let mut account_metas: Vec<AccountMeta> = 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<AccountMeta> = 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
}
}

20
lib/dex-invariant/src/internal/invariant-types/Cargo.toml Normal file
View File

@ -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"

400
lib/dex-invariant/src/internal/invariant-types/src/decimals.rs Normal file
View File

@ -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<TokenAmount> {
let token_amount = nominator
.checked_mul(Self::one::<U256>())?
.checked_div(denominator)?
.checked_div(Self::one::<U256>())?
.try_into()
.ok()?;
Some(TokenAmount::new(token_amount))
}
pub fn big_div_values_to_token_up(nominator: U256, denominator: U256) -> Option<TokenAmount> {
let token_amount = nominator
.checked_mul(Self::one::<U256>())?
.checked_add(denominator - 1)?
.checked_div(denominator)?
.checked_add(Self::almost_one::<U256>())?
.checked_div(Self::one::<U256>())?
.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::<U256>())
.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<Price> {
Ok(Price::new(
nominator
.checked_mul(Self::one::<U256>())
.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::<Self>().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::<U256>();
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::<U256>();
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);
}
}
}

67
lib/dex-invariant/src/internal/invariant-types/src/errors.rs Normal file
View File

@ -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
}

18
lib/dex-invariant/src/internal/invariant-types/src/lib.rs Normal file
View File

@ -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;

549
lib/dex-invariant/src/internal/invariant-types/src/log.rs Normal file
View File

@ -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);
}
}
}
}
}

8
lib/dex-invariant/src/internal/invariant-types/src/macros.rs Normal file
View File

@ -0,0 +1,8 @@
#[macro_export]
macro_rules! size {
($name: ident) => {
impl $name {
pub const LEN: usize = std::mem::size_of::<$name>() + 8;
}
};
}

2129
lib/dex-invariant/src/internal/invariant-types/src/math.rs Normal file
View File

File diff suppressed because it is too large Load Diff

12
lib/dex-invariant/src/internal/invariant-types/src/structs/fee_tier.rs Normal file
View File

@ -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);

9
lib/dex-invariant/src/internal/invariant-types/src/structs/mod.rs Normal file
View File

@ -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::*;

33
lib/dex-invariant/src/internal/invariant-types/src/structs/pool.rs Normal file
View File

@ -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);

20
lib/dex-invariant/src/internal/invariant-types/src/structs/tick.rs Normal file
View File

@ -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);

685
lib/dex-invariant/src/internal/invariant-types/src/structs/tickmap.rs Normal file
View File

@ -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<Self> {
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<usize> for TickmapSlice {
type Output = u8;
fn index(&self, index: usize) -> &Self::Output {
self.get(index).unwrap()
}
}
impl std::ops::IndexMut<usize> 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<i32> {
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<i32> {
// 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<Self> {
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()
);
}
}
}

236
lib/dex-invariant/src/internal/invariant-types/src/utils.rs Normal file
View File

@ -0,0 +1,236 @@
use std::{cmp::Ordering, fmt::write};
use anchor_lang::prelude::Pubkey;
use crate::ID;
pub type TrackableResult<T> = Result<T, TrackableError>;
#[derive(Debug)]
pub struct TrackableError {
pub cause: String,
pub stack: Vec<String>,
}
// 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<T: ?Sized>() -> String {
format!("conversion to {} type failed", std::any::type_name::<T>())
}
}
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<String>) {
(
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>(_: T) -> &'static str {
std::any::type_name::<T>()
}
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<u64> {
Ok(10u64)
}
fn inner_fun() -> TrackableResult<u64> {
ok_or_mark_trace!(value())
}
fn outer_fun() -> TrackableResult<u64> {
ok_or_mark_trace!(inner_fun())
}
fn trigger_error() -> TrackableResult<u64> {
let _ = ok_or_mark_trace!(outer_fun())?; // unwrap without propagate error
Err(err!("trigger error"))
}
fn trigger_result_error() -> Result<u64, String> {
Err("trigger error [result])".to_string())
}
fn inner_fun_err() -> TrackableResult<u64> {
ok_or_mark_trace!(trigger_error())
}
fn outer_fun_err() -> TrackableResult<u64> {
ok_or_mark_trace!(inner_fun_err())
}
fn inner_fun_from_result() -> TrackableResult<u64> {
from_result!(trigger_result_error())
}
fn outer_fun_from_result() -> TrackableResult<u64> {
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);
}
}

3
lib/dex-invariant/src/internal/mod.rs Normal file
View File

@ -0,0 +1,3 @@
pub mod accounts;
pub mod swap;
pub mod tickmap_slice;

43
lib/dex-invariant/src/internal/swap.rs Normal file
View File

@ -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<i32>,
pub global_insufficient_liquidity: bool,
}
impl InvariantSwapResult {
pub fn break_swap_loop_early(
ticks_used: u16,
virtual_ticks_crossed: u16,
) -> Result<bool, String> {
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)
}
}

0
lib/dex-invariant/src/internal/tickmap_slice.rs Normal file
View File

487
lib/dex-invariant/src/invariant_dex.rs Normal file
View File

@ -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<Pubkey, Vec<Arc<dyn DexEdgeIdentifier>>>,
}
#[derive(Debug)]
pub enum PriceDirection {
UP,
DOWN,
}
impl InvariantDex {
pub fn deserialize<T>(data: &[u8]) -> anyhow::Result<T>
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<TickmapView>
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<Pubkey> {
let pubkeys: Vec<Pubkey> = 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<Vec<Pubkey>> {
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<Vec<i32>> {
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<i32> = 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<Vec<i32>> {
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<InvariantEdge> {
let pool_account_data = chain_data.account(&id.pool)?;
let pool = Self::deserialize::<Pool>(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>(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<String, String>,
) -> anyhow::Result<Arc<dyn DexInterface>>
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::<HashSet<_>>();
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::<HashSet<_>>();
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<InvariantEdgeIdentifier>, Arc<InvariantEdgeIdentifier>)> = 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<Arc<dyn DexEdgeIdentifier>> =
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>(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<Pubkey> {
[crate::id()].into_iter().collect()
}
fn edges_per_pk(&self) -> HashMap<Pubkey, Vec<Arc<dyn DexEdgeIdentifier>>> {
self.edges.clone()
}
fn load(
&self,
id: &Arc<dyn DexEdgeIdentifier>,
chain_data: &AccountProviderView,
) -> anyhow::Result<Arc<dyn DexEdge>> {
let id = id
.as_any()
.downcast_ref::<InvariantEdgeIdentifier>()
.unwrap();
let edge = Self::load_edge(id, chain_data)?;
Ok(Arc::new(edge))
}
fn quote(
&self,
id: &Arc<dyn DexEdgeIdentifier>,
edge: &Arc<dyn DexEdge>,
_chain_data: &AccountProviderView,
in_amount: u64,
) -> anyhow::Result<Quote> {
let edge = edge.as_any().downcast_ref::<InvariantEdge>().unwrap();
let id = id
.as_any()
.downcast_ref::<InvariantEdgeIdentifier>()
.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<dyn DexEdgeIdentifier>,
chain_data: &AccountProviderView,
wallet_pk: &Pubkey,
in_amount: u64,
out_amount: u64,
max_slippage_bps: i32,
) -> anyhow::Result<SwapInstruction> {
let id = {
id.as_any()
.downcast_ref::<InvariantEdgeIdentifier>()
.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<dyn DexEdgeIdentifier>) -> bool {
false
}
fn quote_exact_out(
&self,
id: &Arc<dyn DexEdgeIdentifier>,
edge: &Arc<dyn DexEdge>,
_chain_data: &AccountProviderView,
out_amount: u64,
) -> anyhow::Result<Quote> {
anyhow::bail!("Not supported");
let edge = edge.as_any().downcast_ref::<InvariantEdge>().unwrap();
let id = id
.as_any()
.downcast_ref::<InvariantEdgeIdentifier>()
.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<Vec<(Pubkey, Pool)>> {
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::<Pool>(account.data.as_slice());
pool.ok().map(|x| (account.pubkey, x))
})
.collect();
Ok(result)
}

284
lib/dex-invariant/src/invariant_edge.rs Normal file
View File

@ -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<Tick>,
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<InvariantSwapResult, String> {
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
}
}

84
lib/dex-invariant/src/invariant_ix_builder.rs Normal file
View File

@ -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<SwapInstruction> {
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<u8> = 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)
}

13
lib/dex-invariant/src/lib.rs Normal file
View File

@ -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");

40
lib/dex-invariant/tests/test_invariant.rs Normal file
View File

@ -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<String, String>) -> 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<String, String>) -> 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(())
}

5
programs/simulator/tests/cases/test_swap_from_dump.rs
View File

@ -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<Result<(), Error>, Error> {
tracing_subscriber::fmt::init();

BIN
programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so vendored Normal file
View File

Binary file not shown.

BIN
programs/simulator/tests/fixtures/iNvTyprs4TX8m6UeUEkeqDFjAL9zRCRWcexK9Sd4WEU.so vendored Normal file
View File

Binary file not shown.