neptune-rpc-api 0.14.0

Neptune JSON-RPC API contract: the RpcApi trait and its data-transfer model types
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

use neptune_primitives::timestamp::Timestamp;
use neptune_wallet::coin_with_possible_timelock::CoinWithPossibleTimeLock;
use serde::Deserialize;
use serde::Serialize;
use tasm_lib::prelude::Digest;

use crate::model::block::header::RpcBlockHeight;
use crate::model::block::transaction_kernel::RpcAbsoluteIndexSet;
use crate::model::block::transaction_kernel::RpcAdditionRecord;
use crate::model::common::RpcNativeCurrencyAmount;
use crate::model::wallet::transaction::RpcUtxo;

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(any(test, feature = "test-helpers"), derive(PartialEq, Eq))]
pub struct ReceivedTransactionOutput {
    pub aocl_leaf_index: u64,
    pub addition_record: RpcAdditionRecord,
    pub utxo: RpcUtxo,
    pub receiver_preimage: Digest,
    pub sender_randomness: Digest,
    pub confirmed_timestamp: Timestamp,
    pub confirmed_block: Digest,
    pub confirmed_height: RpcBlockHeight,
    pub receiving_address: Option<String>,
    pub canonical: bool,

    /// If transaction was mined in a canonical block, this value shows the
    /// position of the output in the mined block. Always set to `None` if the
    /// block is not canonical.
    pub output_index: Option<u32>,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InitiatedTransactionInput {
    pub utxo: RpcUtxo,
    pub aocl_leaf_index: u64,

    /// The absolute index set of the input to the transaction, if known.
    pub absolute_index_set: Option<RpcAbsoluteIndexSet>,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InitiatedTransactionOutput {
    pub utxo: RpcUtxo,
    pub sender_randomness: Digest,
    pub receiver_digest: Digest,

    /// Enum of "on-chain" or "off-chain"
    pub notification_medium: String,

    /// Did we wallet know the spending key for the UTXO when the transaction
    /// was initiated?
    pub owned: bool,
    pub is_change: bool,
    pub to_address: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InitiatedTransaction {
    pub inputs: Vec<InitiatedTransactionInput>,
    pub outputs: Vec<InitiatedTransactionOutput>,
    pub fee: RpcNativeCurrencyAmount,
    pub timestamp: Timestamp,
    pub tip_when_sent: Digest,
}

#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
pub struct RpcCoinWithPossibleTimeLock {
    pub amount: RpcNativeCurrencyAmount,
    pub confirmed: Timestamp,

    /// The earliest time at which the UTXO can be spent.
    pub release_date: Option<Timestamp>,

    pub aocl_leaf_index: u64,
    pub lock_script_hash: Digest,
    pub num_confirmations: Option<u64>,
}

impl From<CoinWithPossibleTimeLock> for RpcCoinWithPossibleTimeLock {
    fn from(value: CoinWithPossibleTimeLock) -> Self {
        Self {
            amount: value.amount.into(),
            confirmed: value.confirmed,
            release_date: value.release_date,
            aocl_leaf_index: value.aocl_leaf_index,
            lock_script_hash: value.lock_script_hash,
            num_confirmations: value.num_confirmations,
        }
    }
}