fusionamm-client 1.1.1

Rust client to interact with on-chain FusionAMM program.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

//
// Copyright (c) Cryptic Dot
//
// Modification based on Orca Whirlpools (https://github.com/orca-so/whirlpools),
// originally licensed under the Apache License, Version 2.0, prior to February 26, 2025.
//
// Modifications licensed under FusionAMM SDK Source-Available License v1.0
// See the LICENSE file in the project root for license information.
//

use std::error::Error;

use solana_client::nonblocking::rpc_client::RpcClient;
use solana_pubkey::Pubkey;

use crate::{DecodedAccount, TickArray};

use super::{fetch_all_fixed_tick_array_with_filter, FixedTickArrayFilter};
use super::{fetch_all_sparse_tick_array_with_filter, SparseTickArrayFilter};

#[derive(Debug, Clone)]
pub enum TickArrayFilter {
    FusionPool(Pubkey),
    StartTickIndex(i32),
}

impl From<TickArrayFilter> for FixedTickArrayFilter {
    fn from(val: TickArrayFilter) -> Self {
        match val {
            TickArrayFilter::FusionPool(address) => FixedTickArrayFilter::FusionPool(address),
            TickArrayFilter::StartTickIndex(tick_index) => FixedTickArrayFilter::StartTickIndex(tick_index),
        }
    }
}

impl From<TickArrayFilter> for SparseTickArrayFilter {
    fn from(val: TickArrayFilter) -> Self {
        match val {
            TickArrayFilter::FusionPool(address) => SparseTickArrayFilter::FusionPool(address),
            TickArrayFilter::StartTickIndex(tick_index) => SparseTickArrayFilter::StartTickIndex(tick_index),
        }
    }
}

pub async fn fetch_all_tick_array_with_filter(
    rpc: &RpcClient,
    filters: Vec<TickArrayFilter>,
) -> Result<Vec<DecodedAccount<TickArray>>, Box<dyn Error>> {
    let fixed_filters = filters.clone().into_iter().map(|filter| filter.into()).collect();
    let fixed_tick_arrays = fetch_all_fixed_tick_array_with_filter(rpc, fixed_filters).await?;

    let sparse_filters = filters.clone().into_iter().map(|filter| filter.into()).collect();
    let sparse_tick_arrays = fetch_all_sparse_tick_array_with_filter(rpc, sparse_filters).await?;

    let mut tick_arrays: Vec<DecodedAccount<TickArray>> = Vec::new();

    for fixed_tick_array in fixed_tick_arrays {
        tick_arrays.push(DecodedAccount {
            address: fixed_tick_array.address,
            account: fixed_tick_array.account,
            data: TickArray::from(fixed_tick_array.data),
        });
    }

    for sparse_tick_array in sparse_tick_arrays {
        tick_arrays.push(DecodedAccount {
            address: sparse_tick_array.address,
            account: sparse_tick_array.account,
            data: TickArray::from(sparse_tick_array.data),
        });
    }

    Ok(tick_arrays)
}