charms 13.0.0

Programmable assets on Bitcoin and beyond
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

use charms_client::{
    BeamSource, NormalizedSpell,
    tx::{Chain, Tx},
};
use charms_data::{App, B32, Data, UtxoId, util};
use serde::{Deserialize, Serialize};
use serde_with::{DisplayFromStr, IfIsHumanReadable, base64::Base64, serde_as};
use std::collections::BTreeMap;

pub type FeeAddressForNetwork = BTreeMap<String, String>;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct CharmsFee {
    /// Fee addresses for each chain (bitcoin, cardano, etc.) further broken down by network
    /// (mainnet, testnet, etc.).
    pub fee_addresses: BTreeMap<Chain, FeeAddressForNetwork>,
    /// Fee rate in sats per mega cycle.
    pub fee_rate: u64,
    /// Base fee in sats.
    pub fee_base: u64,
}

impl CharmsFee {
    pub fn fee_address(&self, chain: &Chain, network: &str) -> Option<&str> {
        self.fee_addresses.get(chain).and_then(|fee_addresses| {
            fee_addresses
                .get(network)
                .map(|fee_address| fee_address.as_str())
        })
    }
}

serde_with::serde_conv!(
    NormalizedSpellHex,
    NormalizedSpell,
    |data: &NormalizedSpell| hex::encode(util::write(data).expect("failed to write Data")),
    |s: String| util::read(hex::decode(&s)?.as_slice())
);

serde_with::serde_conv!(
    DataHex,
    Data,
    |data: &Data| hex::encode(util::write(data).expect("failed to write Data")),
    |s: String| util::read(hex::decode(&s)?.as_slice())
);

#[serde_as]
#[derive(Debug, Serialize, Deserialize)]
pub struct ProveRequest {
    #[serde_as(as = "IfIsHumanReadable<NormalizedSpellHex>")]
    pub spell: NormalizedSpell,
    #[serde_as(as = "IfIsHumanReadable<BTreeMap<DisplayFromStr, DataHex>>")]
    #[serde(skip_serializing_if = "BTreeMap::is_empty", default)]
    pub app_private_inputs: BTreeMap<App, Data>,
    #[serde_as(as = "IfIsHumanReadable<BTreeMap<DisplayFromStr, _>>")]
    #[serde(skip_serializing_if = "BTreeMap::is_empty", default)]
    pub tx_ins_beamed_source_utxos: BTreeMap<usize, BeamSource>,
    #[serde_as(as = "IfIsHumanReadable<BTreeMap<DisplayFromStr, Base64>>")]
    #[serde(skip_serializing_if = "BTreeMap::is_empty", default)]
    pub binaries: BTreeMap<B32, Vec<u8>>,
    #[serde(skip_serializing_if = "Vec::is_empty", default)]
    pub prev_txs: Vec<Tx>,
    pub change_address: String,
    #[serde(default)]
    pub fee_rate: f64,
    pub chain: Chain,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub collateral_utxo: Option<UtxoId>,
}