kaspa-rpc-core 0.15.0

Kaspa RPC core
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

use crate::{RpcTransactionOutpoint, RpcUtxoEntry};
use serde::{Deserialize, Serialize};
use workflow_serializer::prelude::*;

pub type RpcAddress = kaspa_addresses::Address;

/// Represents a UTXO entry of an address returned by the `GetUtxosByAddresses` RPC.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcUtxosByAddressesEntry {
    pub address: Option<RpcAddress>,
    pub outpoint: RpcTransactionOutpoint,
    pub utxo_entry: RpcUtxoEntry,
}

impl Serializer for RpcUtxosByAddressesEntry {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        store!(u8, &1, writer)?; // version
        store!(Option<RpcAddress>, &self.address, writer)?;
        serialize!(RpcTransactionOutpoint, &self.outpoint, writer)?;
        serialize!(RpcUtxoEntry, &self.utxo_entry, writer)
    }
}

impl Deserializer for RpcUtxosByAddressesEntry {
    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        let _version: u8 = load!(u8, reader)?;
        let address = load!(Option<RpcAddress>, reader)?;
        let outpoint = deserialize!(RpcTransactionOutpoint, reader)?;
        let utxo_entry = deserialize!(RpcUtxoEntry, reader)?;
        Ok(Self { address, outpoint, utxo_entry })
    }
}

/// Represents a balance of an address returned by the `GetBalancesByAddresses` RPC.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RpcBalancesByAddressesEntry {
    pub address: RpcAddress,

    /// Balance of `address` if available
    pub balance: Option<u64>,
}

impl Serializer for RpcBalancesByAddressesEntry {
    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
        store!(u8, &1, writer)?; // version
        store!(RpcAddress, &self.address, writer)?;
        store!(Option<u64>, &self.balance, writer)
    }
}

impl Deserializer for RpcBalancesByAddressesEntry {
    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
        let _version: u8 = load!(u8, reader)?;
        let address = load!(RpcAddress, reader)?;
        let balance = load!(Option<u64>, reader)?;
        Ok(Self { address, balance })
    }
}