WASM code for builders (all) Includes direct 1:1 wrappers for misc builders (#19… - dcspark/cardano-multiplatform-lib@6c4d8bd6 - Cardano Updates

Home / dcSpark / cardano-multiplatform-lib / 6c4d8bd6

View on GitHub

File Changes

m

chain/rust/src/builders/redeemer_builder.rs

+1/-1

impl UntaggedRedeemer {

-

    fn new(data: PlutusData, ex_units: ExUnits) -> Self {

+

    pub fn new(data: PlutusData, ex_units: ExUnits) -> Self {

        Self {

            data,

            ex_units

m

chain/rust/src/builders/tx_builder.rs

+11/-3

use rand::Rng;

use crate::builders::output_builder::TransactionOutputBuilder;

+

// for enums:

+

use wasm_bindgen::prelude::wasm_bindgen;

+

#[derive(Clone, Debug)]

pub struct TransactionUnspentOutput {

    pub input: TransactionInput,

        .map_err(Into::into)

+

#[wasm_bindgen]

pub enum CoinSelectionStrategyCIP2 {

    /// Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.

    LargestFirst,

        self.ttl = Some(ttl)

-

    pub fn set_validity_start_interval(&mut self, validity_start_interval: &Slot) {

-

        self.validity_start_interval = Some(*validity_start_interval)

+

    pub fn set_validity_start_interval(&mut self, validity_start_interval: Slot) {

+

        self.validity_start_interval = Some(validity_start_interval)

    pub fn add_cert(&mut self, result: CertificateBuilderResult) {

+

#[derive(Debug, Clone)]

pub struct TxRedeemerBuilder {

    draft_body: TransactionBody,

    witness_builders: WitnessBuilders,

+

#[derive(Debug, Clone)]

pub struct SignedTxBuilder {

    body: TransactionBody,

    witness_set: TransactionWitnessSetBuilder,

+

+

#[wasm_bindgen]

pub enum ChangeSelectionAlgo {

    Default,

pub fn choose_change_selection_algo(algo: ChangeSelectionAlgo) -> fn(&mut TransactionBuilder, &Address, include_exunits: bool) -> Result<bool, TxBuilderError>  {

    match algo {

-

        Default => {

+

        ChangeSelectionAlgo::Default => {

            add_change_if_needed

a

chain/wasm/src/builders/certificate_builder.rs

+58/-0

+

use crate::*;

+

use crate::builders::witness_builder::{PartialPlutusWitness};

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

+

use super::witness_builder::{NativeScriptWitnessInfo};

+

+

use crate::{

+

    certs::{Certificate},

+

    transaction::RequiredSigners,

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct CertificateBuilderResult(cml_chain::builders::certificate_builder::CertificateBuilderResult);

+

+

impl_wasm_conversions!(cml_chain::builders::certificate_builder::CertificateBuilderResult, CertificateBuilderResult);

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct SingleCertificateBuilder(cml_chain::builders::certificate_builder::SingleCertificateBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::certificate_builder::SingleCertificateBuilder, SingleCertificateBuilder);

+

+

#[wasm_bindgen]

+

impl SingleCertificateBuilder {

+

    pub fn new(cert: &Certificate) -> Self {

+

        cml_chain::builders::certificate_builder::SingleCertificateBuilder::new(cert.clone().into()).into()

+

+

+

    /// note: particularly useful for StakeRegistration which doesn't require witnessing

+

    pub fn skip_witness(&self) -> CertificateBuilderResult {

+

        self.0.clone().skip_witness().into()

+

+

+

    pub fn payment_key(&self) -> Result<CertificateBuilderResult, JsError> {

+

        self.0.clone().payment_key().map(Into::into).map_err(Into::into)

+

+

+

    /** Signer keys don't have to be set. You can leave it empty and then add the required witnesses later */

+

    pub fn native_script(&self, native_script: &NativeScript, witness_info: &NativeScriptWitnessInfo) -> Result<CertificateBuilderResult, JsError> {

+

        self.0.clone().native_script(

+

            native_script.clone().into(),

+

            witness_info.clone().into()

+

+

            .map(Into::into)

+

            .map_err(Into::into)

+

+

+

    pub fn plutus_script(self, partial_witness: &PartialPlutusWitness, required_signers: &RequiredSigners) -> Result<CertificateBuilderResult, JsError> {

+

        self.0.clone().plutus_script(

+

            partial_witness.clone().into(),

+

            required_signers.clone().into()

+

+

            .map(Into::into)

+

            .map_err(Into::into)

+

+

a

chain/wasm/src/builders/input_builder.rs

+51/-0

+

use crate::builders::witness_builder::{

+

    PartialPlutusWitness, NativeScriptWitnessInfo

+

};

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

use crate::{

+

    NativeScript,

+

    transaction::{TransactionInput, TransactionOutput, RequiredSigners},

+

    plutus::PlutusData,

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct InputBuilderResult(cml_chain::builders::input_builder::InputBuilderResult);

+

+

impl_wasm_conversions!(cml_chain::builders::input_builder::InputBuilderResult, InputBuilderResult);

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct SingleInputBuilder(cml_chain::builders::input_builder::SingleInputBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::input_builder::SingleInputBuilder, SingleInputBuilder);

+

+

#[wasm_bindgen]

+

impl SingleInputBuilder {

+

    pub fn new(input: &TransactionInput, utxo_info: &TransactionOutput) -> Self {

+

        cml_chain::builders::input_builder::SingleInputBuilder::new(

+

            input.clone().into(),

+

            utxo_info.clone().into(),

+

        ).into()

+

+

+

    pub fn payment_key(&self) -> Result<InputBuilderResult, JsError> {

+

        self.0.clone().payment_key().map(Into::into).map_err(Into::into)

+

+

+

    pub fn native_script(&self, native_script: &NativeScript, witness_info: &NativeScriptWitnessInfo) -> Result<InputBuilderResult, JsError> {

+

        self.0.clone().native_script(

+

            native_script.clone().into(),

+

            witness_info.clone().into(),

+

        ).map(Into::into).map_err(Into::into)

+

+

+

    pub fn plutus_script(&self, partial_witness: &PartialPlutusWitness, required_signers: &RequiredSigners, datum: &PlutusData) -> Result<InputBuilderResult, JsError> {

+

        self.0.clone().plutus_script(

+

            partial_witness.clone().into(),

+

            required_signers.clone().into(),

+

            datum.clone().into(),

+

        ).map(Into::into).map_err(Into::into)

+

+

a

chain/wasm/src/builders/mint_builder.rs

+50/-0

+

use crate::builders::witness_builder::{

+

    PartialPlutusWitness, NativeScriptWitnessInfo

+

};

+

+

use wasm_bindgen::prelude::{wasm_bindgen};

+

use cml_core_wasm::impl_wasm_conversions;

+

+

use crate::{

+

    AssetName,

+

    MapAssetNameToI64,

+

    NativeScript,

+

    transaction::RequiredSigners,

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct MintBuilderResult(cml_chain::builders::mint_builder::MintBuilderResult);

+

+

impl_wasm_conversions!(cml_chain::builders::mint_builder::MintBuilderResult, MintBuilderResult);

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct SingleMintBuilder(cml_chain::builders::mint_builder::SingleMintBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::mint_builder::SingleMintBuilder, SingleMintBuilder);

+

+

#[wasm_bindgen]

+

impl SingleMintBuilder {

+

    pub fn new(assets: &MapAssetNameToI64) -> Self {

+

        cml_chain::builders::mint_builder::SingleMintBuilder::new(assets.clone().into()).into()

+

+

+

    pub fn new_single_asset(asset: &AssetName, amount: i64) -> Self {

+

        cml_chain::builders::mint_builder::SingleMintBuilder::new_single_asset(asset.clone().into(), amount).into()

+

+

+

    pub fn native_script(self, native_script: &NativeScript, witness_info: &NativeScriptWitnessInfo) -> MintBuilderResult {

+

        self.0.clone().native_script(

+

            native_script.clone().into(),

+

            witness_info.clone().into(),

+

        ).into()

+

+

+

    pub fn plutus_script(self, partial_witness: &PartialPlutusWitness, required_signers: &RequiredSigners) -> MintBuilderResult {

+

        self.0.clone().plutus_script(

+

            partial_witness.clone().into(),

+

            required_signers.clone().into(),

+

        ).into()

+

+

a

chain/wasm/src/builders/mod.rs

+8/-0

+

pub mod certificate_builder;

+

pub mod input_builder;

+

pub mod mint_builder;

+

pub mod output_builder;

+

pub mod redeemer_builder;

+

pub mod tx_builder;

+

pub mod withdrawal_builder;

+

pub mod witness_builder;

\ No newline at end of file

a

chain/wasm/src/builders/output_builder.rs

+93/-0

+

use wasm_bindgen::{prelude::wasm_bindgen, JsError};

+

+

use cml_core_wasm::impl_wasm_conversions;

+

+

use crate::{

+

    address::Address,

+

    transaction::{DatumOption, ScriptRef, TransactionOutput},

+

    plutus::PlutusData,

+

    assets::{MultiAsset, Value, Coin},

+

};

+

+

/// We introduce a builder-pattern format for creating transaction outputs

+

/// This is because:

+

/// 1. Some fields (i.e. data hash) are optional, and we can't easily expose Option<> in WASM

+

/// 2. Some fields like amounts have many ways it could be set (some depending on other field values being known)

+

/// 3. Easier to adapt as the output format gets more complicated in future Cardano releases

+

#[derive(Clone, Debug, Default)]

+

#[wasm_bindgen]

+

pub struct TransactionOutputBuilder(cml_chain::builders::output_builder::TransactionOutputBuilder);

+

+

#[wasm_bindgen]

+

impl TransactionOutputBuilder {

+

    pub fn new() -> Self {

+

        cml_chain::builders::output_builder::TransactionOutputBuilder::new().into()

+

+

+

    pub fn with_address(&self, address: &Address) -> Self {

+

        self.0.clone().with_address(address.clone().into()).into()

+

+

+

    /// A communication datum is one where the data hash is used in the tx output

+

    /// Yet the full datum is included in the witness of the same transaction

+

    pub fn with_communication_data(&self, datum: &PlutusData) -> Self {

+

        self.0.clone().with_communication_data(datum.clone().into()).into()

+

+

    pub fn with_data(&self, datum: &DatumOption) -> Self {

+

        self.0.clone().with_data(datum.clone().into()).into()

+

+

+

    pub fn with_reference_script(&self, script_ref: &ScriptRef) -> Self {

+

        self.0.clone().with_reference_script(script_ref.clone().into()).into()

+

+

+

    pub fn next(&self) -> Result<TransactionOutputAmountBuilder, JsError> {

+

        self.0.clone().next().map(Into::into).map_err(Into::into)

+

+

+

+

impl_wasm_conversions!(cml_chain::builders::output_builder::TransactionOutputBuilder, TransactionOutputBuilder);

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct TransactionOutputAmountBuilder(cml_chain::builders::output_builder::TransactionOutputAmountBuilder);

+

+

#[wasm_bindgen]

+

impl TransactionOutputAmountBuilder {

+

    pub fn with_value(&self, amount: &Value) -> Self {

+

        self.0.clone().with_value::<cml_chain::Value>(amount.clone().into()).into()

+

+

+

    pub fn with_asset_and_min_required_coin(&self, multiasset: &MultiAsset, coins_per_utxo_byte: Coin) -> Result<TransactionOutputAmountBuilder, JsError> {

+

        self.0.clone().with_asset_and_min_required_coin(multiasset.clone().into(), coins_per_utxo_byte)

+

            .map(Into::into)

+

            .map_err(Into::into)

+

+

+

    pub fn build(&self) -> Result<SingleOutputBuilderResult, JsError> {

+

        self.0.clone().build().map(Into::into).map_err(Into::into)

+

+

+

+

impl_wasm_conversions!(cml_chain::builders::output_builder::TransactionOutputAmountBuilder, TransactionOutputAmountBuilder);

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct SingleOutputBuilderResult(cml_chain::builders::output_builder::SingleOutputBuilderResult);

+

+

#[wasm_bindgen]

+

impl SingleOutputBuilderResult {

+

    pub fn new(output: &TransactionOutput) -> SingleOutputBuilderResult {

+

        cml_chain::builders::output_builder::SingleOutputBuilderResult::new(output.clone().into()).into()

+

+

+

    pub fn output(&self) -> TransactionOutput {

+

        self.0.output.clone().into()

+

+

+

    pub fn communication_datum(&self) -> Option<PlutusData> {

+

        self.0.communication_datum.clone().map(Into::into)

+

+

+

+

impl_wasm_conversions!(cml_chain::builders::output_builder::SingleOutputBuilderResult, SingleOutputBuilderResult);

a

chain/wasm/src/builders/redeemer_builder.rs

+87/-0

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

use super::{input_builder::InputBuilderResult, mint_builder::MintBuilderResult, withdrawal_builder::WithdrawalBuilderResult, certificate_builder::CertificateBuilderResult};

+

use crate::{

+

    plutus::{Redeemer, RedeemerTag, PlutusData, ExUnits},

+

    RedeemerList,

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone, Copy, PartialOrd, Ord, Debug, PartialEq, Eq, Hash)]

+

pub struct RedeemerWitnessKey(cml_chain::builders::redeemer_builder::RedeemerWitnessKey);

+

+

impl_wasm_conversions!(cml_chain::builders::redeemer_builder::RedeemerWitnessKey, RedeemerWitnessKey);

+

+

#[wasm_bindgen]

+

impl RedeemerWitnessKey {

+

    pub fn new(tag: RedeemerTag, index: u64) -> Self {

+

        cml_chain::builders::redeemer_builder::RedeemerWitnessKey::new(tag, index).into()

+

+

+

    pub fn from_redeemer(redeemer: &Redeemer) -> Self {

+

        cml_chain::builders::redeemer_builder::RedeemerWitnessKey::from(redeemer.as_ref()).into()

+

+

+

+

/// Redeemer without the tag of index

+

/// This allows builder code to return partial redeemers

+

/// and then later have them placed in the right context

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct UntaggedRedeemer(cml_chain::builders::redeemer_builder::UntaggedRedeemer);

+

+

impl_wasm_conversions!(cml_chain::builders::redeemer_builder::UntaggedRedeemer, UntaggedRedeemer);

+

+

#[wasm_bindgen]

+

impl UntaggedRedeemer {

+

    pub fn new(data: &PlutusData, ex_units: &ExUnits) -> Self {

+

        cml_chain::builders::redeemer_builder::UntaggedRedeemer::new(

+

            data.clone().into(),

+

            ex_units.clone().into(),

+

        ).into()

+

+

+

+

/// In order to calculate the index from the sorted set, "add_*" methods in this builder

+

/// must be called along with the "add_*" methods in transaction builder.

+

#[wasm_bindgen]

+

#[derive(Clone, Default, Debug)]

+

pub struct RedeemerSetBuilder(cml_chain::builders::redeemer_builder::RedeemerSetBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::redeemer_builder::RedeemerSetBuilder, RedeemerSetBuilder);

+

+

#[wasm_bindgen]

+

impl RedeemerSetBuilder {

+

    pub fn new() -> Self {

+

        Self::default()

+

+

+

    pub fn is_empty(&self) -> bool {

+

        self.0.is_empty()

+

+

+

    /// note: will override existing value if called twice with the same key

+

    pub fn update_ex_units(&mut self, key: &RedeemerWitnessKey, ex_units: &ExUnits) {

+

        self.0.update_ex_units(key.clone().into(), ex_units.clone().into());

+

+

+

    pub fn add_spend(&mut self, result: &InputBuilderResult) {

+

        self.0.add_spend(result.as_ref());

+

+

+

    pub fn add_mint(&mut self, result: &MintBuilderResult) {

+

        self.0.add_mint(result.as_ref());

+

+

+

    pub fn add_reward(&mut self, result: &WithdrawalBuilderResult) {

+

        self.0.add_reward(result.as_ref());

+

+

+

    pub fn add_cert(&mut self, result: &CertificateBuilderResult) {

+

        self.0.add_cert(result.as_ref());

+

+

+

    pub fn build(&self, default_to_dummy_exunits: bool) -> Result<RedeemerList, JsError> {

+

        self.0.build(default_to_dummy_exunits).map(Into::into).map_err(Into::into)

+

+

a

chain/wasm/src/builders/tx_builder.rs

+415/-0

+

use cml_chain::builders::tx_builder::{CoinSelectionStrategyCIP2, ChangeSelectionAlgo};

+

use cml_crypto_wasm::Ed25519KeyHash;

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

+

use crate::{

+

    NetworkId,

+

    fees::LinearFee,

+

    transaction::{TransactionBody, Transaction, TransactionOutput, TransactionInput},

+

    auxdata::AuxiliaryData,

+

    builders::{witness_builder::TransactionWitnessSetBuilder, mint_builder::MintBuilderResult, withdrawal_builder::WithdrawalBuilderResult, certificate_builder::CertificateBuilderResult, output_builder::SingleOutputBuilderResult, input_builder::InputBuilderResult, redeemer_builder::RedeemerWitnessKey},

+

    crypto::{BootstrapWitness, Vkeywitness}, Coin, plutus::{ExUnitPrices, CostModels, ExUnits}, Value, assets::Mint, Withdrawals, Slot, address::Address, RedeemerList

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct TransactionUnspentOutput(cml_chain::builders::tx_builder::TransactionUnspentOutput);

+

+

impl_wasm_conversions!(cml_chain::builders::tx_builder::TransactionUnspentOutput, TransactionUnspentOutput);

+

+

#[wasm_bindgen]

+

impl TransactionUnspentOutput {

+

    pub fn new(input: &TransactionInput, output: &TransactionOutput) -> Self {

+

        cml_chain::builders::tx_builder::TransactionUnspentOutput::new(

+

            input.clone().into(),

+

            output.clone().into(),

+

        ).into()

+

+

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct TransactionBuilderConfig(cml_chain::builders::tx_builder::TransactionBuilderConfig);

+

+

impl_wasm_conversions!(cml_chain::builders::tx_builder::TransactionBuilderConfig, TransactionBuilderConfig);

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug, Default)]

+

pub struct TransactionBuilderConfigBuilder(cml_chain::builders::tx_builder::TransactionBuilderConfigBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::tx_builder::TransactionBuilderConfigBuilder, TransactionBuilderConfigBuilder);

+

+

#[wasm_bindgen]

+

impl TransactionBuilderConfigBuilder {

+

    pub fn new() -> Self {

+

        // we have to provide new to expose it to WASM builds

+

        Self::default()

+

+

+

    pub fn fee_algo(&self, fee_algo: &LinearFee) -> Self {

+

        self.0.clone().fee_algo(fee_algo.clone().into()).into()

+

+

+

    pub fn coins_per_utxo_byte(&self, coins_per_utxo_byte: Coin) -> Self {

+

        self.0.clone().coins_per_utxo_byte(coins_per_utxo_byte).into()

+

+

+

    pub fn pool_deposit(&self, pool_deposit: u64) -> Self {

+

        self.0.clone().pool_deposit(pool_deposit).into()

+

+

+

    pub fn key_deposit(&self, key_deposit: u64) -> Self {

+

        self.0.clone().key_deposit(key_deposit).into()

+

+

+

    pub fn max_value_size(&self, max_value_size: u32) -> Self {

+

        self.0.clone().max_value_size(max_value_size).into()

+

+

+

    pub fn max_tx_size(&self, max_tx_size: u32) -> Self {

+

        self.0.clone().max_tx_size(max_tx_size).into()

+

+

+

    pub fn prefer_pure_change(&self, prefer_pure_change: bool) -> Self {

+

        self.0.clone().prefer_pure_change(prefer_pure_change).into()

+

+

+

    pub fn ex_unit_prices(&self, ex_unit_prices: &ExUnitPrices) -> Self {

+

        self.0.clone().ex_unit_prices(ex_unit_prices.clone().into()).into()

+

+

+

    pub fn cost_models(&self, cost_models: &CostModels) -> Self {

+

        self.0.clone().cost_models(cost_models.clone().into()).into()

+

+

+

    pub fn collateral_percentage(&self, collateral_percentage: u32) -> Self {

+

        self.0.clone().collateral_percentage(collateral_percentage).into()

+

+

+

    pub fn max_collateral_inputs(&self, max_collateral_inputs: u32) -> Self {

+

        self.0.clone().max_collateral_inputs(max_collateral_inputs).into()

+

+

+

    pub fn build(&self) -> Result<TransactionBuilderConfig, JsError> {

+

        self.0.clone().build().map(Into::into).map_err(Into::into)

+

+

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct TransactionBuilder(cml_chain::builders::tx_builder::TransactionBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::tx_builder::TransactionBuilder, TransactionBuilder);

+

+

#[wasm_bindgen]

+

impl TransactionBuilder {

+

    /// This automatically selects and adds inputs from {inputs} consisting of just enough to cover

+

    /// the outputs that have already been added.

+

    /// This should be called after adding all certs/outputs/etc and will be an error otherwise.

+

    /// Uses CIP2: https://github.com/cardano-foundation/CIPs/blob/master/CIP-0002/CIP-0002.md

+

    /// Adding a change output must be called after via TransactionBuilder::add_change_if_needed()

+

    /// This function, diverging from CIP2, takes into account fees and will attempt to add additional

+

    /// inputs to cover the minimum fees. This does not, however, set the txbuilder's fee.

+

    pub fn select_utxos(&mut self, strategy: CoinSelectionStrategyCIP2) -> Result<(), JsError> {

+

        self.0.select_utxos(strategy).map_err(Into::into)

+

+

+

    pub fn add_input(&mut self, result: &InputBuilderResult) -> Result<(), JsError> {

+

        self.0.add_input(result.clone().into()).map_err(Into::into)

+

+

+

    pub fn add_utxo(&mut self, result: &InputBuilderResult) {

+

        self.0.add_utxo(result.clone().into())

+

+

+

    /// calculates how much the fee would increase if you added a given output

+

    pub fn fee_for_input(&self, result: &InputBuilderResult) -> Result<Coin, JsError> {

+

        self.0.fee_for_input(result.as_ref()).map_err(Into::into)

+

+

+

    pub fn add_reference_input(&mut self, utxo: &TransactionUnspentOutput) {

+

        self.0.add_reference_input(utxo.clone().into())

+

+

+

+

    /// Add explicit output via a TransactionOutput object

+

    pub fn add_output(&mut self, builder_result: &SingleOutputBuilderResult) -> Result<(), JsError> {

+

        self.0.add_output(builder_result.clone().into()).map_err(Into::into)

+

+

+

    /// calculates how much the fee would increase if you added a given output

+

    pub fn fee_for_output(&self, builder: &SingleOutputBuilderResult) -> Result<Coin, JsError> {

+

        self.0.fee_for_output(builder.as_ref()).map_err(Into::into)

+

+

+

    pub fn set_fee(&mut self, fee: Coin) {

+

        self.0.set_fee(fee)

+

+

+

    pub fn set_ttl(&mut self, ttl: Slot) {

+

        self.0.set_ttl(ttl)

+

+

+

    pub fn set_validity_start_interval(&mut self, validity_start_interval: Slot) {

+

        self.0.set_validity_start_interval(validity_start_interval)

+

+

+

    pub fn add_cert(&mut self, result: &CertificateBuilderResult) {

+

        self.0.add_cert(result.clone().into())

+

+

+

    pub fn get_withdrawals(&self) -> Option<Withdrawals> {

+

        self.0.get_withdrawals().map(|wd| wd.clone().into())

+

+

+

    pub fn add_withdrawal(&mut self, result: &WithdrawalBuilderResult) {

+

        self.0.add_withdrawal(result.clone().into())

+

+

+

    pub fn get_auxiliary_data(&self) -> Option<AuxiliaryData> {

+

        self.0.get_auxiliary_data().map(|aux| aux.clone().into())

+

+

+

    pub fn set_auxiliary_data(&mut self, new_aux_data: &AuxiliaryData) {

+

        self.0.set_auxiliary_data(new_aux_data.clone().into())

+

+

+

    pub fn add_auxiliary_data(&mut self, new_aux_data: &AuxiliaryData) {

+

        self.0.add_auxiliary_data(new_aux_data.clone().into())

+

+

+

    pub fn add_mint(&mut self, result: &MintBuilderResult) -> Result<(), JsError> {

+

        self.0.add_mint(result.clone().into()).map_err(Into::into)

+

+

+

    /// Returns a copy of the current mint state in the builder

+

    pub fn get_mint(&self) -> Option<Mint> {

+

        self.0.get_mint().map(|m| m.clone().into())

+

+

+

    pub fn new(cfg: &TransactionBuilderConfig) -> Self {

+

        cml_chain::builders::tx_builder::TransactionBuilder::new(cfg.clone().into()).into()

+

+

+

    pub fn add_collateral(&mut self, result: &InputBuilderResult) -> Result<(), JsError>  {

+

        self.0.add_collateral(result.clone().into()).map_err(Into::into)

+

+

+

    pub fn add_required_signer(&mut self, hash: &Ed25519KeyHash) {

a

chain/wasm/src/builders/withdrawal_builder.rs

+48/-0

+

use crate::*;

+

use crate::builders::witness_builder::{PartialPlutusWitness};

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

+

use super::witness_builder::{NativeScriptWitnessInfo};

+

+

use crate::{

+

    address::RewardAddress,

+

    transaction::RequiredSigners,

+

};

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct WithdrawalBuilderResult(cml_chain::builders::withdrawal_builder::WithdrawalBuilderResult);

+

+

impl_wasm_conversions!(cml_chain::builders::withdrawal_builder::WithdrawalBuilderResult, WithdrawalBuilderResult);

+

+

#[wasm_bindgen]

+

#[derive(Clone)]

+

pub struct SingleWithdrawalBuilder(cml_chain::builders::withdrawal_builder::SingleWithdrawalBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::withdrawal_builder::SingleWithdrawalBuilder, SingleWithdrawalBuilder);

+

+

#[wasm_bindgen]

+

impl SingleWithdrawalBuilder {

+

    pub fn new(address: &RewardAddress, amount: Coin) -> Self {

+

        cml_chain::builders::withdrawal_builder::SingleWithdrawalBuilder::new(address.clone().into(), amount).into()

+

+

+

    pub fn payment_key(&self) -> Result<WithdrawalBuilderResult, JsError> {

+

        self.0.clone().payment_key().map(Into::into).map_err(Into::into)

+

+

+

    pub fn native_script(self, native_script: &NativeScript, witness_info: &NativeScriptWitnessInfo) -> Result<WithdrawalBuilderResult, JsError> {

+

        self.0.clone().native_script(

+

            native_script.as_ref(),

+

            witness_info.as_ref(),

+

        ).map(Into::into).map_err(Into::into)

+

+

+

    pub fn plutus_script(self, partial_witness: PartialPlutusWitness, required_signers: RequiredSigners) -> Result<WithdrawalBuilderResult, JsError> {

+

        self.0.clone().plutus_script(

+

            partial_witness.clone().into(),

+

            required_signers.clone().into(),

+

        ).map(Into::into).map_err(Into::into)

+

+

a

chain/wasm/src/builders/witness_builder.rs

+227/-0

+

use wasm_bindgen::prelude::{wasm_bindgen, JsError};

+

use cml_core_wasm::impl_wasm_conversions;

+

use cml_crypto_wasm::{

+

    DatumHash, Ed25519KeyHash, ScriptHash

+

};

+

use crate::{

+

    Script,

+

    byron::ByronAddress,

+

    crypto::{BootstrapWitness, Vkeywitness},

+

    transaction::{TransactionWitnessSet},

+

    plutus::{PlutusData, Redeemer},

+

    NativeScriptList, PlutusV1ScriptList, PlutusV2ScriptList, RedeemerList, PlutusDataList, Ed25519KeyHashList, address::RewardAddress,

+

};

+

+

use super::redeemer_builder::{RedeemerWitnessKey};

+

+

#[wasm_bindgen]

+

#[derive(Debug, Clone)]

+

pub struct PlutusScriptWitness(cml_chain::builders::witness_builder::PlutusScriptWitness);

+

+

impl_wasm_conversions!(cml_chain::builders::witness_builder::PlutusScriptWitness, PlutusScriptWitness);

+

+

#[wasm_bindgen]

+

impl PlutusScriptWitness {

+

    // pub fn script(&self) -> Option<PlutusScript> {

+

    //     match self {

+

    //         Self::Ref(_) => None,

+

    //         Self::Script(script) => Some(script.clone()),

+

    //     }

+

    // }

+

+

    pub fn hash(&self) -> ScriptHash {

+

        self.0.hash().into()

+

+

+

+

/// A partial Plutus witness

+

/// It contains all the information needed to witness the Plutus script execution

+

/// except for the redeemer tag and index

+

/// Note: no datum is attached because only input script types have datums

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct PartialPlutusWitness(cml_chain::builders::witness_builder::PartialPlutusWitness);

+

+

impl_wasm_conversions!(cml_chain::builders::witness_builder::PartialPlutusWitness, PartialPlutusWitness);

+

+

#[wasm_bindgen]

+

impl PartialPlutusWitness {

+

    pub fn new(script: &PlutusScriptWitness, data: &PlutusData) -> Self {

+

        cml_chain::builders::witness_builder::PartialPlutusWitness::new(

+

            script.clone().into(),

+

            data.clone().into()

+

        ).into()

+

+

+

    pub fn script(&self) -> PlutusScriptWitness {

+

        self.0.script.clone().into()

+

+

+

    pub fn data(&self) -> PlutusData {

+

        self.0.data.clone().into()

+

+

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug)]

+

pub struct InputAggregateWitnessData(cml_chain::builders::witness_builder::InputAggregateWitnessData);

+

+

impl_wasm_conversions!(cml_chain::builders::witness_builder::InputAggregateWitnessData, InputAggregateWitnessData);

+

+

#[wasm_bindgen]

+

impl InputAggregateWitnessData {

+

    pub fn plutus_data(&self) -> Option<PlutusData> {

+

        self.0.plutus_data().map(|d| d.clone().into())

+

+

+

+

+

+

#[wasm_bindgen]

+

#[derive(Clone, Debug, Default)]

+

pub struct RequiredWitnessSet(cml_chain::builders::witness_builder::RequiredWitnessSet);

+

+

impl_wasm_conversions!(cml_chain::builders::witness_builder::RequiredWitnessSet, RequiredWitnessSet);

+

+

#[wasm_bindgen]

+

impl RequiredWitnessSet {

+

    pub fn add_vkey_key_hash(&mut self, hash: &Ed25519KeyHash) {

+

        self.0.add_vkey_key_hash(hash.clone().into());

+

+

+

    pub fn add_bootstrap(&mut self, address: &ByronAddress) {

+

        self.0.add_bootstrap(address.clone().into());

+

+

+

    pub fn add_script_ref(&mut self, script_hash: &ScriptHash) {

+

        self.0.add_script_ref(script_hash.clone().into());

+

+

+

    pub fn add_script_hash(&mut self, script_hash: &ScriptHash) {

+

        self.0.add_script_hash(script_hash.clone().into());

+

+

+

    pub fn add_plutus_datum_hash(&mut self, plutus_datum: &DatumHash) {

+

        self.0.add_plutus_datum_hash(plutus_datum.clone().into());

+

+

+

    pub fn add_redeemer_tag(&mut self, redeemer: &RedeemerWitnessKey) {

+

        self.0.add_redeemer_tag(redeemer.clone().into());

+

+

+

    pub fn add_all(&mut self, requirements: &RequiredWitnessSet) {

+

        self.0.add_all(requirements.clone().into());

+

+

+

    pub fn new() -> Self {

+

        cml_chain::builders::witness_builder::RequiredWitnessSet::new().into()

+

+

+

    // comes from witsVKeyNeeded in the Ledger spec

+

    // this is here instead of withdrawal_builder.rs due to wasm restrictions on &mut params

+

    pub fn withdrawal_required_wits(&mut self, address: &RewardAddress) {

+

        cml_chain::builders::withdrawal_builder::withdrawal_required_wits(address.as_ref(), &mut self.0);

+

+

+

+

/// Builder de-duplicates witnesses as they are added

+

#[wasm_bindgen]

+

#[derive(Clone, Default, Debug)]

+

pub struct TransactionWitnessSetBuilder(cml_chain::builders::witness_builder::TransactionWitnessSetBuilder);

+

+

impl_wasm_conversions!(cml_chain::builders::witness_builder::TransactionWitnessSetBuilder, TransactionWitnessSetBuilder);

+

+

#[wasm_bindgen]

+

impl TransactionWitnessSetBuilder {

+

    pub fn add_vkey(&mut self, vkey_witness: &Vkeywitness) {

+

        self.0.add_vkey(vkey_witness.clone().into());

+

+

+

    pub fn add_bootstrap(&mut self, bootstrap: &BootstrapWitness) {

+

        self.0.add_bootstrap(bootstrap.clone().into())

+

+

+

    pub fn add_script(&mut self, script: &Script) {

+

        self.0.add_script(script.clone().into());

+

+

+

    pub fn get_native_script(&self) -> NativeScriptList {

+

        self.0.get_native_script().into()

+

+

+

    pub fn get_plutus_v1_script(&self) -> PlutusV1ScriptList {

+

        self.0.get_plutus_v1_script().into()

+

+

+

    pub fn get_plutus_v2_script(&self) -> PlutusV2ScriptList {

+

        self.0.get_plutus_v2_script().into()

+

+

+

    pub fn add_plutus_datum(&mut self, plutus_datum: PlutusData) {

+

        self.0.add_plutus_datum(plutus_datum.clone().into());

+

+

+

    pub fn get_plutus_datum(&self) -> PlutusDataList {

+

        self.0.get_plutus_datum().into()

+

+

+

    pub fn add_redeemer(&mut self, redeemer: &Redeemer) {

+

        self.0.add_redeemer(redeemer.clone().into());

+

+

+

    pub fn get_redeemer(&self) -> RedeemerList {

+

        self.0.get_redeemer().into()

+

+

+

    pub fn add_required_wits(&mut self, required_wits: &RequiredWitnessSet) {

+

        self.0.add_required_wits(required_wits.clone().into());

+

+

+

    pub fn new() -> Self {

+

        cml_chain::builders::witness_builder::TransactionWitnessSetBuilder::new().into()

+

+

+

    pub fn add_existing(&mut self, wit_set: &TransactionWitnessSet) {

+

        self.0.add_existing(wit_set.clone().into());

+

+

+

    pub fn build(&self) -> TransactionWitnessSet {

+

        self.0.clone().build().into()

+

+

+

    pub fn remaining_wits(&self) -> RequiredWitnessSet {

+

        self.0.remaining_wits().into()

+

+

+

    pub fn try_build(&self) -> Result<TransactionWitnessSet, JsError> {

+

        self.0.try_build().map(Into::into).map_err(Into::into)

+

+

Yesterday's Report

Wednesday, September 20, 2023

727 commits in 72 repos

New Repo Discovered

Wed, 20 Sep 23 12:04:09 +0000 · aiken-mode

Emacs Lisp · MPL-2.0

New Releases

Wed, 20 Sep 23 17:14:01 +0000 · v1.0.17-alpha aiken Wed, 20 Sep 23 17:00:12 +0000 · Unstable Development Builds mithril Wed, 20 Sep 23 16:12:11 +0000 · @cardano-sdk/[email protected] cardano-js-sdk Wed, 20 Sep 23 14:24:04 +0000 · Open Enterprise Agent v1.16.0 open-enterprise-agent Wed, 20 Sep 23 14:24:04 +0000 · Open Enterprise Agent v1.16.0 atala-prism-building-blocks Wed, 20 Sep 23 14:12:47 +0000 · Cardano Node 8.4.0-pre cardano-node

3,572 commits this week Sep 14, 2023 - Sep 21, 2023

Showing 25 of 3572 recent commits.