Previous work on the builders/etc updates rust but introduced things caused the WASM to no longer compile. This updates the WASM bindings as well. Includes genesis module that wasn't pushed before.
use std::collections::BTreeMap;
use super::{AssetName, ScriptHash};
pub use super::AssetName;
use super::ScriptHash;
pub type Coin = u64;
// this will be added back at a later point:
//pub mod byron;
pub mod network_info;
\ No newline at end of file
use crate::{
byron::ProtocolMagic,
plutus::CostModels
};
use cml_core::Int;
#[derive(Debug, Clone, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkInfo {
network_id: u8,
protocol_magic: ProtocolMagic,
}
impl NetworkInfo {
pub fn new(network_id: u8, protocol_magic: ProtocolMagic) -> Self {
Self {
network_id,
protocol_magic,
}
}
pub fn network_id(&self) -> u8 {
self.network_id
}
pub fn protocol_magic(&self) -> ProtocolMagic {
self.protocol_magic
}
pub fn testnet() -> NetworkInfo {
NetworkInfo {
network_id: 0b0000,
protocol_magic: ProtocolMagic::from(1097911063)
}
}
pub fn mainnet() -> NetworkInfo {
NetworkInfo {
network_id: 0b0001,
protocol_magic: ProtocolMagic::from(764824073)
}
}
}
// TODO: https://github.com/dcSpark/cardano-multiplatform-lib/issues/92
pub fn plutus_alonzo_cost_models() -> CostModels {
let ops: [u64; 166] = [197209, 0, 1, 1, 396231, 621, 0, 1, 150000, 1000, 0, 1, 150000, 32, 2477736, 29175, 4, 29773, 100, 29773, 100, 29773, 100, 29773, 100, 29773, 100, 29773, 100, 100, 100, 29773, 100, 150000, 32, 150000, 32, 150000, 32, 150000, 1000, 0, 1, 150000, 32, 150000, 1000, 0, 8, 148000, 425507, 118, 0, 1, 1, 150000, 1000, 0, 8, 150000, 112536, 247, 1, 150000, 10000, 1, 136542, 1326, 1, 1000, 150000, 1000, 1, 150000, 32, 150000, 32, 150000, 32, 1, 1, 150000, 1, 150000, 4, 103599, 248, 1, 103599, 248, 1, 145276, 1366, 1, 179690, 497, 1, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 148000, 425507, 118, 0, 1, 1, 61516, 11218, 0, 1, 150000, 32, 148000, 425507, 118, 0, 1, 1, 148000, 425507, 118, 0, 1, 1, 2477736, 29175, 4, 0, 82363, 4, 150000, 5000, 0, 1, 150000, 32, 197209, 0, 1, 1, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 150000, 32, 3345831, 1, 1];
let mut res = CostModels::new();
res.plutus_v1 = Some(ops.iter().map(|&i| Int::from(i)).collect());
res
}
pub type GenesisHashList = Vec<GenesisHash>;
pub type NetworkId = u8;
pub type NetworkId = u32;// TODO: u8? or custom struct? (u8 can't be exposed to wasm)
pub type PolicyId = ScriptHash;
}
let (tmp_network_id, tmp_network_id_encoding) = (|| -> Result<_, DeserializeError> {
read_len.read_elems(1)?;
raw.unsigned_integer_sz().map(|(x, enc)| (x as u8, Some(enc))).map_err(Into::<DeserializeError>::into)
raw.unsigned_integer_sz().map(|(x, enc)| (x as u32, Some(enc))).map_err(Into::<DeserializeError>::into)
})().map_err(|e| e.annotate("network_id"))?;
network_id = Some(tmp_network_id);
network_id_encoding = tmp_network_id_encoding;
clippy::new_without_default
)]
use wasm_bindgen::prelude::{wasm_bindgen, JsError, JsValue};
use ::wasm_bindgen::prelude::{wasm_bindgen, JsError, JsValue};
use cml_core::error::DeserializeError;
pub use cml_core_wasm::Int;
pub mod address;
pub mod assets;
pub mod auxdata;
pub mod block;
pub mod byron;
pub mod builders;
pub mod certs;
pub mod crypto;
pub mod fees;
pub mod plutus;
pub mod transaction;
pub mod utils;
use address::RewardAccount;
use assets::{AssetName};//, MutliAsset};
use auxdata::{AuxiliaryData, TransactionMetadatum};
use block::ProtocolVersion;
use certs::{Certificate, Relay, StakeCredential};
use transaction::{
NativeScript, TransactionBody, TransactionInput, TransactionOutput, TransactionWitnessSet,
};
pub mod utils;
use cml_chain::NetworkId;
//extern crate serde_wasm_bindgen;
// Code below here was code-generated using an experimental CDDL to rust tool:
// https://github.com/dcSpark/cddl-codegen
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct AssetName(cml_chain::AssetName);
#[wasm_bindgen]
impl AssetName {
pub fn to_cbor_bytes(&self) -> Vec<u8> {
cml_chain::serialization::Serialize::to_cbor_bytes(&self.0)
}
pub fn from_cbor_bytes(cbor_bytes: &[u8]) -> Result<AssetName, JsValue> {
cml_chain::serialization::Deserialize::from_cbor_bytes(cbor_bytes)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_bytes: {}", e)))
}
pub fn to_json(&self) -> Result<String, JsValue> {
serde_json::to_string_pretty(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_json: {}", e)))
}
pub fn to_json_value(&self) -> Result<JsValue, JsValue> {
serde_wasm_bindgen::to_value(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_js_value: {}", e)))
}
pub fn from_json(json: &str) -> Result<AssetName, JsValue> {
serde_json::from_str(json)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_json: {}", e)))
}
pub fn get(&self) -> Vec<u8> {
self.0.get().clone()
}
}
impl From<cml_chain::AssetName> for AssetName {
fn from(native: cml_chain::AssetName) -> Self {
Self(native)
}
}
impl From<AssetName> for cml_chain::AssetName {
fn from(wasm: AssetName) -> Self {
wasm.0
}
}
impl AsRef<cml_chain::AssetName> for AssetName {
fn as_ref(&self) -> &cml_chain::AssetName {
&self.0
}
}
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct AssetNameList(Vec<cml_chain::AssetName>);
pub struct AssetNameList(Vec<cml_chain::assets::AssetName>);
#[wasm_bindgen]
impl AssetNameList {
}
}
impl From<Vec<cml_chain::AssetName>> for AssetNameList {
fn from(native: Vec<cml_chain::AssetName>) -> Self {
impl From<Vec<cml_chain::assets::AssetName>> for AssetNameList {
fn from(native: Vec<cml_chain::assets::AssetName>) -> Self {
Self(native)
}
}
impl From<AssetNameList> for Vec<cml_chain::AssetName> {
impl From<AssetNameList> for Vec<cml_chain::assets::AssetName> {
fn from(wasm: AssetNameList) -> Self {
wasm.0
}
}
impl AsRef<Vec<cml_chain::AssetName>> for AssetNameList {
fn as_ref(&self) -> &Vec<cml_chain::AssetName> {
impl AsRef<Vec<cml_chain::assets::AssetName>> for AssetNameList {
fn as_ref(&self) -> &Vec<cml_chain::assets::AssetName> {
&self.0
}
}
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct MapAssetNameToI64(OrderedHashMap<cml_chain::AssetName, i64>);
pub struct MapAssetNameToI64(OrderedHashMap<cml_chain::assets::AssetName, i64>);
#[wasm_bindgen]
impl MapAssetNameToI64 {
}
}
impl From<OrderedHashMap<cml_chain::AssetName, i64>> for MapAssetNameToI64 {
fn from(native: OrderedHashMap<cml_chain::AssetName, i64>) -> Self {
impl From<OrderedHashMap<cml_chain::assets::AssetName, i64>> for MapAssetNameToI64 {
fn from(native: OrderedHashMap<cml_chain::assets::AssetName, i64>) -> Self {
Self(native)
}
}
impl From<MapAssetNameToI64> for OrderedHashMap<cml_chain::AssetName, i64> {
impl From<MapAssetNameToI64> for OrderedHashMap<cml_chain::assets::AssetName, i64> {
fn from(wasm: MapAssetNameToI64) -> Self {
wasm.0
}
}
impl AsRef<OrderedHashMap<cml_chain::AssetName, i64>> for MapAssetNameToI64 {
fn as_ref(&self) -> &OrderedHashMap<cml_chain::AssetName, i64> {
&self.0
}
}
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct MapAssetNameToU64(OrderedHashMap<cml_chain::AssetName, u64>);
#[wasm_bindgen]
impl MapAssetNameToU64 {
pub fn new() -> Self {
Self(OrderedHashMap::new())
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn insert(&mut self, key: &AssetName, value: u64) -> Option<u64> {
self.0.insert(key.clone().into(), value)
}
pub fn get(&self, key: &AssetName) -> Option<u64> {
self.0.get(key.as_ref()).copied()
}
pub fn keys(&self) -> AssetNameList {
AssetNameList(self.0.iter().map(|(k, _v)| k.clone()).collect::<Vec<_>>())
}
}
impl From<OrderedHashMap<cml_chain::AssetName, u64>> for MapAssetNameToU64 {
fn from(native: OrderedHashMap<cml_chain::AssetName, u64>) -> Self {
Self(native)
}
}
impl From<MapAssetNameToU64> for OrderedHashMap<cml_chain::AssetName, u64> {
fn from(wasm: MapAssetNameToU64) -> Self {
wasm.0
}
}
pub mod utils;
// This file was code-generated using an experimental CDDL to rust tool:
// https://github.com/dcSpark/cddl-codegen
use super::{IntList, MapPlutusDataToPlutusData, PlutusDataList, SubCoin};
use crate::utils::BigInt;
use super::{IntList, MapPlutusDataToPlutusData, PlutusDataList, SubCoin};
pub use cml_chain::plutus::{Language, RedeemerTag};
pub use utils::ConstrPlutusData;
use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct ConstrPlutusData(cml_chain::plutus::ConstrPlutusData);
#[wasm_bindgen]
impl ConstrPlutusData {
pub fn to_cbor_bytes(&self) -> Vec<u8> {
cml_chain::serialization::Serialize::to_cbor_bytes(&self.0)
}
pub fn from_cbor_bytes(cbor_bytes: &[u8]) -> Result<ConstrPlutusData, JsValue> {
cml_chain::serialization::Deserialize::from_cbor_bytes(cbor_bytes)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_bytes: {}", e)))
}
pub fn to_json(&self) -> Result<String, JsValue> {
serde_json::to_string_pretty(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_json: {}", e)))
}
pub fn to_json_value(&self) -> Result<JsValue, JsValue> {
serde_wasm_bindgen::to_value(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_js_value: {}", e)))
}
pub fn from_json(json: &str) -> Result<ConstrPlutusData, JsValue> {
serde_json::from_str(json)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_json: {}", e)))
}
pub fn alternative(&self) -> u64 {
self.0.alternative
}
pub fn fields(&self) -> PlutusDataList {
self.0.fields.clone().into()
}
pub fn new(alternative: u64, fields: &PlutusDataList) -> Self {
Self(cml_chain::plutus::ConstrPlutusData::new(
alternative,
fields.clone().into(),
))
}
}
impl From<cml_chain::plutus::ConstrPlutusData> for ConstrPlutusData {
fn from(native: cml_chain::plutus::ConstrPlutusData) -> Self {
Self(native)
}
}
impl From<ConstrPlutusData> for cml_chain::plutus::ConstrPlutusData {
fn from(wasm: ConstrPlutusData) -> Self {
wasm.0
}
}
impl AsRef<cml_chain::plutus::ConstrPlutusData> for ConstrPlutusData {
fn as_ref(&self) -> &cml_chain::plutus::ConstrPlutusData {
&self.0
}
}
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct CostModels(cml_chain::plutus::CostModels);
cml_chain::plutus::PlutusData::Map { .. } => PlutusDataKind::Map,
cml_chain::plutus::PlutusData::List { .. } => PlutusDataKind::List,
cml_chain::plutus::PlutusData::BigInt(_) => PlutusDataKind::BigInt,
cml_chain::plutus::PlutusData::Bytes{ .. } => PlutusDataKind::Bytes,
cml_chain::plutus::PlutusData::Bytes { .. } => PlutusDataKind::Bytes,
}
}
pub fn as_bytes(&self) -> Option<Vec<u8>> {
match &self.0 {
cml_chain::plutus::PlutusData::Bytes{ bytes, .. } => Some(bytes.clone().into()),
cml_chain::plutus::PlutusData::Bytes { bytes, .. } => Some(bytes.clone()),
_ => None,
}
}
// https://github.com/dcSpark/cddl-codegen
use super::{
BootstrapWitnessList, CertificateList, Coin, Mint, NativeScriptList, NetworkId, PlutusDataList,
PlutusV1ScriptList, PlutusV2ScriptList, RedeemerList, Script, Slot, TransactionInputList,
TransactionOutputList, Update, Value, VkeywitnessList, Withdrawals,
Value, BootstrapWitnessList, CertificateList, NativeScriptList, NetworkId, PlutusDataList,
PlutusV1ScriptList, PlutusV2ScriptList, RedeemerList, Slot, TransactionInputList,
TransactionOutputList, Update, VkeywitnessList, Withdrawals,
};
use crate::Script;
use crate::address::Address;
use crate::assets::{Coin, Mint};
use crate::auxdata::AuxiliaryData;
use crate::plutus::PlutusData;
use cml_core::ordered_hash_map::OrderedHashMap;
use cml_crypto_wasm::{
AuxiliaryDataHash, DatumHash, Ed25519KeyHash, ScriptDataHash, TransactionHash,
};
use crate::plutus::PlutusData;
use wasm_bindgen::prelude::{wasm_bindgen, JsValue};
pub mod utils;
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct AlonzoTxOut(cml_chain::transaction::AlonzoTxOut);
self.0.address.clone().into()
}
pub fn value(&self) -> Value {
self.0.value.clone().into()
pub fn amount(&self) -> Value {
self.0.amount.clone().into()
}
pub fn set_datum_option(&mut self, datum_option: &DatumOption) {
.map(std::convert::Into::into)
}
pub fn new(address: &Address, value: &Value) -> Self {
pub fn new(address: &Address, amount: &Value) -> Self {
Self(cml_chain::transaction::BabbageTxOut::new(
address.clone().into(),
value.clone().into(),
amount.clone().into(),
))
}
}
#[derive(Clone, Debug)]
#[wasm_bindgen]
pub struct RequiredSigners(cml_chain::transaction::RequiredSigners);
pub struct RequiredSigners(Vec<cml_chain::crypto::Ed25519KeyHash>);
#[wasm_bindgen]
impl RequiredSigners {
pub fn to_cbor_bytes(&self) -> Vec<u8> {
cml_chain::serialization::Serialize::to_cbor_bytes(&self.0)
}
pub fn from_cbor_bytes(cbor_bytes: &[u8]) -> Result<RequiredSigners, JsValue> {
cml_chain::serialization::Deserialize::from_cbor_bytes(cbor_bytes)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_bytes: {}", e)))
}
pub fn to_json(&self) -> Result<String, JsValue> {
serde_json::to_string_pretty(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_json: {}", e)))
}
pub fn to_json_value(&self) -> Result<JsValue, JsValue> {
serde_wasm_bindgen::to_value(&self.0)
.map_err(|e| JsValue::from_str(&format!("to_js_value: {}", e)))
pub fn new() -> Self {
Self(Vec::new())
}
pub fn from_json(json: &str) -> Result<RequiredSigners, JsValue> {
serde_json::from_str(json)
.map(Self)
.map_err(|e| JsValue::from_str(&format!("from_json: {}", e)))
pub fn len(&self) -> usize {
self.0.len()
}
pub fn ed25519_key_hash(&self) -> Ed25519KeyHash {
self.0.ed25519_key_hash.clone().into()
pub fn get(&self, index: usize) -> Ed25519KeyHash {
self.0[index].clone().into()
}
pub fn new(ed25519_key_hash: &Ed25519KeyHash) -> Self {
Self(cml_chain::transaction::RequiredSigners::new(
ed25519_key_hash.clone().into(),
))
pub fn add(&mut self, elem: &Ed25519KeyHash) {
self.0.push(elem.clone().into());
}
}
impl From<cml_chain::transaction::RequiredSigners> for RequiredSigners {
fn from(native: cml_chain::transaction::RequiredSigners) -> Self {
impl From<Vec<cml_chain::crypto::Ed25519KeyHash>> for RequiredSigners {
fn from(native: Vec<cml_chain::crypto::Ed25519KeyHash>) -> Self {
Self(native)
}
}
impl From<RequiredSigners> for cml_chain::transaction::RequiredSigners {
impl From<RequiredSigners> for Vec<cml_chain::crypto::Ed25519KeyHash> {
fn from(wasm: RequiredSigners) -> Self {
wasm.0
}
}
impl AsRef<cml_chain::transaction::RequiredSigners> for RequiredSigners {
fn as_ref(&self) -> &cml_chain::transaction::RequiredSigners {
impl AsRef<Vec<cml_chain::crypto::Ed25519KeyHash>> for RequiredSigners {
fn as_ref(&self) -> &Vec<cml_chain::crypto::Ed25519KeyHash> {
&self.0
}
}
//impl_hash_type!(KESSignature, 448);
impl_hash_type!(NonceHash, 32);
#[derive(Clone)]
pub struct LegacyDaedalusPrivateKey(chain_crypto::SecretKey<chain_crypto::LegacyDaedalus>);
impl LegacyDaedalusPrivateKey {
crate-type = ["cdylib", "rlib"]
[dependencies]
#core = { path = "../chain", package = "cml-chain" }
core_crypto = { path = "../rust", package = "cml-crypto" }
cml-crypto = { path = "../rust" }
cbor_event = "2.2.0"
wasm-bindgen = { version = "=0.2.83", features = ["serde-serialize"] }
linked-hash-map = "0.5.3"
use wasm_bindgen::prelude::{wasm_bindgen, JsError};
use core_crypto::RawBytesEncoding;
use cml_crypto::RawBytesEncoding;
#[wasm_bindgen]
pub struct Bip32PrivateKey(core_crypto::Bip32PrivateKey);
pub struct Bip32PrivateKey(cml_crypto::Bip32PrivateKey);
#[wasm_bindgen]
impl Bip32PrivateKey {
/// so be careful if you see the term "xprv" as it could refer to either one
/// our library does not require the pub (instead we compute the pub key when needed)
pub fn from_128_xprv(bytes: &[u8]) -> Result<Bip32PrivateKey, JsError> {
core_crypto::Bip32PrivateKey::from_128_xprv(bytes)
cml_crypto::Bip32PrivateKey::from_128_xprv(bytes)
.map(Self)
.map_err(Into::into)
}
}
pub fn generate_ed25519_bip32() -> Bip32PrivateKey {
Self(core_crypto::Bip32PrivateKey::generate_ed25519_bip32())
Self(cml_crypto::Bip32PrivateKey::generate_ed25519_bip32())
}
pub fn to_raw_key(&self) -> PrivateKey {
}
pub fn from_raw_bytes(bytes: &[u8]) -> Result<Bip32PrivateKey, JsError> {
core_crypto::Bip32PrivateKey::from_raw_bytes(bytes)
cml_crypto::Bip32PrivateKey::from_raw_bytes(bytes)
.map(Self)
.map_err(Into::into)
}
}
pub fn from_bech32(bech32_str: &str) -> Result<Bip32PrivateKey, JsError> {
core_crypto::Bip32PrivateKey::from_bech32(bech32_str)
cml_crypto::Bip32PrivateKey::from_bech32(bech32_str)
.map(Self)
.map_err(Into::into)
}
}
pub fn from_bip39_entropy(entropy: &[u8], password: &[u8]) -> Self {
Self(core_crypto::Bip32PrivateKey::from_bip39_entropy(
Self(cml_crypto::Bip32PrivateKey::from_bip39_entropy(
entropy, password,
))
}
}
}
impl From<core_crypto::Bip32PrivateKey> for Bip32PrivateKey {
fn from(inner: core_crypto::Bip32PrivateKey) -> Self {
impl From<cml_crypto::Bip32PrivateKey> for Bip32PrivateKey {
fn from(inner: cml_crypto::Bip32PrivateKey) -> Self {
Self(inner)
}
}
impl From<Bip32PrivateKey> for core_crypto::Bip32PrivateKey {
impl From<Bip32PrivateKey> for cml_crypto::Bip32PrivateKey {
fn from(wrapper: Bip32PrivateKey) -> Self {
wrapper.0
}
}
impl AsRef<core_crypto::Bip32PrivateKey> for Bip32PrivateKey {
fn as_ref(&self) -> &core_crypto::Bip32PrivateKey {
impl AsRef<cml_crypto::Bip32PrivateKey> for Bip32PrivateKey {
fn as_ref(&self) -> &cml_crypto::Bip32PrivateKey {
&self.0
}
}
#[wasm_bindgen]
pub struct Bip32PublicKey(core_crypto::Bip32PublicKey);
#[derive(Clone)]
pub struct Bip32PublicKey(cml_crypto::Bip32PublicKey);
#[wasm_bindgen]
impl Bip32PublicKey {
}
pub fn from_raw_bytes(bytes: &[u8]) -> Result<Bip32PublicKey, JsError> {
core_crypto::Bip32PublicKey::from_raw_bytes(bytes)
cml_crypto::Bip32PublicKey::from_raw_bytes(bytes)
.map(Self)
.map_err(Into::into)
}
}
pub fn from_bech32(bech32_str: &str) -> Result<Bip32PublicKey, JsError> {
core_crypto::Bip32PublicKey::from_bech32(bech32_str)
cml_crypto::Bip32PublicKey::from_bech32(bech32_str)
.map(Self)
.map_err(Into::into)
}
}
}
impl From<core_crypto::Bip32PublicKey> for Bip32PublicKey {
fn from(inner: core_crypto::Bip32PublicKey) -> Self {
impl From<cml_crypto::Bip32PublicKey> for Bip32PublicKey {
fn from(inner: cml_crypto::Bip32PublicKey) -> Self {
Self(inner)
}
}
impl From<Bip32PublicKey> for core_crypto::Bip32PublicKey {
impl From<Bip32PublicKey> for cml_crypto::Bip32PublicKey {
fn from(wrapper: Bip32PublicKey) -> Self {
wrapper.0
}
}
impl AsRef<core_crypto::Bip32PublicKey> for Bip32PublicKey {
fn as_ref(&self) -> &core_crypto::Bip32PublicKey {
impl AsRef<cml_crypto::Bip32PublicKey> for Bip32PublicKey {
fn as_ref(&self) -> &cml_crypto::Bip32PublicKey {
&self.0
}
}
#[wasm_bindgen]
pub struct PrivateKey(core_crypto::PrivateKey);
pub struct PrivateKey(cml_crypto::PrivateKey);
#[wasm_bindgen]
impl PrivateKey {
}
pub fn generate_ed25519() -> Self {
Self(core_crypto::PrivateKey::generate_ed25519())
Self(cml_crypto::PrivateKey::generate_ed25519())
}
pub fn generate_ed25519extended() -> Self {
Self(core_crypto::PrivateKey::generate_ed25519extended())
Self(cml_crypto::PrivateKey::generate_ed25519extended())
}
/// Get private key from its bech32 representation
/// PrivateKey.from_bech32('ed25519e_sk1gqwl4szuwwh6d0yk3nsqcc6xxc3fpvjlevgwvt60df59v8zd8f8prazt8ln3lmz096ux3xvhhvm3ca9wj2yctdh3pnw0szrma07rt5gl748fp');
/// ```
pub fn from_bech32(bech32_str: &str) -> Result<PrivateKey, JsError> {
core_crypto::PrivateKey::from_bech32(bech32_str)
cml_crypto::PrivateKey::from_bech32(bech32_str)
.map(Self)
.map_err(Into::into)
}
}
pub fn from_extended_bytes(bytes: &[u8]) -> Result<PrivateKey, JsError> {
core_crypto::PrivateKey::from_extended_bytes(bytes)
cml_crypto::PrivateKey::from_extended_bytes(bytes)
.map(Self)
.map_err(Into::into)
}
pub fn from_normal_bytes(bytes: &[u8]) -> Result<PrivateKey, JsError> {
core_crypto::PrivateKey::from_normal_bytes(bytes)
cml_crypto::PrivateKey::from_normal_bytes(bytes)
.map(Self)
.map_err(Into::into)
}
}
}
impl From<core_crypto::PrivateKey> for PrivateKey {
fn from(inner: core_crypto::PrivateKey) -> Self {
impl From<cml_crypto::PrivateKey> for PrivateKey {
fn from(inner: cml_crypto::PrivateKey) -> Self {
Self(inner)
}
}
impl From<PrivateKey> for core_crypto::PrivateKey {
impl From<PrivateKey> for cml_crypto::PrivateKey {
fn from(wrapper: PrivateKey) -> Self {
wrapper.0
}
}
asset_name = bytes .size (0..32)
multiasset = { * policy_id => { * asset_name => uint } }
; these two are technically hand-written but we keep them here so that other code can
; continue thinking they're maps and handle them like so (encoding details, etc)
; they will just invoke the Deref trait on the hand-written object anyway.
; So the hand-written part is more of a wrapper over the type defined below
; NOTE: this means that after generation you must unfortunately manually remove Mint
; MultiAsset doesn't need removing since it's only referenced by Value which is also
; externally defined.
; multi_asset = { * policy_id => { * asset_name => uint } }
mint = { * policy_id => { * asset_name => int64 } }
int64 = -9223372036854775808 .. 9223372036854775807 ; @no_alias
; but this produces numbers outside the unit interval
; and can also produce a zero in the denominator
positive_interval = #6.30([strart: uint, end: uint])
;positive_interval = #6.30([strart: uint, end: uint])
;positive_interval = #6.30([1, 2])
; ; fractional positive_interval is: #6.30([uint, uint])
; ; but this can produce a zero in the denominator
? 24: uint, ; @name max_collateral_inputs
}
sub_coin = positive_interval
sub_coin = rational
policy_id = script_hash
So far only `x86_64-linux` works, I’ll fix an `aarch64-linux` version shortly fix(ogmios): clone cardano-configurations directly
Fix record download statistics
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4&s=80)
Bumps [aws-sdk-s3](https://github.com/awslabs/aws-sdk-rust) from 0.28.0 to 0.31.1. - [Release notes](https://github.com/awslabs/aws-sdk-rust/releases) - [Changelog](https://github.com/awslabs/aws-sdk-rust/blob/main/CHANGELOG.md) - [Commits](https://github.com/awslabs/aws-sdk-rust/commits) --- updated-dependencies: - dependency-name: aws-sdk-s3 dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <[email protected]>
So far only `x86_64-linux` works, I’ll fix an `aarch64-linux` version shortly
