ord 0.27.1

◉ Ordinal wallet and block explorer
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

use super::*;

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SplitfileUnchecked {
  outputs: Vec<OutputUnchecked>,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct OutputUnchecked {
  address: Address<NetworkUnchecked>,
  value: Option<DeserializeFromStr<Amount>>,
  runes: BTreeMap<SpacedRune, Decimal>,
}

pub(crate) struct Splitfile {
  pub(crate) outputs: Vec<Output>,
  pub(crate) rune_info: BTreeMap<Rune, RuneInfo>,
}

pub(crate) struct Output {
  pub(crate) address: Address,
  pub(crate) value: Option<Amount>,
  pub(crate) runes: BTreeMap<Rune, u128>,
}

#[derive(Clone, Copy)]
pub(crate) struct RuneInfo {
  pub(crate) divisibility: u8,
  pub(crate) id: RuneId,
  pub(crate) spaced_rune: SpacedRune,
  pub(crate) symbol: Option<char>,
}

impl Splitfile {
  pub(crate) fn load(path: &Path, wallet: &Wallet) -> Result<Self> {
    let network = wallet.chain().network();

    let unchecked = Self::load_unchecked(path)?;

    let mut rune_info = BTreeMap::<Rune, RuneInfo>::new();

    let mut outputs = Vec::new();

    for output in unchecked.outputs {
      let mut runes = BTreeMap::new();

      for (spaced_rune, decimal) in output.runes {
        let info = if let Some(info) = rune_info.get(&spaced_rune.rune) {
          info
        } else {
          let (id, entry, _parent) = wallet
            .get_rune(spaced_rune.rune)?
            .with_context(|| format!("rune `{}` has not been etched", spaced_rune.rune))?;
          rune_info.insert(
            spaced_rune.rune,
            RuneInfo {
              divisibility: entry.divisibility,
              id,
              spaced_rune: entry.spaced_rune,
              symbol: entry.symbol,
            },
          );
          rune_info.get(&spaced_rune.rune).unwrap()
        };

        let amount = decimal.to_integer(info.divisibility)?;

        runes.insert(spaced_rune.rune, amount);
      }

      outputs.push(Output {
        address: output.address.require_network(network)?,
        value: output.value.map(|DeserializeFromStr(value)| value),
        runes,
      });
    }

    Ok(Self { outputs, rune_info })
  }

  fn load_unchecked(path: &Path) -> Result<SplitfileUnchecked> {
    Ok(serde_yaml::from_reader(File::open(path)?)?)
  }
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn example_split_file_is_valid() {
    Splitfile::load_unchecked("splits.yaml".as_ref()).unwrap();
  }
}