@meshsdk/core-csl 1.6.0-alpha.1

package/README.md

@@ -0,0 +1,9 @@
+# mesh-csl
+
+It is a Typescript wrapper around [`sidan-csl-rs`](https://github.com/sidan-lab/sidan-csl-rs) to add user-friendliness and useful APIs for building Cardano off-chain transactions. The APIs in this package are mostly low-level, closely tied with `sidan-csl-rs`. This package also serves some new utils functions that are yet to be packaged into `@meshsdk/core`.
+
+## Install
+
+```sh
+yarn add @meshsdk/mesh-csl
+```

package/dist/cjs/core/builder.d.ts

@@ -0,0 +1,38 @@
+import type { BuilderData, Certificate, MeshTxBuilderBody, MintItem, Protocol, IMeshSerializer } from '@meshsdk/core';
+import { TransactionBuilder, csl } from '../deser';
+export declare const emptyTxBuilderBody: () => MeshTxBuilderBody;
+export declare class CSLSerializer implements IMeshSerializer {
+    txBuilder: TransactionBuilder;
+    protocolParams: Protocol;
+    meshTxBuilderBody: MeshTxBuilderBody;
+    constructor(protocolParams?: Protocol);
+    serializeTxBody(txBody: MeshTxBuilderBody, protocolParams?: Protocol): string;
+    addSigningKeys(txHex: string, signingKeys: string[]): string;
+    private addUtxosFrom;
+    private makePlutusScriptSource;
+    protected removeDuplicateInputs: () => void;
+    private addAllInputs;
+    private addTxIn;
+    private addScriptTxIn;
+    private addAllOutputs;
+    private addOutput;
+    private addAllCollaterals;
+    private addCollateral;
+    private addCollateralReturn;
+    private addAllReferenceInputs;
+    private addReferenceInput;
+    protected addAllMints: (mints: MintItem[]) => void;
+    private addPlutusMint;
+    private addNativeMint;
+    private decimalToFraction;
+    private toPoolParams;
+    private addCertificate;
+    protected addAllCertificates: (allCertificates: Certificate[]) => void;
+    protected addCostModels: () => void;
+    private addChange;
+    private addValidityRange;
+    private addAllRequiredSignatures;
+    private addAllMetadata;
+    protected castRawDataToJsonString: (rawData: object | string) => string;
+    protected castDataToPlutusData: ({ type, content }: BuilderData) => csl.PlutusData;
+}

package/dist/cjs/core/builder.js

@@ -0,0 +1,389 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSLSerializer = exports.emptyTxBuilderBody = void 0;
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const common_1 = require("@meshsdk/common");
+const utils_1 = require("../utils");
+const deser_1 = require("../deser");
+const emptyTxBuilderBody = () => ({
+    inputs: [],
+    outputs: [],
+    extraInputs: [],
+    selectionThreshold: 0,
+    collaterals: [],
+    requiredSignatures: [],
+    referenceInputs: [],
+    mints: [],
+    changeAddress: '',
+    metadata: [],
+    validityRange: {},
+    certificates: [],
+    signingKey: [],
+});
+exports.emptyTxBuilderBody = emptyTxBuilderBody;
+class CSLSerializer {
+    constructor(protocolParams) {
+        this.meshTxBuilderBody = (0, exports.emptyTxBuilderBody)();
+        this.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 === null || inputAmount === void 0 ? void 0 : 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 = (0, common_1.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);
+            });
+        };
+        this.makePlutusScriptSource = (scriptSourceInfo) => {
+            const scriptHash = deser_1.csl.ScriptHash.from_hex(scriptSourceInfo.spendingScriptHash);
+            const scriptRefInput = deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(scriptSourceInfo.txHash), scriptSourceInfo.txIndex);
+            const scriptSource = deser_1.csl.PlutusScriptSource.new_ref_input_with_lang_ver(scriptHash, scriptRefInput, deser_1.LANGUAGE_VERSIONS[scriptSourceInfo.version]);
+            return scriptSource;
+        };
+        // Below protected functions for completing tx building
+        this.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);
+                }
+            }
+        };
+        this.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;
+                }
+            }
+        };
+        this.addTxIn = (currentTxIn) => {
+            this.txBuilder.add_input(deser_1.csl.Address.from_bech32(currentTxIn.txIn.address), deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(currentTxIn.txIn.txHash), currentTxIn.txIn.txIndex), (0, deser_1.toValue)(currentTxIn.txIn.amount));
+        };
+        this.addScriptTxIn = ({ scriptTxIn, txIn, }) => {
+            let cslDatum;
+            const { datumSource, scriptSource, redeemer } = scriptTxIn;
+            if (datumSource.type === 'Provided') {
+                cslDatum = deser_1.csl.DatumSource.new(this.castDataToPlutusData(datumSource.data));
+            }
+            else {
+                const refTxIn = deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(datumSource.txHash), datumSource.txIndex);
+                cslDatum = deser_1.csl.DatumSource.new_ref_input(refTxIn);
+            }
+            let cslScript;
+            if (scriptSource.type === 'Inline') {
+                cslScript = this.makePlutusScriptSource(scriptSource.txInInfo);
+            }
+            else {
+                cslScript = deser_1.csl.PlutusScriptSource.new(deser_1.csl.PlutusScript.from_hex_with_version(scriptSource.script.code, deser_1.LANGUAGE_VERSIONS[scriptSource.script.version]));
+            }
+            const cslRedeemer = deser_1.csl.Redeemer.new(deser_1.csl.RedeemerTag.new_spend(), deser_1.csl.BigNum.from_str('0'), this.castDataToPlutusData(redeemer.data), deser_1.csl.ExUnits.new(deser_1.csl.BigNum.from_str(String(redeemer.exUnits.mem)), deser_1.csl.BigNum.from_str(String(redeemer.exUnits.steps))));
+            this.txBuilder.add_plutus_script_input(deser_1.csl.PlutusWitness.new_with_ref(cslScript, cslDatum, cslRedeemer), deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(txIn.txHash), txIn.txIndex), (0, deser_1.toValue)(txIn.amount));
+        };
+        this.addAllOutputs = (outputs) => {
+            for (let i = 0; i < outputs.length; i += 1) {
+                const currentOutput = outputs[i];
+                this.addOutput(currentOutput);
+            }
+        };
+        this.addOutput = ({ amount, address, datum, referenceScript }) => {
+            const txValue = (0, deser_1.toValue)(amount);
+            const multiAsset = txValue.multiasset();
+            if (txValue.is_zero() && multiAsset === undefined)
+                throw Error('Invalid output amount');
+            let outputBuilder = deser_1.csl.TransactionOutputBuilder.new().with_address((0, deser_1.toAddress)(address));
+            if (datum && datum.type === 'Hash') {
+                outputBuilder = outputBuilder.with_data_hash(deser_1.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(deser_1.csl.ScriptRef.new_plutus_script(deser_1.csl.PlutusScript.from_hex_with_version(referenceScript.code, deser_1.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, (0, deser_1.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);
+            }
+        };
+        this.addAllCollaterals = (collaterals) => {
+            const collateralBuilder = deser_1.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);
+        };
+        this.addCollateral = (collateralBuilder, currentCollateral) => {
+            collateralBuilder.add_input(deser_1.csl.Address.from_bech32(currentCollateral.txIn.address), deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(currentCollateral.txIn.txHash), currentCollateral.txIn.txIndex), (0, deser_1.toValue)(currentCollateral.txIn.amount));
+        };
+        this.addCollateralReturn = (returnAddress) => {
+            var _a;
+            const currentFee = (_a = this.txBuilder.get_fee_if_set()) === null || _a === void 0 ? void 0 : _a.to_js_value();
+            if (currentFee) {
+                const collateralAmount = Math.ceil((this.protocolParams.collateralPercent * Number(currentFee)) / 100);
+                this.txBuilder.set_total_collateral_and_return(deser_1.csl.BigNum.from_str(String(collateralAmount)), deser_1.csl.Address.from_bech32(returnAddress));
+            }
+        };
+        this.addAllReferenceInputs = (refInputs) => {
+            refInputs.forEach((refInput) => {
+                this.addReferenceInput(refInput);
+            });
+        };
+        this.addReferenceInput = ({ txHash, txIndex }) => {
+            const refInput = deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(txHash), txIndex);
+            this.txBuilder.add_reference_input(refInput);
+        };
+        this.addAllMints = (mints) => {
+            const mintBuilder = deser_1.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);
+        };
+        this.addPlutusMint = (mintBuilder, { redeemer, policyId, scriptSource, assetName, amount }, redeemerIndex) => {
+            const newRedeemer = deser_1.csl.Redeemer.new(deser_1.csl.RedeemerTag.new_mint(), deser_1.csl.BigNum.from_str(String(redeemerIndex)), this.castDataToPlutusData(redeemer.data), deser_1.csl.ExUnits.new(deser_1.csl.BigNum.from_str(String(redeemer.exUnits.mem)), deser_1.csl.BigNum.from_str(String(redeemer.exUnits.steps))));
+            const script = scriptSource.type === 'Reference Script'
+                ? deser_1.csl.PlutusScriptSource.new_ref_input_with_lang_ver(deser_1.csl.ScriptHash.from_hex(policyId), deser_1.csl.TransactionInput.new(deser_1.csl.TransactionHash.from_hex(scriptSource.txHash), scriptSource.txIndex), deser_1.LANGUAGE_VERSIONS[scriptSource.version])
+                : deser_1.csl.PlutusScriptSource.new(deser_1.csl.PlutusScript.from_hex_with_version(scriptSource.script.code, deser_1.LANGUAGE_VERSIONS[scriptSource.script.version]));
+            mintBuilder.add_asset(deser_1.csl.MintWitness.new_plutus_script(script, newRedeemer), deser_1.csl.AssetName.new(Buffer.from(assetName, 'hex')), deser_1.csl.Int.from_str(amount));
+        };
+        this.addNativeMint = (mintBuilder, { scriptSource, assetName, amount }) => {
+            if (scriptSource.type === 'Reference Script')
+                throw Error('Native mint cannot have reference script');
+            mintBuilder.add_asset(deser_1.csl.MintWitness.new_native_script(deser_1.csl.NativeScript.from_hex(scriptSource.script.code)), deser_1.csl.AssetName.new(Buffer.from(assetName, 'hex')), deser_1.csl.Int.from_str(amount));
+        };
+        this.toPoolParams = (poolParams) => {
+            const marginFraction = this.decimalToFraction(poolParams.margin);
+            const relays = deser_1.csl.Relays.new();
+            poolParams.relays.forEach((relay) => {
+                relays.add((0, deser_1.toRelay)(relay));
+            });
+            const rewardAddress = deser_1.csl.RewardAddress.from_address(deser_1.csl.Address.from_bech32(poolParams.rewardAddress));
+            if (rewardAddress === undefined) {
+                throw new Error('Reward address is invalid');
+            }
+            const poolOwners = deser_1.csl.Ed25519KeyHashes.new();
+            poolParams.owners.forEach((owner) => {
+                poolOwners.add(deser_1.csl.Ed25519KeyHash.from_hex(owner));
+            });
+            return deser_1.csl.PoolParams.new(deser_1.csl.Ed25519KeyHash.from_hex(poolParams.operator), deser_1.csl.VRFKeyHash.from_hex(poolParams.VRFKeyHash), deser_1.csl.BigNum.from_str(poolParams.pledge), deser_1.csl.BigNum.from_str(poolParams.cost), deser_1.csl.UnitInterval.new(deser_1.csl.BigNum.from_str(marginFraction[0].toString()), deser_1.csl.BigNum.from_str(marginFraction[1].toString())), rewardAddress, poolOwners, relays, poolParams.metadata
+                ? deser_1.csl.PoolMetadata.from_json(json_bigint_1.default.stringify(poolParams.metadata))
+                : undefined);
+        };
+        this.addCertificate = (certificates, cert) => {
+            switch (cert.type) {
+                case 'RegisterPool':
+                    certificates.add(deser_1.csl.Certificate.new_pool_registration(deser_1.csl.PoolRegistration.new(this.toPoolParams(cert.poolParams))));
+                    break;
+                case 'RegisterStake':
+                    certificates.add(deser_1.csl.Certificate.new_stake_registration(deser_1.csl.StakeRegistration.new(deser_1.csl.StakeCredential.from_keyhash(deser_1.csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)))));
+                    break;
+                case 'DelegateStake':
+                    certificates.add(deser_1.csl.Certificate.new_stake_delegation(deser_1.csl.StakeDelegation.new(deser_1.csl.StakeCredential.from_keyhash(deser_1.csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)), cert.poolId.startsWith('pool')
+                        ? deser_1.csl.Ed25519KeyHash.from_bech32(cert.poolId)
+                        : deser_1.csl.Ed25519KeyHash.from_hex(cert.poolId))));
+                    break;
+                case 'DeregisterStake':
+                    certificates.add(deser_1.csl.Certificate.new_stake_deregistration(deser_1.csl.StakeDeregistration.new(deser_1.csl.StakeCredential.from_keyhash(deser_1.csl.Ed25519KeyHash.from_hex(cert.stakeKeyHash)))));
+                    break;
+                case 'RetirePool':
+                    certificates.add(deser_1.csl.Certificate.new_pool_retirement(deser_1.csl.PoolRetirement.new(cert.poolId.startsWith('pool')
+                        ? deser_1.csl.Ed25519KeyHash.from_bech32(cert.poolId)
+                        : deser_1.csl.Ed25519KeyHash.from_hex(cert.poolId), cert.epoch)));
+            }
+        };
+        this.addAllCertificates = (allCertificates) => {
+            const certificates = deser_1.csl.Certificates.new();
+            allCertificates.forEach((cert) => {
+                this.addCertificate(certificates, cert);
+            });
+            this.txBuilder.set_certs(certificates);
+        };
+        this.addCostModels = () => {
+            this.txBuilder.calc_script_data_hash(deser_1.csl.TxBuilderConstants.plutus_vasil_cost_models());
+        };
+        this.addChange = (changeAddress) => {
+            this.txBuilder.add_change_if_needed(deser_1.csl.Address.from_bech32(changeAddress));
+        };
+        this.addValidityRange = ({ invalidBefore, invalidHereafter }) => {
+            if (invalidBefore) {
+                this.txBuilder.set_validity_start_interval_bignum(deser_1.csl.BigNum.from_str(invalidBefore.toString()));
+            }
+            if (invalidHereafter) {
+                this.txBuilder.set_ttl_bignum(deser_1.csl.BigNum.from_str(invalidHereafter.toString()));
+            }
+        };
+        this.addAllRequiredSignatures = (requiredSignatures) => {
+            requiredSignatures.forEach((pubKeyHash) => {
+                this.txBuilder.add_required_signer(deser_1.csl.Ed25519KeyHash.from_hex(pubKeyHash));
+            });
+        };
+        this.addAllMetadata = (allMetadata) => {
+            allMetadata.forEach(({ tag, metadata }) => {
+                this.txBuilder.add_json_metadatum(deser_1.csl.BigNum.from_str(tag), json_bigint_1.default.stringify(metadata));
+            });
+        };
+        this.castRawDataToJsonString = (rawData) => {
+            if (typeof rawData === 'object') {
+                return json_bigint_1.default.stringify(rawData);
+            }
+            return rawData;
+        };
+        this.castDataToPlutusData = ({ type, content }) => {
+            if (type === 'Mesh') {
+                return (0, deser_1.toPlutusData)(content);
+            }
+            if (type === 'CBOR') {
+                return deser_1.csl.PlutusData.from_hex(content);
+            }
+            return deser_1.csl.PlutusData.from_json(content, deser_1.csl.PlutusDatumSchema.DetailedSchema);
+        };
+        this.protocolParams = protocolParams || common_1.DEFAULT_PROTOCOL_PARAMETERS;
+        this.txBuilder = (0, deser_1.buildTxBuilder)(protocolParams);
+    }
+    serializeTxBody(txBody, protocolParams) {
+        if (protocolParams) {
+            this.protocolParams = protocolParams;
+        }
+        this.txBuilder = (0, deser_1.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) => {
+                var _a, _b;
+                return ((_b = (_a = collateral.txIn.amount) === null || _a === void 0 ? void 0 : _a.find((asset) => asset.unit === 'lovelace')) === null || _b === void 0 ? void 0 : _b.quantity) || '0';
+            })
+                .reduce((acc, curr) => acc + parseInt(curr), 0);
+            const collateralEstimate = Math.ceil((this.protocolParams.collateralPercent *
+                Number(Number(this.txBuilder
+                    .min_fee()
+                    .checked_add(deser_1.csl.BigNum.from_str('10000'))
+                    .to_js_value()))) /
+                100);
+            let collateralReturnNeeded = false;
+            if (totalCollateral - collateralEstimate > 0) {
+                const collateralEstimateOutput = deser_1.csl.TransactionOutput.new(deser_1.csl.Address.from_bech32(changeAddress), deser_1.csl.Value.new(deser_1.csl.BigNum.from_str(String(collateralEstimate))));
+                if (totalCollateral - collateralEstimate >
+                    Number(deser_1.csl
+                        .min_ada_for_output(collateralEstimateOutput, deser_1.csl.DataCost.new_coins_per_byte(deser_1.csl.BigNum.from_str(this.protocolParams.coinsPerUTxOSize)))
+                        .to_js_value())) {
+                    this.txBuilder.set_collateral_return(deser_1.csl.TransactionOutput.new(deser_1.csl.Address.from_bech32(changeAddress), deser_1.csl.Value.new(deser_1.csl.BigNum.from_str(String(totalCollateral)))));
+                    this.txBuilder.set_total_collateral(deser_1.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 (0, utils_1.signTransaction)(txHex, signingKeys);
+        }
+        return txHex;
+    }
+    decimalToFraction(decimal) {
+        const powerOf10 = Math.pow(10, decimal.toString().split('.')[1].length);
+        const numerator = decimal * powerOf10;
+        const denominator = powerOf10;
+        return [numerator, denominator];
+    }
+}
+exports.CSLSerializer = CSLSerializer;

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

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

package/dist/cjs/core/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./builder"), exports);

package/dist/cjs/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/cjs/deser/builder.js

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

package/dist/cjs/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/cjs/deser/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICY_ID_LENGTH = exports.REDEEMER_TAGS = exports.LANGUAGE_VERSIONS = void 0;
+const csl_1 = require("./csl");
+exports.LANGUAGE_VERSIONS = {
+    V1: csl_1.csl.Language.new_plutus_v1(),
+    V2: csl_1.csl.Language.new_plutus_v2(),
+};
+exports.REDEEMER_TAGS = {
+    CERT: csl_1.csl.RedeemerTag.new_cert(),
+    MINT: csl_1.csl.RedeemerTag.new_mint(),
+    REWARD: csl_1.csl.RedeemerTag.new_reward(),
+    SPEND: csl_1.csl.RedeemerTag.new_spend(),
+};
+exports.POLICY_ID_LENGTH = 56;