@meshsdk/core-csl 1.6.0-alpha.1

package/dist/mjs/core/builder.js

@@ -0,0 +1,380 @@
+import JSONbig from 'json-bigint';
+import { DEFAULT_PROTOCOL_PARAMETERS, selectUtxos } from '@meshsdk/common';
+import { signTransaction } from '../utils';
+import { buildDataCost, buildTxBuilder, toAddress, toPlutusData, toRelay, toValue, csl, LANGUAGE_VERSIONS, } from '../deser';
+export const emptyTxBuilderBody = () => ({
+    inputs: [],
+    outputs: [],
+    extraInputs: [],
+    selectionThreshold: 0,
+    collaterals: [],
+    requiredSignatures: [],
+    referenceInputs: [],
+    mints: [],
+    changeAddress: '',
+    metadata: [],
+    validityRange: {},
+    certificates: [],
+    signingKey: [],
+});
+export class CSLSerializer {
+    txBuilder;
+    protocolParams;
+    meshTxBuilderBody = emptyTxBuilderBody();
+    constructor(protocolParams) {
+        this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
+        this.txBuilder = buildTxBuilder(protocolParams);
+    }
+    serializeTxBody(txBody, protocolParams) {
+        if (protocolParams) {
+            this.protocolParams = protocolParams;
+        }
+        this.txBuilder = buildTxBuilder(protocolParams);
+        const { inputs, outputs, extraInputs, selectionThreshold, collaterals, referenceInputs, mints, changeAddress, certificates, validityRange, requiredSignatures, metadata, } = txBody;
+        if (extraInputs.length > 0) {
+            this.addUtxosFrom(extraInputs, String(selectionThreshold));
+        }
+        this.removeDuplicateInputs();
+        mints.sort((a, b) => a.policyId.localeCompare(b.policyId));
+        inputs.sort((a, b) => {
+            if (a.txIn.txHash === b.txIn.txHash) {
+                return a.txIn.txIndex - b.txIn.txIndex;
+            }
+            return a.txIn.txHash.localeCompare(b.txIn.txHash);
+        });
+        this.addAllInputs(inputs);
+        this.addAllOutputs(outputs);
+        this.addAllCollaterals(collaterals);
+        this.addAllReferenceInputs(referenceInputs);
+        this.addAllMints(mints);
+        this.addAllCertificates(certificates);
+        this.addValidityRange(validityRange);
+        this.addAllRequiredSignatures(requiredSignatures);
+        this.addAllMetadata(metadata);
+        this.addCostModels();
+        if (changeAddress) {
+            // Hacky fix to set a dummy collateral return so fees are calculated correctly
+            const totalCollateral = collaterals
+                .map((collateral) => collateral.txIn.amount?.find((asset) => asset.unit === 'lovelace')
+                ?.quantity || '0')
+                .reduce((acc, curr) => acc + parseInt(curr), 0);
+            const collateralEstimate = Math.ceil((this.protocolParams.collateralPercent *
+                Number(Number(this.txBuilder
+                    .min_fee()
+                    .checked_add(csl.BigNum.from_str('10000'))
+                    .to_js_value()))) /
+                100);
+            let collateralReturnNeeded = false;
+            if (totalCollateral - collateralEstimate > 0) {
+                const collateralEstimateOutput = csl.TransactionOutput.new(csl.Address.from_bech32(changeAddress), csl.Value.new(csl.BigNum.from_str(String(collateralEstimate))));
+                if (totalCollateral - collateralEstimate >
+                    Number(csl
+                        .min_ada_for_output(collateralEstimateOutput, csl.DataCost.new_coins_per_byte(csl.BigNum.from_str(this.protocolParams.coinsPerUTxOSize)))
+                        .to_js_value())) {
+                    this.txBuilder.set_collateral_return(csl.TransactionOutput.new(csl.Address.from_bech32(changeAddress), csl.Value.new(csl.BigNum.from_str(String(totalCollateral)))));
+                    this.txBuilder.set_total_collateral(csl.BigNum.from_str(String(totalCollateral)));
+                    collateralReturnNeeded = true;
+                }
+            }
+            this.addChange(changeAddress);
+            if (collateralReturnNeeded)
+                this.addCollateralReturn(changeAddress);
+        }
+        const tx = this.txBuilder.build_tx();
+        // const txJson = JSON.parse(tx.to_json());
+        const txHex = tx.to_hex();
+        return txHex;
+    }
+    addSigningKeys(txHex, signingKeys) {
+        if (signingKeys.length > 0) {
+            return signTransaction(txHex, signingKeys);
+        }
+        return txHex;
+    }
+    addUtxosFrom = (extraInputs, threshold) => {
+        const requiredAssets = this.meshTxBuilderBody.outputs.reduce((map, output) => {
+            const outputAmount = output.amount;
+            outputAmount.forEach((asset) => {
+                const { unit, quantity } = asset;
+                const existingQuantity = Number(map.get(unit)) || 0;
+                map.set(unit, String(existingQuantity + Number(quantity)));
+            });
+            return map;
+        }, new Map());
+        this.meshTxBuilderBody.inputs.reduce((map, input) => {
+            const inputAmount = input.txIn.amount;
+            inputAmount?.forEach((asset) => {
+                const { unit, quantity } = asset;
+                const existingQuantity = Number(map.get(unit)) || 0;
+                map.set(unit, String(existingQuantity - Number(quantity)));
+            });
+            return map;
+        }, requiredAssets);
+        this.meshTxBuilderBody.mints.reduce((map, mint) => {
+            const mintAmount = {
+                unit: mint.policyId + mint.assetName,
+                quantity: String(mint.amount),
+            };
+            const existingQuantity = Number(map.get(mintAmount.unit)) || 0;
+            map.set(mintAmount.unit, String(existingQuantity - Number(mintAmount.quantity)));
+            return map;
+        }, requiredAssets);
+        const selectedInputs = selectUtxos(extraInputs, requiredAssets, threshold);
+        selectedInputs.forEach((input) => {
+            const pubKeyTxIn = {
+                type: 'PubKey',
+                txIn: {
+                    txHash: input.input.txHash,
+                    txIndex: input.input.outputIndex,
+                    amount: input.output.amount,
+                    address: input.output.address,
+                },
+            };
+            this.meshTxBuilderBody.inputs.push(pubKeyTxIn);
+            this.addTxIn(pubKeyTxIn);
+        });
+    };
+    makePlutusScriptSource = (scriptSourceInfo) => {
+        const scriptHash = csl.ScriptHash.from_hex(scriptSourceInfo.spendingScriptHash);
+        const scriptRefInput = csl.TransactionInput.new(csl.TransactionHash.from_hex(scriptSourceInfo.txHash), scriptSourceInfo.txIndex);
+        const scriptSource = csl.PlutusScriptSource.new_ref_input_with_lang_ver(scriptHash, scriptRefInput, LANGUAGE_VERSIONS[scriptSourceInfo.version]);
+        return scriptSource;
+    };
+    // Below protected functions for completing tx building
+    removeDuplicateInputs = () => {
+        const { inputs } = this.meshTxBuilderBody;
+        const getTxInId = (txIn) => `${txIn.txHash}#${txIn.txIndex}`;
+        const addedInputs = [];
+        for (let i = 0; i < inputs.length; i += 1) {
+            const currentTxInId = getTxInId(inputs[i].txIn);
+            if (addedInputs.includes(currentTxInId)) {
+                inputs.splice(i, 1);
+                i -= 1;
+            }
+            else {
+                addedInputs.push(currentTxInId);
+            }
+        }
+    };
+    addAllInputs = (inputs) => {
+        for (let i = 0; i < inputs.length; i += 1) {
+            const currentTxIn = inputs[i]; // TODO: add type
+            switch (currentTxIn.type) {
+                case 'PubKey':
+                    this.addTxIn(currentTxIn);
+                    break;
+                case 'Script':
+                    this.addScriptTxIn(currentTxIn);
+                    break;
+            }
+        }
+    };
+    addTxIn = (currentTxIn) => {
+        this.txBuilder.add_input(csl.Address.from_bech32(currentTxIn.txIn.address), csl.TransactionInput.new(csl.TransactionHash.from_hex(currentTxIn.txIn.txHash), currentTxIn.txIn.txIndex), toValue(currentTxIn.txIn.amount));
+    };
+    addScriptTxIn = ({ scriptTxIn, txIn, }) => {
+        let cslDatum;
+        const { datumSource, scriptSource, redeemer } = scriptTxIn;
+        if (datumSource.type === 'Provided') {
+            cslDatum = csl.DatumSource.new(this.castDataToPlutusData(datumSource.data));
+        }
+        else {
+            const refTxIn = csl.TransactionInput.new(csl.TransactionHash.from_hex(datumSource.txHash), datumSource.txIndex);
+            cslDatum = csl.DatumSource.new_ref_input(refTxIn);
+        }
+        let cslScript;
+        if (scriptSource.type === 'Inline') {
+            cslScript = this.makePlutusScriptSource(scriptSource.txInInfo);
+        }
+        else {
+            cslScript = csl.PlutusScriptSource.new(csl.PlutusScript.from_hex_with_version(scriptSource.script.code, LANGUAGE_VERSIONS[scriptSource.script.version]));
+        }
+        const cslRedeemer = csl.Redeemer.new(csl.RedeemerTag.new_spend(), csl.BigNum.from_str('0'), this.castDataToPlutusData(redeemer.data), csl.ExUnits.new(csl.BigNum.from_str(String(redeemer.exUnits.mem)), csl.BigNum.from_str(String(redeemer.exUnits.steps))));
+        this.txBuilder.add_plutus_script_input(csl.PlutusWitness.new_with_ref(cslScript, cslDatum, cslRedeemer), csl.TransactionInput.new(csl.TransactionHash.from_hex(txIn.txHash), txIn.txIndex), toValue(txIn.amount));
+    };
+    addAllOutputs = (outputs) => {
+        for (let i = 0; i < outputs.length; i += 1) {
+            const currentOutput = outputs[i];
+            this.addOutput(currentOutput);
+        }
+    };
+    addOutput = ({ amount, address, datum, referenceScript }) => {
+        const txValue = toValue(amount);
+        const multiAsset = txValue.multiasset();
+        if (txValue.is_zero() && multiAsset === undefined)
+            throw Error('Invalid output amount');
+        let outputBuilder = csl.TransactionOutputBuilder.new().with_address(toAddress(address));
+        if (datum && datum.type === 'Hash') {
+            outputBuilder = outputBuilder.with_data_hash(csl.hash_plutus_data(this.castDataToPlutusData(datum.data)));
+        }
+        if (datum && datum.type === 'Inline') {
+            outputBuilder = outputBuilder.with_plutus_data(this.castDataToPlutusData(datum.data));
+        }
+        if (referenceScript) {
+            outputBuilder = outputBuilder.with_script_ref(csl.ScriptRef.new_plutus_script(csl.PlutusScript.from_hex_with_version(referenceScript.code, LANGUAGE_VERSIONS[referenceScript.version])));
+        }
+        const amountBuilder = outputBuilder.next();
+        if (multiAsset) {
+            const output = txValue.coin().is_zero()
+                ? amountBuilder
+                    .with_asset_and_min_required_coin_by_utxo_cost(multiAsset, buildDataCost(this.protocolParams.coinsPerUTxOSize))
+                    .build()
+                : amountBuilder.with_coin_and_asset(txValue.coin(), multiAsset).build();
+            this.txBuilder.add_output(output);
+        }
+        else {
+            const output = amountBuilder.with_coin(txValue.coin()).build();
+            this.txBuilder.add_output(output);
+        }
+    };
+    addAllCollaterals = (collaterals) => {
+        const collateralBuilder = csl.TxInputsBuilder.new();
+        for (let i = 0; i < collaterals.length; i += 1) {
+            const currentCollateral = collaterals[i];
+            this.addCollateral(collateralBuilder, currentCollateral);
+        }
+        this.txBuilder.set_collateral(collateralBuilder);
+    };
+    addCollateral = (collateralBuilder, currentCollateral) => {
+        collateralBuilder.add_input(csl.Address.from_bech32(currentCollateral.txIn.address), csl.TransactionInput.new(csl.TransactionHash.from_hex(currentCollateral.txIn.txHash), currentCollateral.txIn.txIndex), toValue(currentCollateral.txIn.amount));
+    };
+    addCollateralReturn = (returnAddress) => {
+        const currentFee = this.txBuilder.get_fee_if_set()?.to_js_value();
+        if (currentFee) {
+            const collateralAmount = Math.ceil((this.protocolParams.collateralPercent * Number(currentFee)) / 100);
+            this.txBuilder.set_total_collateral_and_return(csl.BigNum.from_str(String(collateralAmount)), csl.Address.from_bech32(returnAddress));
+        }
+    };
+    addAllReferenceInputs = (refInputs) => {
+        refInputs.forEach((refInput) => {
+            this.addReferenceInput(refInput);
+        });
+    };
+    addReferenceInput = ({ txHash, txIndex }) => {
+        const refInput = csl.TransactionInput.new(csl.TransactionHash.from_hex(txHash), txIndex);
+        this.txBuilder.add_reference_input(refInput);
+    };
+    addAllMints = (mints) => {
+        const mintBuilder = csl.MintBuilder.new();
+        let plutusMintCount = 0;
+        for (let i = 0; i < mints.length; i += 1) {
+            const mintItem = mints[i];
+            if (!mintItem.scriptSource)
+                throw Error('Mint script is expected to be provided');
+            if (mintItem.type === 'Plutus') {
+                if (!mintItem.redeemer)
+                    throw Error('Missing mint redeemer information');
+                this.addPlutusMint(mintBuilder, mintItem, plutusMintCount); // TODO: Update after csl update
+                plutusMintCount += 1; // TODO: Remove after csl update
+            }
+            else if (mintItem.type === 'Native') {
+                this.addNativeMint(mintBuilder, mintItem);
+            }
+        }
+        this.txBuilder.set_mint_builder(mintBuilder);
+    };
+    addPlutusMint = (mintBuilder, { redeemer, policyId, scriptSource, assetName, amount }, redeemerIndex) => {
+        const newRedeemer = csl.Redeemer.new(csl.RedeemerTag.new_mint(), csl.BigNum.from_str(String(redeemerIndex)), this.castDataToPlutusData(redeemer.data), csl.ExUnits.new(csl.BigNum.from_str(String(redeemer.exUnits.mem)), csl.BigNum.from_str(String(redeemer.exUnits.steps))));
+        const script = scriptSource.type === 'Reference Script'
+            ? csl.PlutusScriptSource.new_ref_input_with_lang_ver(csl.ScriptHash.from_hex(policyId), csl.TransactionInput.new(csl.TransactionHash.from_hex(scriptSource.txHash), scriptSource.txIndex), LANGUAGE_VERSIONS[scriptSource.version])
+            : csl.PlutusScriptSource.new(csl.PlutusScript.from_hex_with_version(scriptSource.script.code, LANGUAGE_VERSIONS[scriptSource.script.version]));
+        mintBuilder.add_asset(csl.MintWitness.new_plutus_script(script, newRedeemer), csl.AssetName.new(Buffer.from(assetName, 'hex')), csl.Int.from_str(amount));
+    };
+    addNativeMint = (mintBuilder, { scriptSource, assetName, amount }) => {
+        if (scriptSource.type === 'Reference Script')
+            throw Error('Native mint cannot have reference script');
+        mintBuilder.add_asset(csl.MintWitness.new_native_script(csl.NativeScript.from_hex(scriptSource.script.code)), csl.AssetName.new(Buffer.from(assetName, 'hex')), csl.Int.from_str(amount));
+    };
+    decimalToFraction(decimal) {
+        const powerOf10 = 10 ** decimal.toString().split('.')[1].length;
+        const numerator = decimal * powerOf10;
+        const denominator = powerOf10;
+        return [numerator, denominator];
+    }
+    toPoolParams = (poolParams) => {
+        const marginFraction = this.decimalToFraction(poolParams.margin);
+        const relays = csl.Relays.new();
+        poolParams.relays.forEach((relay) => {
+            relays.add(toRelay(relay));
+        });
+        const rewardAddress = csl.RewardAddress.from_address(csl.Address.from_bech32(poolParams.rewardAddress));
+        if (rewardAddress === undefined) {
+            throw new Error('Reward address is invalid');
+        }
+        const poolOwners = csl.Ed25519KeyHashes.new();
+        poolParams.owners.forEach((owner) => {
+            poolOwners.add(csl.Ed25519KeyHash.from_hex(owner));
+        });
+        return csl.PoolParams.new(csl.Ed25519KeyHash.from_hex(poolParams.operator), csl.VRFKeyHash.from_hex(poolParams.VRFKeyHash), csl.BigNum.from_str(poolParams.pledge), csl.BigNum.from_str(poolParams.cost), csl.UnitInterval.new(csl.BigNum.from_str(marginFraction[0].toString()), csl.BigNum.from_str(marginFraction[1].toString())), rewardAddress, poolOwners, relays, poolParams.metadata
+            ? csl.PoolMetadata.from_json(JSONbig.stringify(poolParams.metadata))
+            : undefined);
+    };
+    addCertificate = (certificates, cert) => {
+        switch (cert.type) {
+            case 'RegisterPool':
+                certificates.add(csl.Certificate.new_pool_registration(csl.PoolRegistration.new(this.toPoolParams(cert.poolParams))));
+                break;
+            case 'RegisterStake':
+                certificates.add(csl.Certificate.new_stake_registration(csl.StakeRegistration.new(csl.StakeCredential.from_keyhash(csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)))));
+                break;
+            case 'DelegateStake':
+                certificates.add(csl.Certificate.new_stake_delegation(csl.StakeDelegation.new(csl.StakeCredential.from_keyhash(csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)), cert.poolId.startsWith('pool')
+                    ? csl.Ed25519KeyHash.from_bech32(cert.poolId)
+                    : csl.Ed25519KeyHash.from_hex(cert.poolId))));
+                break;
+            case 'DeregisterStake':
+                certificates.add(csl.Certificate.new_stake_deregistration(csl.StakeDeregistration.new(csl.StakeCredential.from_keyhash(csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)))));
+                break;
+            case 'RetirePool':
+                certificates.add(csl.Certificate.new_pool_retirement(csl.PoolRetirement.new(cert.poolId.startsWith('pool')
+                    ? csl.Ed25519KeyHash.from_bech32(cert.poolId)
+                    : csl.Ed25519KeyHash.from_hex(cert.poolId), cert.epoch)));
+        }
+    };
+    addAllCertificates = (allCertificates) => {
+        const certificates = csl.Certificates.new();
+        allCertificates.forEach((cert) => {
+            this.addCertificate(certificates, cert);
+        });
+        this.txBuilder.set_certs(certificates);
+    };
+    addCostModels = () => {
+        this.txBuilder.calc_script_data_hash(csl.TxBuilderConstants.plutus_vasil_cost_models());
+    };
+    addChange = (changeAddress) => {
+        this.txBuilder.add_change_if_needed(csl.Address.from_bech32(changeAddress));
+    };
+    addValidityRange = ({ invalidBefore, invalidHereafter }) => {
+        if (invalidBefore) {
+            this.txBuilder.set_validity_start_interval_bignum(csl.BigNum.from_str(invalidBefore.toString()));
+        }
+        if (invalidHereafter) {
+            this.txBuilder.set_ttl_bignum(csl.BigNum.from_str(invalidHereafter.toString()));
+        }
+    };
+    addAllRequiredSignatures = (requiredSignatures) => {
+        requiredSignatures.forEach((pubKeyHash) => {
+            this.txBuilder.add_required_signer(csl.Ed25519KeyHash.from_hex(pubKeyHash));
+        });
+    };
+    addAllMetadata = (allMetadata) => {
+        allMetadata.forEach(({ tag, metadata }) => {
+            this.txBuilder.add_json_metadatum(csl.BigNum.from_str(tag), JSONbig.stringify(metadata));
+        });
+    };
+    castRawDataToJsonString = (rawData) => {
+        if (typeof rawData === 'object') {
+            return JSONbig.stringify(rawData);
+        }
+        return rawData;
+    };
+    castDataToPlutusData = ({ type, content }) => {
+        if (type === 'Mesh') {
+            return toPlutusData(content);
+        }
+        if (type === 'CBOR') {
+            return csl.PlutusData.from_hex(content);
+        }
+        return csl.PlutusData.from_json(content, csl.PlutusDatumSchema.DetailedSchema);
+    };
+}

