ex3-dft-client 0.17.1

Dfinity fungible token standard canister client-rs/client-canister.
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use candid::{CandidType, Deserialize, Nat, Principal};
use ex3_common_error_info::ErrorInfo;
use serde::Serialize;

pub type BlockHeight = Nat;
pub type TokenHolder = AccountIdentifier;
pub type TokenReceiver = AccountIdentifier;
pub type TransactionId = String;
pub type BlockHash = [u8; 32];

/// AccountIdentifier is a 32-byte array.
/// The first 4 bytes is big-endian encoding of a CRC32 checksum of the last 28 bytes.
#[derive(
    CandidType, Serialize, Deserialize, Clone, Copy, Hash, Debug, PartialEq, Eq, PartialOrd, Ord,
)]
pub struct AccountIdentifier {
    hash: [u8; 28],
}

/// Subaccount is an arbitrary 32-byte byte array.
/// Ledger uses subaccounts to compute account pub_key, which enables one
/// principal to control multiple ledger accounts.
#[derive(CandidType, Serialize, Deserialize, Clone, Copy, Hash, Debug, PartialEq, Eq)]
pub struct Subaccount(pub [u8; 32]);

#[derive(CandidType, Deserialize, Debug, Clone)]
pub enum OperationResult {
    Ok {
        #[serde(rename = "txId")]
        tx_id: TransactionId,
        #[serde(rename = "blockHeight")]
        block_height: Nat,
    },
    Err(ErrorInfo),
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub struct ArchivedBlocksRange {
    pub start: Nat,
    pub length: u64,
    #[serde(rename = "storageCanisterId")]
    pub storage_canister_id: Principal,
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub struct QueryBlocksResult {
    #[serde(rename = "chainLength")]
    pub chain_length: Nat,
    pub certificate: Option<serde_bytes::ByteBuf>,
    pub blocks: Vec<Block>,
    #[serde(rename = "firstBlockIndex")]
    pub first_block_index: Nat,
    #[serde(rename = "archivedBlocks")]
    pub archived_blocks: Vec<ArchivedBlocksRange>,
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub enum Operation {
    Approve {
        caller: Principal,
        owner: TokenHolder,
        spender: TokenHolder,
        value: Nat,
        fee: Nat,
    },
    Transfer {
        caller: TokenHolder,
        from: TokenHolder,
        to: TokenReceiver,
        value: Nat,
        fee: Nat,
    },
    FeeModify {
        caller: Principal,
        #[serde(rename = "newFee")]
        new_fee: TokenFee,
    },
    OwnerModify {
        caller: Principal,
        #[serde(rename = "newOwner")]
        new_owner: Principal,
    },
    FeeToModify {
        caller: Principal,
        #[serde(rename = "newFeeTo")]
        new_fee_to: TokenHolder,
    },
    AddMinter {
        caller: Principal,
        minter: Principal,
    },
    RemoveMinter {
        caller: Principal,
        minter: Principal,
    },
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub struct TokenFee {
    pub minimum: Nat,
    pub rate: u32,
    #[serde(rename = "rateDecimals")]
    pub rate_decimals: u8,
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub struct Transaction {
    pub operation: Operation,
    /// The time this transaction was created.
    #[serde(rename = "createdAt")]
    pub created_at: u64,
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub struct Block {
    #[serde(rename = "parentHash")]
    pub parent_hash: BlockHash,
    pub transaction: Transaction,
    pub timestamp: u64,
}

#[derive(CandidType, Deserialize, Debug, Clone)]
pub enum BlockResult {
    // Return tx record if exist in the DFT cache txs
    Ok(Block),
    // If not storage in DFT cache txs, return the storage canister id
    Forward(Principal),
    // Such as out of tx index or tx id not exist
    Err(ErrorInfo),
}