ic-query 0.10.1

Internet Computer query library for NNS, SNS, ICRC, and related public network metadata
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Module: sns::report::live::fetch::token
//!
//! Responsibility: fetch SNS ledger token metadata.
//! Does not own: lookup resolution, report assembly, amount formatting, or rendering.
//! Boundary: queries one resolved SNS ledger for ICRC metadata and index details.

use super::block_on_sns;
use crate::icrc::ledger::{
    GetIndexPrincipalResult, IcrcLedgerMetadataRow, IcrcLedgerStandardRow, IcrcLedgerTokenMetadata,
    fetch_icrc1_token_metadata, index_principal_error_text, query_ledger,
};
use crate::sns::report::live::query::{principal_from_text, sns_agent};
use crate::sns::report::{
    SnsHostError, SnsTokenMetadataRow, SnsTokenStandardRow,
    source::{MainnetSns, MainnetSnsToken, SnsSourceRequest},
};

/// Fetch token metadata for one resolved mainnet SNS ledger.
pub(in crate::sns::report::live) fn fetch_mainnet_sns_token(
    request: &SnsSourceRequest,
    sns: &MainnetSns,
) -> Result<MainnetSnsToken, SnsHostError> {
    block_on_sns(fetch_mainnet_sns_token_async(request, sns))
}

async fn fetch_mainnet_sns_token_async(
    request: &SnsSourceRequest,
    sns: &MainnetSns,
) -> Result<MainnetSnsToken, SnsHostError> {
    let agent = sns_agent(&request.endpoint)?;
    let ledger_canister = principal_from_text(&sns.ledger_canister_id, "ledger_canister_id")?;
    let token = Box::pin(fetch_icrc1_token_metadata::<SnsHostError>(
        &agent,
        &ledger_canister,
    ))
    .await?;
    let (ledger_index_canister_id, ledger_index_error) = match query_ledger::<
        GetIndexPrincipalResult,
        SnsHostError,
    >(
        &agent,
        &ledger_canister,
        "icrc106_get_index_principal",
    )
    .await
    {
        Ok(GetIndexPrincipalResult::Ok(principal)) => (Some(principal.to_text()), None),
        Ok(GetIndexPrincipalResult::Err(error)) => (None, Some(index_principal_error_text(error))),
        Err(error) => (None, Some(error.to_string())),
    };

    Ok(mainnet_sns_token_from_ledger(
        token,
        ledger_index_canister_id,
        ledger_index_error,
    ))
}

fn mainnet_sns_token_from_ledger(
    token: IcrcLedgerTokenMetadata,
    ledger_index_canister_id: Option<String>,
    ledger_index_error: Option<String>,
) -> MainnetSnsToken {
    MainnetSnsToken {
        token_name: token.token_name,
        token_symbol: token.token_symbol,
        decimals: token.decimals,
        transfer_fee: token.transfer_fee,
        total_supply: token.total_supply,
        minting_account_owner: token.minting_account_owner,
        minting_account_subaccount_hex: token.minting_account_subaccount_hex,
        ledger_index_canister_id,
        ledger_index_error,
        supported_standards: token
            .supported_standards
            .into_iter()
            .map(sns_standard_row_from_ledger)
            .collect(),
        metadata: token
            .metadata
            .into_iter()
            .map(sns_metadata_row_from_ledger)
            .collect(),
    }
}

fn sns_standard_row_from_ledger(row: IcrcLedgerStandardRow) -> SnsTokenStandardRow {
    SnsTokenStandardRow {
        name: row.name,
        url: row.url,
    }
}

fn sns_metadata_row_from_ledger(row: IcrcLedgerMetadataRow) -> SnsTokenMetadataRow {
    SnsTokenMetadataRow {
        key: row.key,
        value_type: row.value_type,
        value: row.value,
    }
}