package/dist/mjs/core/index.d.ts

@@ -0,0 +1 @@
+export * from './builder';

package/dist/mjs/core/index.js

@@ -0,0 +1 @@
+export * from './builder';

package/dist/mjs/deser/builder.d.ts

@@ -0,0 +1,18 @@
+import { Action, Data, PlutusScript, Recipient, UTxO } from '@meshsdk/core';
+import { csl } from './csl';
+import type { BaseAddress, Bip32PrivateKey, DataCost, DatumSource, Ed25519KeyHash, EnterpriseAddress, MintWitness, PlutusScriptSource, RewardAddress, TransactionBuilder, TransactionOutputBuilder, TxInputsBuilder } from './types';
+export declare const buildBaseAddress: (networkId: number, paymentKeyHash: Ed25519KeyHash, stakeKeyHash: Ed25519KeyHash) => BaseAddress;
+export declare const buildBip32PrivateKey: (entropy: string, password?: string) => Bip32PrivateKey;
+export declare const buildDataCost: (coinsPerByte: string) => DataCost;
+export declare const buildDatumSource: (datum: Data | UTxO) => DatumSource;
+export declare const buildEnterpriseAddress: (networkId: number, paymentKeyHash: Ed25519KeyHash) => EnterpriseAddress;
+export declare const buildGeneralTxMetadata: (metadata: Record<string, unknown>) => csl.GeneralTransactionMetadata;
+export declare const buildMintWitness: (script: string | PlutusScript | UTxO, redeemer?: Partial<Action>) => MintWitness;
+export declare const buildRewardAddress: (networkId: number, stakeKeyHash: Ed25519KeyHash) => RewardAddress;
+export declare const buildPlutusScriptSource: (script: PlutusScript | UTxO) => PlutusScriptSource;
+export declare const buildScriptPubkey: (keyHash: Ed25519KeyHash) => csl.NativeScript;
+export declare const buildTimelockExpiry: (slot: string) => csl.NativeScript;
+export declare const buildTimelockStart: (slot: string) => csl.NativeScript;
+export declare const buildTxBuilder: (parameters?: import("@meshsdk/core").Protocol) => TransactionBuilder;
+export declare const buildTxInputsBuilder: (utxos: unknown[]) => TxInputsBuilder;
+export declare const buildTxOutputBuilder: (recipient: Recipient) => TransactionOutputBuilder;

