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
70
71
72
73
74
75
76

use crate::cli::DestParams;
use anyhow::{bail, ensure};
use charms_client::{cardano_tx::proxy_script_hash, tx::Chain};
use cml_core::serialization::RawBytesEncoding;
use std::str::FromStr;

pub fn dest(params: DestParams) -> anyhow::Result<()> {
    let has_addr = params.addr.is_some();
    let has_apps = !params.apps.is_empty();
    ensure!(
        has_addr != has_apps,
        "exactly one of --addr or --apps must be provided"
    );
    if has_apps {
        if let Some(Chain::Bitcoin) = params.chain {
            bail!("--apps only works with Cardano");
        };
    }

    let dest_bytes = if let Some(addr) = &params.addr {
        dest_from_addr(addr, params.chain)?
    } else {
        dest_from_apps(&params.apps)?
    };

    println!("{}", hex::encode(dest_bytes));
    Ok(())
}

fn dest_from_addr(addr: &str, chain: Option<Chain>) -> anyhow::Result<Vec<u8>> {
    match chain {
        Some(Chain::Bitcoin) => bitcoin_dest(addr),
        Some(Chain::Cardano) => cardano_dest(addr),
        None => {
            // Auto-detect: try Cardano first (bech32 with addr/addr_test prefix),
            // then Bitcoin
            if let Ok(bytes) = cardano_dest(addr) {
                return Ok(bytes);
            }
            if let Ok(bytes) = bitcoin_dest(addr) {
                return Ok(bytes);
            }
            bail!("could not parse address as Bitcoin or Cardano; try specifying --chain")
        }
    }
}

fn bitcoin_dest(addr: &str) -> anyhow::Result<Vec<u8>> {
    let address = bitcoin::Address::from_str(addr)?;
    Ok(address.assume_checked().script_pubkey().to_bytes())
}

fn cardano_dest(addr: &str) -> anyhow::Result<Vec<u8>> {
    let address = pallas_addresses::Address::from_bech32(addr)
        .map_err(|e| anyhow::anyhow!("invalid Cardano address: {:?}", e))?;
    Ok(address.to_vec())
}

fn dest_from_apps(apps: &[charms_data::App]) -> anyhow::Result<Vec<u8>> {
    ensure!(!apps.is_empty(), "--apps must not be empty");

    let app_refs: Vec<&charms_data::App> = apps.iter().collect();
    let (script_hash, _) = proxy_script_hash(&app_refs);

    let hash_bytes: [u8; 28] = script_hash
        .to_raw_bytes()
        .try_into()
        .expect("script hash must be 28 bytes");
    let pallas_hash = pallas_crypto::hash::Hash::<28>::new(hash_bytes);
    let shelley_addr = pallas_addresses::ShelleyAddress::new(
        pallas_addresses::Network::Mainnet,
        pallas_addresses::ShelleyPaymentPart::Script(pallas_hash),
        pallas_addresses::ShelleyDelegationPart::Null,
    );
    Ok(pallas_addresses::Address::Shelley(shelley_addr).to_vec())
}