Merge pull request #1 from invariant-labs/integrate-invariant
Integrate invariant
This commit is contained in:
Michał Smykała
GitHub
commit
05f3ced7ad
|
|
@ -1974,6 +1974,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"
|
||||
|
|
@ -2114,6 +2136,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"
|
||||
|
|
@ -3503,6 +3559,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"
|
||||
|
|
|
|||
|
|
@ -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" }
|
||||
|
|
@ -0,0 +1,116 @@
|
|||
use anchor_lang::prelude::*;
|
||||
use anchor_spl::token::spl_token;
|
||||
use anyhow::Error;
|
||||
use invariant_types::{SEED, STATE_SEED};
|
||||
|
||||
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,
|
||||
account_x: Pubkey,
|
||||
account_y: Pubkey,
|
||||
reserve_x: Pubkey,
|
||||
reserve_y: Pubkey,
|
||||
owner: Pubkey,
|
||||
program_authority: Pubkey,
|
||||
token_program: Pubkey,
|
||||
ticks_accounts: Vec<Pubkey>,
|
||||
referral_fee: Option<Pubkey>,
|
||||
}
|
||||
|
||||
impl InvariantSwapAccounts {
|
||||
pub fn from_pubkeys(
|
||||
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 invariant_swap_accounts = Self {
|
||||
state: Self::get_state_address(crate::ID),
|
||||
pool: pool_pk,
|
||||
tickmap: invariant_edge.pool.tickmap,
|
||||
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_program: spl_token::id(),
|
||||
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.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_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
|
||||
}
|
||||
}
|
||||
|
|
@ -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"
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#[macro_export]
|
||||
macro_rules! size {
|
||||
($name: ident) => {
|
||||
impl $name {
|
||||
pub const LEN: usize = std::mem::size_of::<$name>() + 8;
|
||||
}
|
||||
};
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -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);
|
||||
|
|
@ -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::*;
|
||||
|
|
@ -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);
|
||||
|
|
@ -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);
|
||||
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
pub mod accounts;
|
||||
pub mod swap;
|
||||
pub mod tickmap_slice;
|
||||
|
|
@ -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,0 +1,460 @@
|
|||
use std::{
|
||||
collections::{HashMap, HashSet},
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use anchor_lang::AnchorDeserialize;
|
||||
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, 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 pools = fetch_invariant_accounts(rpc, crate::id()).await?;
|
||||
|
||||
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)
|
||||
}
|
||||
|
|
@ -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 {
|
||||
10 // 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
|
||||
}
|
||||
}
|
||||
|
|
@ -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(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)
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
mod internal;
|
||||
mod invariant_dex;
|
||||
mod invariant_edge;
|
||||
mod invariant_ix_builder;
|
||||
|
||||
pub use invariant_dex::InvariantDex;
|
||||
|
||||
use solana_sdk::declare_id;
|
||||
|
||||
declare_id!("HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt");
|
||||
|
|
@ -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(())
|
||||
}
|
||||
|
|
@ -7,7 +7,8 @@ use base64::Engine;
|
|||
use jsonrpc_core_client::transports::http;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::json;
|
||||
use solana_account_decoder::{UiAccount, UiAccountEncoding};
|
||||
use solana_account_decoder::{UiAccount, UiAccountData, UiAccountEncoding};
|
||||
use solana_client::rpc_response::RpcKeyedAccount;
|
||||
use solana_client::{
|
||||
nonblocking::rpc_client::RpcClient,
|
||||
rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig},
|
||||
|
|
@ -123,6 +124,9 @@ pub async fn get_compressed_program_account(
|
|||
let config = RpcProgramAccountsConfig {
|
||||
filters: None,
|
||||
with_context: Some(true),
|
||||
account_config: RpcAccountInfoConfig {
|
||||
..Default::default()
|
||||
},
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
|
|
@ -130,7 +134,6 @@ pub async fn get_compressed_program_account(
|
|||
}
|
||||
|
||||
// called on startup to get the required accounts, few calls with some 100 thousand accounts
|
||||
#[tracing::instrument(skip_all, level = "trace")]
|
||||
pub async fn get_compressed_program_account_rpc(
|
||||
rpc_client: &RpcClient,
|
||||
filters: &HashSet<Pubkey>,
|
||||
|
|
@ -138,6 +141,10 @@ pub async fn get_compressed_program_account_rpc(
|
|||
) -> anyhow::Result<(u64, Vec<AccountWrite>)> {
|
||||
let config = RpcProgramAccountsConfig {
|
||||
with_context: Some(true),
|
||||
account_config: RpcAccountInfoConfig{
|
||||
encoding: Some(UiAccountEncoding::Base64),
|
||||
..Default::default()
|
||||
},
|
||||
..config
|
||||
};
|
||||
|
||||
|
|
@ -149,14 +156,11 @@ pub async fn get_compressed_program_account_rpc(
|
|||
info!("gPA for {}", program_id);
|
||||
|
||||
let result = rpc_client
|
||||
.send::<OptionalContext<Vec<RpcKeyedCompressedAccount>>>(
|
||||
solana_client::rpc_request::RpcRequest::Custom {
|
||||
method: "getProgramAccountsCompressed",
|
||||
},
|
||||
json!([program_id.to_string(), config]),
|
||||
)
|
||||
.await;
|
||||
|
||||
.send::<OptionalContext<Vec<RpcKeyedAccount>>>(
|
||||
solana_client::rpc_request::RpcRequest::GetProgramAccounts ,
|
||||
json!([program_id.to_string(), config]),
|
||||
)
|
||||
.await;
|
||||
// failed to get over compressed program accounts
|
||||
match result {
|
||||
Ok(OptionalContext::Context(response)) => {
|
||||
|
|
@ -165,13 +169,19 @@ pub async fn get_compressed_program_account_rpc(
|
|||
min_slot = updated_slot.min(min_slot);
|
||||
|
||||
for key_account in response.value {
|
||||
let base64_decoded =
|
||||
base64::engine::general_purpose::STANDARD.decode(&key_account.a)?;
|
||||
let account_data = if let UiAccountData::Binary(data, encoding) = &key_account.account.data {
|
||||
if let UiAccountEncoding::Base64 = encoding {
|
||||
data
|
||||
} else {
|
||||
panic!("wrong encoding")
|
||||
}
|
||||
} else {
|
||||
panic!("wrong data type")
|
||||
};
|
||||
base64::engine::general_purpose::STANDARD.decode(&account_data)?;
|
||||
// decompress all the account information
|
||||
let uncompressed = lz4::block::decompress(&base64_decoded, None)?;
|
||||
let shared_data = bincode::deserialize::<AccountSharedData>(&uncompressed)?;
|
||||
let pubkey = Pubkey::from_str(&key_account.p).unwrap();
|
||||
let account: Account = shared_data.into();
|
||||
let pubkey = Pubkey::from_str(&key_account.pubkey).unwrap();
|
||||
let account: Account = key_account.account.decode().unwrap();
|
||||
snap_result.push(account_write_from(
|
||||
pubkey,
|
||||
updated_slot,
|
||||
|
|
@ -180,7 +190,7 @@ pub async fn get_compressed_program_account_rpc(
|
|||
));
|
||||
}
|
||||
|
||||
info!(
|
||||
println!(
|
||||
"Decompressed snapshot for {} with {} accounts",
|
||||
program_id,
|
||||
snap_result.len()
|
||||
|
|
|
|||
|
|
@ -70,6 +70,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> {
|
||||
let mut skip_count = option_env!("SKIP_COUNT")
|
||||
.map(|x| u32::from_str(x).unwrap_or(0))
|
||||
|
|
|
|||
BIN
programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so
vendored
Normal file
BIN
programs/simulator/tests/fixtures/HyaB3W9q6XdA5xwpU4XnSZV94htfmbmqJXZcEbRaJutt.so
vendored
Normal file
Binary file not shown.
Binary file not shown.
Loading…
Reference in New Issue