package/dist/mjs/deser/builder.js

@@ -0,0 +1,118 @@
+import { DEFAULT_PROTOCOL_PARAMETERS, DEFAULT_REDEEMER_BUDGET } from '@meshsdk/common';
+import { LANGUAGE_VERSIONS } from './constants';
+import { csl } from './csl';
+import { fromScriptRef, fromUTF8, toAddress, toBytes, toPlutusData, toRedeemer, toScriptRef, toTxUnspentOutput, toUnitInterval, } from './converter';
+import { deserializeNativeScript, deserializePlutusScript } from './deserializer';
+export const buildBaseAddress = (networkId, paymentKeyHash, stakeKeyHash) => csl.BaseAddress.new(networkId, csl.StakeCredential.from_keyhash(paymentKeyHash), csl.StakeCredential.from_keyhash(stakeKeyHash));
+export const buildBip32PrivateKey = (entropy, password = '') => csl.Bip32PrivateKey.from_bip39_entropy(toBytes(entropy), toBytes(fromUTF8(password)));
+export const buildDataCost = (coinsPerByte) => csl.DataCost.new_coins_per_byte(csl.BigNum.from_str(coinsPerByte));
+export const buildDatumSource = (datum) => {
+    if (typeof datum !== 'object' || !('input' in datum)) {
+        return csl.DatumSource.new(toPlutusData(datum));
+    }
+    const utxo = toTxUnspentOutput(datum);
+    if (utxo.output().has_plutus_data()) {
+        return csl.DatumSource.new_ref_input(utxo.input());
+    }
+    throw new Error(`No inline datum found in UTxO: ${utxo.input().transaction_id().to_hex()}`);
+};
+export const buildEnterpriseAddress = (networkId, paymentKeyHash) => csl.EnterpriseAddress.new(networkId, csl.StakeCredential.from_keyhash(paymentKeyHash));
+export const buildGeneralTxMetadata = (metadata) => {
+    const generalTxMetadata = csl.GeneralTransactionMetadata.new();
+    Object.entries(metadata).forEach(([MetadataLabel, Metadata]) => {
+        generalTxMetadata.insert(csl.BigNum.from_str(MetadataLabel), csl.encode_json_str_to_metadatum(JSON.stringify(Metadata), csl.MetadataJsonSchema.NoConversions));
+    });
+    return generalTxMetadata;
+};
+export const buildMintWitness = (script, redeemer) => {
+    if (typeof script === 'string') {
+        return csl.MintWitness.new_native_script(deserializeNativeScript(script));
+    }
+    if (redeemer === undefined)
+        throw new Error('Minting with plutus requires a redeemer to be defined');
+    if (redeemer.tag !== 'MINT')
+        throw new Error("Minting redeemer's tag must be defined as 'MINT'");
+    return csl.MintWitness.new_plutus_script(buildPlutusScriptSource(script), toRedeemer({
+        tag: 'MINT',
+        index: 0,
+        budget: DEFAULT_REDEEMER_BUDGET,
+        data: {
+            alternative: 0,
+            fields: [],
+        },
+        ...redeemer,
+    }));
+};
+export const buildRewardAddress = (networkId, stakeKeyHash) => csl.RewardAddress.new(networkId, csl.StakeCredential.from_keyhash(stakeKeyHash));
+export const buildPlutusScriptSource = (script) => {
+    if ('code' in script) {
+        return csl.PlutusScriptSource.new(deserializePlutusScript(script.code, script.version));
+    }
+    const utxo = toTxUnspentOutput(script);
+    if (utxo.output().has_script_ref()) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const scriptRef = utxo.output().script_ref();
+        if (scriptRef.is_plutus_script()) {
+            const plutusScript = fromScriptRef(scriptRef);
+            const scriptHash = deserializePlutusScript(plutusScript.code, plutusScript.version).hash();
+            return csl.PlutusScriptSource.new_ref_input_with_lang_ver(scriptHash, utxo.input(), LANGUAGE_VERSIONS[plutusScript.version]);
+        }
+    }
+    throw new Error(`No plutus script reference found in UTxO: ${utxo.input().transaction_id().to_hex()}`);
+};
+export const buildScriptPubkey = (keyHash) => {
+    const scriptPubkey = csl.ScriptPubkey.new(keyHash);
+    return csl.NativeScript.new_script_pubkey(scriptPubkey);
+};
+export const buildTimelockExpiry = (slot) => {
+    const expiry = csl.BigNum.from_str(slot);
+    const timelockExpiry = csl.TimelockExpiry.new_timelockexpiry(expiry);
+    return csl.NativeScript.new_timelock_expiry(timelockExpiry);
+};
+export const buildTimelockStart = (slot) => {
+    const start = csl.BigNum.from_str(slot);
+    const timelockStart = csl.TimelockStart.new_timelockstart(start);
+    return csl.NativeScript.new_timelock_start(timelockStart);
+};
+export const buildTxBuilder = (parameters = DEFAULT_PROTOCOL_PARAMETERS) => {
+    const txBuilderConfig = csl.TransactionBuilderConfigBuilder.new()
+        .coins_per_utxo_byte(csl.BigNum.from_str(parameters.coinsPerUTxOSize))
+        .ex_unit_prices(csl.ExUnitPrices.new(toUnitInterval(parameters.priceMem.toString()), toUnitInterval(parameters.priceStep.toString())))
+        .fee_algo(csl.LinearFee.new(csl.BigNum.from_str(parameters.minFeeA.toString()), csl.BigNum.from_str(parameters.minFeeB.toString())))
+        .key_deposit(csl.BigNum.from_str(parameters.keyDeposit))
+        .max_tx_size(parameters.maxTxSize)
+        .max_value_size(parseInt(parameters.maxValSize, 10))
+        .pool_deposit(csl.BigNum.from_str(parameters.poolDeposit))
+        .build();
+    return csl.TransactionBuilder.new(txBuilderConfig);
+};
+export const buildTxInputsBuilder = (utxos) => {
+    const txInputsBuilder = csl.TxInputsBuilder.new();
+    utxos
+        .map((utxo) => utxo instanceof csl.TransactionUnspentOutput
+        ? utxo
+        : toTxUnspentOutput(utxo))
+        .forEach((utxo) => {
+        txInputsBuilder.add_input(utxo.output().address(), utxo.input(), utxo.output().amount());
+    });
+    return txInputsBuilder;
+};
+export const buildTxOutputBuilder = (recipient) => {
+    if (typeof recipient === 'string') {
+        return csl.TransactionOutputBuilder.new().with_address(toAddress(recipient));
+    }
+    let txOutputBuilder = csl.TransactionOutputBuilder.new().with_address(toAddress(recipient.address));
+    if (recipient.datum) {
+        const { value, inline } = recipient.datum;
+        const plutusData = toPlutusData(value);
+        txOutputBuilder = txOutputBuilder.with_data_hash(csl.hash_plutus_data(plutusData));
+        if (inline) {
+            txOutputBuilder = txOutputBuilder.with_plutus_data(plutusData);
+        }
+    }
+    if (recipient.script) {
+        const reference = toScriptRef(recipient.script);
+        txOutputBuilder = txOutputBuilder.with_script_ref(reference);
+    }
+    return txOutputBuilder;
+};

