urma-runtime 0.1.1

URMA publication planning, network transports and recovery
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

use urma_core::format::Urma;
pub struct Limits;
impl Limits {
    pub const INPUT_BYTES: usize = 16 * 1024 * 1024;
    pub const RECORDS: usize = Self::INPUT_BYTES / Urma::CHUNK_BYTES;
    pub const CONTAINER_BYTES: usize = 12 + Self::RECORDS * (4 + Urma::PRIVATE_RECORD_BYTES);
    pub const OBJECTS: usize = 64;
}

use crate::error::{Context, Error};
use serde_json::Value;

pub fn confirmations(value: &Value) -> Result<i64, Error> {
    match value.get("confirmations") {
        Some(number) => number.as_i64().context("invalid confirmations"),
        None => Ok(0),
    }
}

#[derive(Clone, Copy)]
pub enum RpcScope<'a> {
    Node,
    Wallet(&'a str),
}
impl<'a> From<Option<&'a str>> for RpcScope<'a> {
    fn from(wallet: Option<&'a str>) -> Self {
        match wallet {
            Some(name) => Self::Wallet(name),
            None => Self::Node,
        }
    }
}
#[derive(Clone, Copy)]
pub enum ScanEnd {
    Tip,
    Height(u64),
}
#[derive(Clone, Copy)]
pub enum RevealSelection {
    All,
    First(usize),
}
impl RevealSelection {
    pub fn count(self, total: usize) -> usize {
        match self {
            Self::All => total,
            Self::First(count) => count.min(total),
        }
    }
}
#[derive(Clone, Copy)]
pub enum TxPresence {
    Missing,
    Observed(i64),
}
impl TxPresence {
    pub fn confirmed(self) -> bool {
        match self {
            Self::Missing => false,
            Self::Observed(count) => count > 0,
        }
    }
}

#[derive(Clone, Copy)]
pub enum MempoolPresence {
    Absent,
    Present,
}
impl From<Option<usize>> for RevealSelection {
    fn from(count: Option<usize>) -> Self {
        match count {
            Some(n) => Self::First(n),
            None => Self::All,
        }
    }
}
pub const MAX_OBJECTS: usize = Limits::OBJECTS;
pub const MAX_DIRECTORY_RECORDS: usize = MAX_OBJECTS * Limits::RECORDS;
pub const LITECOIN_NETWORK: &str = "litecoin-testnet";
pub const LITECOIN_GENESIS: &str = urma_chain::observation::Chain::LITECOIN_TESTNET_GENESIS;
pub const LITECOIN_RPC_PORT: u16 = 19332;
pub const LITECOIN_RETURN_LITOSHIS: u64 = 1_000;
pub const LITECOIN_MAX_FEE_LITOSHIS: u64 = 500_000;
pub const LITECOIN_MAX_SCAN_BLOCKS: u64 = 10_000;
pub const LITECOIN_MAX_SCAN_BYTES: usize = 256 * 1024 * 1024;
pub const LITECOIN_MAX_JOURNAL_BYTES: usize = 4_000_000;
pub const RELAY_MAX_BUDGET_SATS: u64 = 500_000;
pub const SOURCE_MAX_BLOCK_BYTES: usize = 4_000_000;
pub const SOURCE_MAX_JSON_BYTES: usize = 1_000_000;
pub const SOURCE_MAX_UTXOS: usize = 1_000;
pub const SOURCE_MAX_SCAN_BLOCKS: u64 = 10_000;
pub const SOURCE_MAX_SCAN_BYTES: usize = 256 * 1024 * 1024;
pub const BITCOIN_RETURN_SATS: u64 = 1_000;
pub const BITCOIN_MAX_FEE_SATS: u64 = 500_000;
pub const BITCOIN_MAX_FEE_RATE: u64 = 100;

pub const STANDARD_TX_WEIGHT: u64 = 400_000;
pub const PUBLICATION_BUFFER_WEIGHT: u64 = 7_960_000;
pub const PUBLICATION_PENDING_COMMITS: usize = 24;
pub const PUBLICATION_COMMIT_VBYTES: u64 = 90_000;
pub const LITECOIN_DUST_RELAY_FEE: u64 = 30_000;

pub fn publication_return(chain: urma_chain::observation::Chain) -> u64 {
    use urma_chain::observation::Chain;
    match chain {
        Chain::LitecoinTestnet | Chain::LitecoinMainnet => 110 * LITECOIN_DUST_RELAY_FEE / 1000,
        Chain::BitcoinRegtest | Chain::BitcoinTestnet4 => 1000,
    }
}