package/dist/mjs/deser/constants.d.ts

@@ -0,0 +1,12 @@
+import { csl } from './csl';
+export declare const LANGUAGE_VERSIONS: {
+    V1: csl.Language;
+    V2: csl.Language;
+};
+export declare const REDEEMER_TAGS: {
+    CERT: csl.RedeemerTag;
+    MINT: csl.RedeemerTag;
+    REWARD: csl.RedeemerTag;
+    SPEND: csl.RedeemerTag;
+};
+export declare const POLICY_ID_LENGTH = 56;

package/dist/mjs/deser/constants.js

@@ -0,0 +1,12 @@
+import { csl } from './csl';
+export const LANGUAGE_VERSIONS = {
+    V1: csl.Language.new_plutus_v1(),
+    V2: csl.Language.new_plutus_v2(),
+};
+export const REDEEMER_TAGS = {
+    CERT: csl.RedeemerTag.new_cert(),
+    MINT: csl.RedeemerTag.new_mint(),
+    REWARD: csl.RedeemerTag.new_reward(),
+    SPEND: csl.RedeemerTag.new_spend(),
+};
+export const POLICY_ID_LENGTH = 56;

package/dist/mjs/deser/converter.d.ts

@@ -0,0 +1,27 @@
+import type { Action, Asset, Data, NativeScript, PlutusScript, PoolParams, Relay, UTxO } from '@meshsdk/core';
+import { csl } from './csl';
+import { Value, PlutusData, ScriptRef, TransactionUnspentOutput } from './types';
+export declare const toAddress: (bech32: string) => csl.Address;
+export declare const toBaseAddress: (bech32: string) => csl.BaseAddress | undefined;
+export declare const toEnterpriseAddress: (bech32: string) => csl.EnterpriseAddress | undefined;
+export declare const toRewardAddress: (bech32: string) => csl.RewardAddress | undefined;
+export declare const fromBytes: (bytes: Uint8Array) => string;
+export declare const toBytes: (hex: string) => Uint8Array;
+export declare const fromLovelace: (lovelace: number) => number;
+export declare const toLovelace: (ada: number) => number;
+export declare const fromNativeScript: (script: csl.NativeScript) => NativeScript;
+export declare const toNativeScript: (script: NativeScript) => csl.NativeScript;
+export declare const fromPlutusData: (plutusData: PlutusData) => Data;
+export declare const toPlutusData: (data: Data) => csl.PlutusData;
+export declare const toPoolParams: (params: PoolParams) => never;
+export declare const toRedeemer: (action: Action) => csl.Redeemer;
+export declare const toRelay: (relay: Relay) => csl.Relay;
+export declare const fromScriptRef: (scriptRef: ScriptRef) => NativeScript | PlutusScript;
+export declare const toScriptRef: (script: PlutusScript | NativeScript) => csl.ScriptRef;
+export declare const fromTxUnspentOutput: (txUnspentOutput: TransactionUnspentOutput) => UTxO;
+export declare const toTxUnspentOutput: (utxo: UTxO) => csl.TransactionUnspentOutput;
+export declare const toUnitInterval: (float: string) => csl.UnitInterval;
+export declare const fromUTF8: (utf8: string) => string;
+export declare const toUTF8: (hex: string) => string;
+export declare const fromValue: (value: Value) => Asset[];
+export declare const toValue: (assets: Asset[]) => csl.Value;