@meshsdk/core-csl 1.6.0-alpha.1

package/dist/cjs/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;

package/dist/cjs/deser/converter.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toValue = exports.fromValue = exports.toUTF8 = exports.fromUTF8 = exports.toUnitInterval = exports.toTxUnspentOutput = exports.fromTxUnspentOutput = exports.toScriptRef = exports.fromScriptRef = exports.toRelay = exports.toRedeemer = exports.toPoolParams = exports.toPlutusData = exports.fromPlutusData = exports.toNativeScript = exports.fromNativeScript = exports.toLovelace = exports.fromLovelace = exports.toBytes = exports.fromBytes = exports.toRewardAddress = exports.toEnterpriseAddress = exports.toBaseAddress = exports.toAddress = void 0;
+// import { POLICY_ID_LENGTH } from '@meshsdk/core';
+const csl_1 = require("./csl");
+const constants_1 = require("./constants");
+const deserializer_1 = require("./deserializer");
+/* -----------------[ Address ]----------------- */
+const toAddress = (bech32) => csl_1.csl.Address.from_bech32(bech32);
+exports.toAddress = toAddress;
+const toBaseAddress = (bech32) => csl_1.csl.BaseAddress.from_address((0, exports.toAddress)(bech32));
+exports.toBaseAddress = toBaseAddress;
+const toEnterpriseAddress = (bech32) => csl_1.csl.EnterpriseAddress.from_address((0, exports.toAddress)(bech32));
+exports.toEnterpriseAddress = toEnterpriseAddress;
+const toRewardAddress = (bech32) => csl_1.csl.RewardAddress.from_address((0, exports.toAddress)(bech32));
+exports.toRewardAddress = toRewardAddress;
+/* -----------------[ Bytes ]----------------- */
+const fromBytes = (bytes) => Buffer.from(bytes).toString('hex');
+exports.fromBytes = fromBytes;
+const toBytes = (hex) => {
+    if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex))
+        return Buffer.from(hex, 'hex');
+    return Buffer.from(hex, 'utf-8');
+};
+exports.toBytes = toBytes;
+/* -----------------[ Lovelace ]----------------- */
+const fromLovelace = (lovelace) => lovelace / 1000000;
+exports.fromLovelace = fromLovelace;
+const toLovelace = (ada) => ada * 1000000;
+exports.toLovelace = toLovelace;
+/* -----------------[ NativeScript ]----------------- */
+const fromNativeScript = (script) => {
+    const fromNativeScripts = (scripts) => {
+        const nativeScripts = new Array();
+        for (let index = 0; index < scripts.len(); index += 1) {
+            nativeScripts.push((0, exports.fromNativeScript)(scripts.get(index)));
+        }
+        return nativeScripts;
+    };
+    switch (script.kind()) {
+        case csl_1.csl.NativeScriptKind.ScriptAll: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const scriptAll = script.as_script_all();
+            return {
+                type: 'all',
+                scripts: fromNativeScripts(scriptAll.native_scripts()),
+            };
+        }
+        case csl_1.csl.NativeScriptKind.ScriptAny: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const scriptAny = script.as_script_any();
+            return {
+                type: 'any',
+                scripts: fromNativeScripts(scriptAny.native_scripts()),
+            };
+        }
+        case csl_1.csl.NativeScriptKind.ScriptNOfK: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const scriptNOfK = script.as_script_n_of_k();
+            return {
+                type: 'atLeast',
+                required: scriptNOfK.n(),
+                scripts: fromNativeScripts(scriptNOfK.native_scripts()),
+            };
+        }
+        case csl_1.csl.NativeScriptKind.TimelockStart: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const timelockStart = script.as_timelock_start();
+            return {
+                type: 'after',
+                slot: timelockStart.slot_bignum().to_str(),
+            };
+        }
+        case csl_1.csl.NativeScriptKind.TimelockExpiry: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const timelockExpiry = script.as_timelock_expiry();
+            return {
+                type: 'before',
+                slot: timelockExpiry.slot_bignum().to_str(),
+            };
+        }
+        case csl_1.csl.NativeScriptKind.ScriptPubkey: {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const scriptPubkey = script.as_script_pubkey();
+            return {
+                type: 'sig',
+                keyHash: scriptPubkey.addr_keyhash().to_hex(),
+            };
+        }
+        default:
+            throw new Error(`Script Kind: ${script.kind()}, is not supported`);
+    }
+};
+exports.fromNativeScript = fromNativeScript;
+const toNativeScript = (script) => {
+    const toNativeScripts = (scripts) => {
+        const nativeScripts = csl_1.csl.NativeScripts.new();
+        scripts.forEach((scriptItem) => {
+            nativeScripts.add((0, exports.toNativeScript)(scriptItem));
+        });
+        return nativeScripts;
+    };
+    switch (script.type) {
+        case 'all':
+            return csl_1.csl.NativeScript.new_script_all(csl_1.csl.ScriptAll.new(toNativeScripts(script.scripts)));
+        case 'any':
+            return csl_1.csl.NativeScript.new_script_any(csl_1.csl.ScriptAny.new(toNativeScripts(script.scripts)));
+        case 'atLeast':
+            return csl_1.csl.NativeScript.new_script_n_of_k(csl_1.csl.ScriptNOfK.new(script.required, toNativeScripts(script.scripts)));
+        case 'after':
+            return csl_1.csl.NativeScript.new_timelock_start(csl_1.csl.TimelockStart.new_timelockstart(csl_1.csl.BigNum.from_str(script.slot)));
+        case 'before':
+            return csl_1.csl.NativeScript.new_timelock_expiry(csl_1.csl.TimelockExpiry.new_timelockexpiry(csl_1.csl.BigNum.from_str(script.slot)));
+        case 'sig':
+            return csl_1.csl.NativeScript.new_script_pubkey(csl_1.csl.ScriptPubkey.new((0, deserializer_1.deserializeEd25519KeyHash)(script.keyHash)));
+    }
+};
+exports.toNativeScript = toNativeScript;
+/* -----------------[ PlutusData ]----------------- */
+const fromPlutusData = (plutusData) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const fromPlutusList = (plutusList) => {
+        const dataList = [];
+        for (let index = 0; index < plutusList.len(); index += 1) {
+            dataList.push((0, exports.fromPlutusData)(plutusList.get(index)));
+        }
+        return dataList;
+    };
+    const fromPlutusMap = (plutusMap) => {
+        var _a;
+        const dataMap = new Map();
+        for (let index = 0; index < plutusMap.len(); index += 1) {
+            const key = plutusMap.keys().get(index);
+            const value = (_a = plutusMap.get(key)) !== null && _a !== void 0 ? _a : csl_1.csl.PlutusData.from_hex((0, exports.fromUTF8)('NO_ITEM_FOUND_INSIDE_GOLD_ROOM'));
+            dataMap.set((0, exports.fromPlutusData)(key), (0, exports.fromPlutusData)(value));
+        }
+        return dataMap;
+    };
+    switch (plutusData.kind()) {
+        case csl_1.csl.PlutusDataKind.Bytes:
+            return (0, exports.fromBytes)((_a = plutusData.as_bytes()) !== null && _a !== void 0 ? _a : new Uint8Array());
+        case csl_1.csl.PlutusDataKind.Integer:
+            return parseInt((_c = (_b = plutusData.as_integer()) === null || _b === void 0 ? void 0 : _b.to_str()) !== null && _c !== void 0 ? _c : '0', 10);
+        case csl_1.csl.PlutusDataKind.List:
+            return fromPlutusList((_d = plutusData.as_list()) !== null && _d !== void 0 ? _d : csl_1.csl.PlutusList.new());
+        case csl_1.csl.PlutusDataKind.Map:
+            return fromPlutusMap((_e = plutusData.as_map()) !== null && _e !== void 0 ? _e : csl_1.csl.PlutusMap.new());
+        case csl_1.csl.PlutusDataKind.ConstrPlutusData:
+            return {
+                alternative: parseInt((_g = (_f = plutusData.as_constr_plutus_data()) === null || _f === void 0 ? void 0 : _f.alternative().to_str()) !== null && _g !== void 0 ? _g : '0', 10),
+                fields: fromPlutusList((_j = (_h = plutusData.as_constr_plutus_data()) === null || _h === void 0 ? void 0 : _h.data()) !== null && _j !== void 0 ? _j : csl_1.csl.PlutusList.new()),
+            };
+        default:
+            throw new Error(`PlutusData Kind: ${plutusData.kind()}, is not supported`);
+    }
+};
+exports.fromPlutusData = fromPlutusData;
+const toPlutusData = (data) => {
+    const toPlutusList = (dataArray) => {
+        const plutusList = csl_1.csl.PlutusList.new();
+        dataArray.forEach((element) => {
+            plutusList.add((0, exports.toPlutusData)(element));
+        });
+        return plutusList;
+    };
+    switch (typeof data) {
+        case 'string':
+            return csl_1.csl.PlutusData.new_bytes((0, exports.toBytes)(data));
+        case 'number':
+            return csl_1.csl.PlutusData.new_integer(csl_1.csl.BigInt.from_str(data.toString()));
+        case 'bigint':
+            return csl_1.csl.PlutusData.new_integer(csl_1.csl.BigInt.from_str(data.toString()));
+        case 'object':
+            if (data instanceof Array) {
+                const plutusList = toPlutusList(data);
+                return csl_1.csl.PlutusData.new_list(plutusList);
+            }
+            if (data instanceof Map) {
+                const plutusMap = csl_1.csl.PlutusMap.new();
+                data.forEach((value, key) => {
+                    plutusMap.insert((0, exports.toPlutusData)(key), (0, exports.toPlutusData)(value));
+                });
+                return csl_1.csl.PlutusData.new_map(plutusMap);
+            }
+            return csl_1.csl.PlutusData.new_constr_plutus_data(csl_1.csl.ConstrPlutusData.new(csl_1.csl.BigNum.from_str(data.alternative.toString()), toPlutusList(data.fields)));
+    }
+};
+exports.toPlutusData = toPlutusData;
+/* -----------------[ PoolParams ]----------------- */
+const toPoolParams = (params) => {
+    const relays = csl_1.csl.Relays.new();
+    params.relays.forEach((relay) => {
+        relays.add((0, exports.toRelay)(relay));
+    });
+    throw new Error('toPoolParams not implemented.');
+};
+exports.toPoolParams = toPoolParams;
+/* -----------------[ Redeemer ]----------------- */
+const toRedeemer = (action) => {
+    const lookupRedeemerTag = (key) => constants_1.REDEEMER_TAGS[key];
+    return csl_1.csl.Redeemer.new(lookupRedeemerTag(action.tag), csl_1.csl.BigNum.from_str(action.index.toString()), (0, exports.toPlutusData)(action.data), csl_1.csl.ExUnits.new(csl_1.csl.BigNum.from_str(action.budget.mem.toString()), csl_1.csl.BigNum.from_str(action.budget.steps.toString())));
+};
+exports.toRedeemer = toRedeemer;
+/* -----------------[ Relay ]----------------- */
+const toRelay = (relay) => {
+    switch (relay.type) {
+        case 'SingleHostAddr': {
+            const IPV4 = relay.IPV4
+                ? csl_1.csl.Ipv4.new(new Uint8Array(relay.IPV4.split('.').map((b) => parseInt(b))))
+                : undefined;
+            const IPV6 = relay.IPV6
+                ? csl_1.csl.Ipv6.new((0, exports.toBytes)(relay.IPV6.replaceAll(':', '')))
+                : undefined;
+            return csl_1.csl.Relay.new_single_host_addr(csl_1.csl.SingleHostAddr.new(relay.port, IPV4, IPV6));
+        }
+        case 'SingleHostName':
+            return csl_1.csl.Relay.new_single_host_name(csl_1.csl.SingleHostName.new(relay.port, csl_1.csl.DNSRecordAorAAAA.new(relay.domainName)));
+        case 'MultiHostName':
+            return csl_1.csl.Relay.new_multi_host_name(csl_1.csl.MultiHostName.new(csl_1.csl.DNSRecordSRV.new(relay.domainName)));
+    }
+};
+exports.toRelay = toRelay;
+/* -----------------[ ScriptRef ]----------------- */
+const fromScriptRef = (scriptRef) => {
+    if (scriptRef.is_plutus_script()) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const plutusScript = scriptRef.plutus_script();
+        return {
+            code: plutusScript.to_hex(),
+            version: Object.keys(constants_1.LANGUAGE_VERSIONS).find((key) => constants_1.LANGUAGE_VERSIONS[key].to_hex() ===
+                plutusScript.language_version().to_hex()),
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const nativeScript = scriptRef.native_script();
+    return (0, exports.fromNativeScript)(nativeScript);
+};
+exports.fromScriptRef = fromScriptRef;
+const toScriptRef = (script) => {
+    if ('code' in script) {
+        const plutusScript = (0, deserializer_1.deserializePlutusScript)(script.code, script.version);
+        return csl_1.csl.ScriptRef.new_plutus_script(plutusScript);
+    }
+    return csl_1.csl.ScriptRef.new_native_script((0, exports.toNativeScript)(script));
+};
+exports.toScriptRef = toScriptRef;
+/* -----------------[ TransactionUnspentOutput ]----------------- */
+const fromTxUnspentOutput = (txUnspentOutput) => {
+    var _a, _b, _c;
+    const dataHash = txUnspentOutput.output().has_data_hash()
+        ? (_a = txUnspentOutput.output().data_hash()) === null || _a === void 0 ? void 0 : _a.to_hex()
+        : undefined;
+    const plutusData = txUnspentOutput.output().has_plutus_data()
+        ? (_b = txUnspentOutput.output().plutus_data()) === null || _b === void 0 ? void 0 : _b.to_hex()
+        : undefined;
+    const scriptRef = txUnspentOutput.output().has_script_ref()
+        ? (_c = txUnspentOutput.output().script_ref()) === null || _c === void 0 ? void 0 : _c.to_hex()
+        : undefined;
+    return {
+        input: {
+            outputIndex: txUnspentOutput.input().index(),
+            txHash: txUnspentOutput.input().transaction_id().to_hex(),
+        },
+        output: {
+            address: txUnspentOutput.output().address().to_bech32(),
+            amount: (0, exports.fromValue)(txUnspentOutput.output().amount()),
+            dataHash,
+            plutusData,
+            scriptRef,
+        },
+    };
+};
+exports.fromTxUnspentOutput = fromTxUnspentOutput;
+const toTxUnspentOutput = (utxo) => {
+    const txInput = csl_1.csl.TransactionInput.new((0, deserializer_1.deserializeTxHash)(utxo.input.txHash), utxo.input.outputIndex);
+    const txOutput = csl_1.csl.TransactionOutput.new((0, exports.toAddress)(utxo.output.address), (0, exports.toValue)(utxo.output.amount));
+    if (utxo.output.dataHash !== undefined) {
+        txOutput.set_data_hash((0, deserializer_1.deserializeDataHash)(utxo.output.dataHash));
+    }
+    if (utxo.output.plutusData !== undefined) {
+        txOutput.set_plutus_data((0, deserializer_1.deserializePlutusData)(utxo.output.plutusData));
+    }
+    if (utxo.output.scriptRef !== undefined) {
+        txOutput.set_script_ref((0, deserializer_1.deserializeScriptRef)(utxo.output.scriptRef));
+    }
+    return csl_1.csl.TransactionUnspentOutput.new(txInput, txOutput);
+};
+exports.toTxUnspentOutput = toTxUnspentOutput;
+/* -----------------[ UnitInterval ]----------------- */
+const toUnitInterval = (float) => {
+    var _a;
+    const decimal = (_a = float.split('.')[1]) !== null && _a !== void 0 ? _a : '0';
+    const numerator = `${parseInt(decimal, 10)}`;
+    const denominator = `1${'0'.repeat(decimal.length)}`;
+    return csl_1.csl.UnitInterval.new(csl_1.csl.BigNum.from_str(numerator), csl_1.csl.BigNum.from_str(denominator));
+};
+exports.toUnitInterval = toUnitInterval;
+/* -----------------[ UTF-8 ]----------------- */
+const fromUTF8 = (utf8) => {
+    if (utf8.length % 2 === 0 && /^[0-9A-F]*$/i.test(utf8))
+        return utf8;
+    return (0, exports.fromBytes)(Buffer.from(utf8, 'utf-8'));
+};
+exports.fromUTF8 = fromUTF8;
+const toUTF8 = (hex) => Buffer.from(hex, 'hex').toString('utf-8');
+exports.toUTF8 = toUTF8;
+/* -----------------[ Value ]----------------- */
+const fromValue = (value) => {
+    var _a;
+    const assets = [{ unit: 'lovelace', quantity: value.coin().to_str() }];
+    const multiAsset = value.multiasset();
+    if (multiAsset !== undefined) {
+        const policies = multiAsset.keys();
+        for (let i = 0; i < policies.len(); i += 1) {
+            const policyId = policies.get(i);
+            const policyAssets = multiAsset.get(policyId);
+            if (policyAssets !== undefined) {
+                const policyAssetNames = policyAssets.keys();
+                for (let j = 0; j < policyAssetNames.len(); j += 1) {
+                    const assetName = policyAssetNames.get(j);
+                    const quantity = (_a = policyAssets.get(assetName)) !== null && _a !== void 0 ? _a : csl_1.csl.BigNum.from_str('0');
+                    const assetId = policyId.to_hex() + (0, exports.fromBytes)(assetName.name());
+                    assets.push({ unit: assetId, quantity: quantity.to_str() });
+                }
+            }
+        }
+    }
+    return assets;
+};
+exports.fromValue = fromValue;
+const toValue = (assets) => {
+    const lovelace = assets.find((asset) => asset.unit === 'lovelace');
+    const policies = Array.from(new Set(assets
+        .filter((asset) => asset.unit !== 'lovelace')
+        .map((asset) => asset.unit.slice(0, constants_1.POLICY_ID_LENGTH))));
+    const multiAsset = csl_1.csl.MultiAsset.new();
+    policies.forEach((policyId) => {
+        const policyAssets = csl_1.csl.Assets.new();
+        assets
+            .filter((asset) => asset.unit.slice(0, constants_1.POLICY_ID_LENGTH) === policyId)
+            .forEach((asset) => {
+            policyAssets.insert(csl_1.csl.AssetName.new((0, exports.toBytes)(asset.unit.slice(constants_1.POLICY_ID_LENGTH))), csl_1.csl.BigNum.from_str(asset.quantity));
+        });
+        multiAsset.insert((0, deserializer_1.deserializeScriptHash)(policyId), policyAssets);
+    });
+    const value = csl_1.csl.Value.new(csl_1.csl.BigNum.from_str(lovelace ? lovelace.quantity : '0'));
+    if (assets.length > 1 || !lovelace) {
+        value.set_multiasset(multiAsset);
+    }
+    return value;
+};
+exports.toValue = toValue;

package/dist/cjs/deser/csl.d.ts

@@ -0,0 +1 @@
+export * as csl from '@sidan-lab/sidan-csl-rs-nodejs';

package/dist/cjs/deser/csl.js

@@ -0,0 +1,27 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csl = void 0;
+exports.csl = __importStar(require("@sidan-lab/sidan-csl-rs-nodejs"));

package/dist/cjs/deser/deserializer.d.ts

@@ -0,0 +1,19 @@
+import { LanguageVersion } from '@meshsdk/core';
+import { csl } from './csl';
+export declare const deserializeAddress: (address: string) => csl.Address;
+export declare const deserializeBip32PrivateKey: (bip32PrivateKey: string) => csl.Bip32PrivateKey;
+export declare const deserializeDataHash: (dataHash: string) => csl.DataHash;
+export declare const deserializeEd25519KeyHash: (ed25519KeyHash: string) => csl.Ed25519KeyHash;
+export declare const deserializeEd25519Signature: (ed25519Signature: string) => csl.Ed25519Signature;
+export declare const deserializeNativeScript: (nativeScript: string) => csl.NativeScript;
+export declare const deserializePublicKey: (publicKey: string) => csl.PublicKey;
+export declare const deserializePlutusData: (plutusData: string) => csl.PlutusData;
+export declare const deserializePlutusScript: (plutusScript: string, version: LanguageVersion) => csl.PlutusScript;
+export declare const deserializeScriptRef: (scriptRef: string) => csl.ScriptRef;
+export declare const deserializeScriptHash: (scriptHash: string) => csl.ScriptHash;
+export declare const deserializeTx: (tx: string) => csl.Transaction;
+export declare const deserializeTxBody: (txBody: string) => csl.TransactionBody;
+export declare const deserializeTxHash: (txHash: string) => csl.TransactionHash;
+export declare const deserializeTxUnspentOutput: (txUnspentOutput: string) => csl.TransactionUnspentOutput;
+export declare const deserializeTxWitnessSet: (txWitnessSet: string) => csl.TransactionWitnessSet;
+export declare const deserializeValue: (value: string) => csl.Value;

package/dist/cjs/deser/deserializer.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeValue = exports.deserializeTxWitnessSet = exports.deserializeTxUnspentOutput = exports.deserializeTxHash = exports.deserializeTxBody = exports.deserializeTx = exports.deserializeScriptHash = exports.deserializeScriptRef = exports.deserializePlutusScript = exports.deserializePlutusData = exports.deserializePublicKey = exports.deserializeNativeScript = exports.deserializeEd25519Signature = exports.deserializeEd25519KeyHash = exports.deserializeDataHash = exports.deserializeBip32PrivateKey = exports.deserializeAddress = void 0;
+const constants_1 = require("./constants");
+const csl_1 = require("./csl");
+const converter_1 = require("./converter");
+const deserializeAddress = (address) => csl_1.csl.Address.from_bytes((0, converter_1.toBytes)(address));
+exports.deserializeAddress = deserializeAddress;
+const deserializeBip32PrivateKey = (bip32PrivateKey) => csl_1.csl.Bip32PrivateKey.from_bytes((0, converter_1.toBytes)(bip32PrivateKey));
+exports.deserializeBip32PrivateKey = deserializeBip32PrivateKey;
+const deserializeDataHash = (dataHash) => csl_1.csl.DataHash.from_bytes((0, converter_1.toBytes)(dataHash));
+exports.deserializeDataHash = deserializeDataHash;
+const deserializeEd25519KeyHash = (ed25519KeyHash) => csl_1.csl.Ed25519KeyHash.from_bytes((0, converter_1.toBytes)(ed25519KeyHash));
+exports.deserializeEd25519KeyHash = deserializeEd25519KeyHash;
+const deserializeEd25519Signature = (ed25519Signature) => csl_1.csl.Ed25519Signature.from_bytes((0, converter_1.toBytes)(ed25519Signature));
+exports.deserializeEd25519Signature = deserializeEd25519Signature;
+const deserializeNativeScript = (nativeScript) => csl_1.csl.NativeScript.from_bytes((0, converter_1.toBytes)(nativeScript));
+exports.deserializeNativeScript = deserializeNativeScript;
+const deserializePublicKey = (publicKey) => csl_1.csl.PublicKey.from_bytes((0, converter_1.toBytes)(publicKey));
+exports.deserializePublicKey = deserializePublicKey;
+const deserializePlutusData = (plutusData) => csl_1.csl.PlutusData.from_bytes((0, converter_1.toBytes)(plutusData));
+exports.deserializePlutusData = deserializePlutusData;
+const deserializePlutusScript = (plutusScript, version) => csl_1.csl.PlutusScript.from_bytes_with_version((0, converter_1.toBytes)(plutusScript), constants_1.LANGUAGE_VERSIONS[version]);
+exports.deserializePlutusScript = deserializePlutusScript;
+const deserializeScriptRef = (scriptRef) => csl_1.csl.ScriptRef.from_bytes((0, converter_1.toBytes)(scriptRef));
+exports.deserializeScriptRef = deserializeScriptRef;
+const deserializeScriptHash = (scriptHash) => csl_1.csl.ScriptHash.from_bytes((0, converter_1.toBytes)(scriptHash));
+exports.deserializeScriptHash = deserializeScriptHash;
+const deserializeTx = (tx) => csl_1.csl.Transaction.from_bytes((0, converter_1.toBytes)(tx));
+exports.deserializeTx = deserializeTx;
+const deserializeTxBody = (txBody) => csl_1.csl.TransactionBody.from_bytes((0, converter_1.toBytes)(txBody));
+exports.deserializeTxBody = deserializeTxBody;
+const deserializeTxHash = (txHash) => csl_1.csl.TransactionHash.from_bytes((0, converter_1.toBytes)(txHash));
+exports.deserializeTxHash = deserializeTxHash;
+const deserializeTxUnspentOutput = (txUnspentOutput) => csl_1.csl.TransactionUnspentOutput.from_bytes((0, converter_1.toBytes)(txUnspentOutput));
+exports.deserializeTxUnspentOutput = deserializeTxUnspentOutput;
+const deserializeTxWitnessSet = (txWitnessSet) => csl_1.csl.TransactionWitnessSet.from_bytes((0, converter_1.toBytes)(txWitnessSet));
+exports.deserializeTxWitnessSet = deserializeTxWitnessSet;
+const deserializeValue = (value) => csl_1.csl.Value.from_bytes((0, converter_1.toBytes)(value));
+exports.deserializeValue = deserializeValue;

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

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './deserializer';
+export * from './converter';
+export * from './csl';
+export * from './constants';
+export * from './builder';

package/dist/cjs/deser/index.js

@@ -0,0 +1,22 @@
+"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("./types"), exports);
+__exportStar(require("./deserializer"), exports);
+__exportStar(require("./converter"), exports);
+__exportStar(require("./csl"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./builder"), exports);

package/dist/cjs/deser/types.d.ts

@@ -0,0 +1,146 @@
+import { csl } from './csl';
+export type Address = InstanceType<typeof csl.Address>;
+export type AssetName = InstanceType<typeof csl.AssetName>;
+export type AssetNames = InstanceType<typeof csl.AssetNames>;
+export type Assets = InstanceType<typeof csl.Assets>;
+export type AuxiliaryData = InstanceType<typeof csl.AuxiliaryData>;
+export type AuxiliaryDataHash = InstanceType<typeof csl.AuxiliaryDataHash>;
+export type AuxiliaryDataSet = InstanceType<typeof csl.AuxiliaryDataSet>;
+export type BaseAddress = InstanceType<typeof csl.BaseAddress>;
+export type BigInt = InstanceType<typeof csl.BigInt>;
+export type BigNum = InstanceType<typeof csl.BigNum>;
+export type Bip32PrivateKey = InstanceType<typeof csl.Bip32PrivateKey>;
+export type Bip32PublicKey = InstanceType<typeof csl.Bip32PublicKey>;
+export type Block = InstanceType<typeof csl.Block>;
+export type BlockHash = InstanceType<typeof csl.BlockHash>;
+export type BootstrapWitness = InstanceType<typeof csl.BootstrapWitness>;
+export type BootstrapWitnesses = InstanceType<typeof csl.BootstrapWitnesses>;
+export type ByronAddress = InstanceType<typeof csl.ByronAddress>;
+export type Certificate = InstanceType<typeof csl.Certificate>;
+export type Certificates = InstanceType<typeof csl.Certificates>;
+export type ConstrPlutusData = InstanceType<typeof csl.ConstrPlutusData>;
+export type CostModel = InstanceType<typeof csl.CostModel>;
+export type Costmdls = InstanceType<typeof csl.Costmdls>;
+export type DNSRecordAorAAAA = InstanceType<typeof csl.DNSRecordAorAAAA>;
+export type DNSRecordSRV = InstanceType<typeof csl.DNSRecordSRV>;
+export type DataCost = InstanceType<typeof csl.DataCost>;
+export type DataHash = InstanceType<typeof csl.DataHash>;
+export type DatumSource = InstanceType<typeof csl.DatumSource>;
+export type Ed25519KeyHash = InstanceType<typeof csl.Ed25519KeyHash>;
+export type Ed25519KeyHashes = InstanceType<typeof csl.Ed25519KeyHashes>;
+export type Ed25519Signature = InstanceType<typeof csl.Ed25519Signature>;
+export type EnterpriseAddress = InstanceType<typeof csl.EnterpriseAddress>;
+export type ExUnitPrices = InstanceType<typeof csl.ExUnitPrices>;
+export type ExUnits = InstanceType<typeof csl.ExUnits>;
+export type GeneralTransactionMetadata = InstanceType<typeof csl.GeneralTransactionMetadata>;
+export type GenesisDelegateHash = InstanceType<typeof csl.GenesisDelegateHash>;
+export type GenesisHash = InstanceType<typeof csl.GenesisHash>;
+export type GenesisHashes = InstanceType<typeof csl.GenesisHashes>;
+export type GenesisKeyDelegation = InstanceType<typeof csl.GenesisKeyDelegation>;
+export type Header = InstanceType<typeof csl.Header>;
+export type HeaderBody = InstanceType<typeof csl.HeaderBody>;
+export type Int = InstanceType<typeof csl.Int>;
+export type Ipv4 = InstanceType<typeof csl.Ipv4>;
+export type Ipv6 = InstanceType<typeof csl.Ipv6>;
+export type KESSignature = InstanceType<typeof csl.KESSignature>;
+export type KESVKey = InstanceType<typeof csl.KESVKey>;
+export type Language = InstanceType<typeof csl.Language>;
+export type Languages = InstanceType<typeof csl.Languages>;
+export type LegacyDaedalusPrivateKey = InstanceType<typeof csl.LegacyDaedalusPrivateKey>;
+export type LinearFee = InstanceType<typeof csl.LinearFee>;
+export type MIRToStakeCredentials = InstanceType<typeof csl.MIRToStakeCredentials>;
+export type MetadataList = InstanceType<typeof csl.MetadataList>;
+export type MetadataMap = InstanceType<typeof csl.MetadataMap>;
+export type Mint = InstanceType<typeof csl.Mint>;
+export type MintAssets = InstanceType<typeof csl.MintAssets>;
+export type MintBuilder = InstanceType<typeof csl.MintBuilder>;
+export type MintWitness = InstanceType<typeof csl.MintWitness>;
+export type MintsAssets = InstanceType<typeof csl.MintsAssets>;
+export type MoveInstantaneousReward = InstanceType<typeof csl.MoveInstantaneousReward>;
+export type MoveInstantaneousRewardsCert = InstanceType<typeof csl.MoveInstantaneousRewardsCert>;
+export type MultiAsset = InstanceType<typeof csl.MultiAsset>;
+export type MultiHostName = InstanceType<typeof csl.MultiHostName>;
+export type NativeScript = InstanceType<typeof csl.NativeScript>;
+export type NativeScripts = InstanceType<typeof csl.NativeScripts>;
+export type NetworkId = InstanceType<typeof csl.NetworkId>;
+export type NetworkInfo = InstanceType<typeof csl.NetworkInfo>;
+export type Nonce = InstanceType<typeof csl.Nonce>;
+export type OperationalCert = InstanceType<typeof csl.OperationalCert>;
+export type PlutusData = InstanceType<typeof csl.PlutusData>;
+export type PlutusList = InstanceType<typeof csl.PlutusList>;
+export type PlutusMap = InstanceType<typeof csl.PlutusMap>;
+export type PlutusScript = InstanceType<typeof csl.PlutusScript>;
+export type PlutusScripts = InstanceType<typeof csl.PlutusScripts>;
+export type PlutusScriptSource = InstanceType<typeof csl.PlutusScriptSource>;
+export type PlutusWitness = InstanceType<typeof csl.PlutusWitness>;
+export type PlutusWitnesses = InstanceType<typeof csl.PlutusWitnesses>;
+export type Pointer = InstanceType<typeof csl.Pointer>;
+export type PointerAddress = InstanceType<typeof csl.PointerAddress>;
+export type PoolMetadata = InstanceType<typeof csl.PoolMetadata>;
+export type PoolMetadataHash = InstanceType<typeof csl.PoolMetadataHash>;
+export type PoolParams = InstanceType<typeof csl.PoolParams>;
+export type PoolRegistration = InstanceType<typeof csl.PoolRegistration>;
+export type PoolRetirement = InstanceType<typeof csl.PoolRetirement>;
+export type PrivateKey = InstanceType<typeof csl.PrivateKey>;
+export type ProposedProtocolParameterUpdates = InstanceType<typeof csl.ProposedProtocolParameterUpdates>;
+export type ProtocolParamUpdate = InstanceType<typeof csl.ProtocolParamUpdate>;
+export type ProtocolVersion = InstanceType<typeof csl.ProtocolVersion>;
+export type PublicKey = InstanceType<typeof csl.PublicKey>;
+export type PublicKeys = InstanceType<typeof csl.PublicKeys>;
+export type Redeemer = InstanceType<typeof csl.Redeemer>;
+export type RedeemerTag = InstanceType<typeof csl.RedeemerTag>;
+export type Redeemers = InstanceType<typeof csl.Redeemers>;
+export type Relay = InstanceType<typeof csl.Relay>;
+export type Relays = InstanceType<typeof csl.Relays>;
+export type RewardAddress = InstanceType<typeof csl.RewardAddress>;
+export type RewardAddresses = InstanceType<typeof csl.RewardAddresses>;
+export type ScriptAll = InstanceType<typeof csl.ScriptAll>;
+export type ScriptAny = InstanceType<typeof csl.ScriptAny>;
+export type ScriptDataHash = InstanceType<typeof csl.ScriptDataHash>;
+export type ScriptHash = InstanceType<typeof csl.ScriptHash>;
+export type ScriptHashes = InstanceType<typeof csl.ScriptHashes>;
+export type ScriptNOfK = InstanceType<typeof csl.ScriptNOfK>;
+export type ScriptPubkey = InstanceType<typeof csl.ScriptPubkey>;
+export type ScriptRef = InstanceType<typeof csl.ScriptRef>;
+export type SingleHostAddr = InstanceType<typeof csl.SingleHostAddr>;
+export type SingleHostName = InstanceType<typeof csl.SingleHostName>;
+export type StakeCredential = InstanceType<typeof csl.StakeCredential>;
+export type StakeCredentials = InstanceType<typeof csl.StakeCredentials>;
+export type StakeDelegation = InstanceType<typeof csl.StakeDelegation>;
+export type StakeRegistration = InstanceType<typeof csl.StakeRegistration>;
+export type Strings = InstanceType<typeof csl.Strings>;
+export type TimelockExpiry = InstanceType<typeof csl.TimelockExpiry>;
+export type TimelockStart = InstanceType<typeof csl.TimelockStart>;
+export type Transaction = InstanceType<typeof csl.Transaction>;
+export type TransactionBodies = InstanceType<typeof csl.TransactionBodies>;
+export type TransactionBody = InstanceType<typeof csl.TransactionBody>;
+export type TransactionBuilder = InstanceType<typeof csl.TransactionBuilder>;
+export type TransactionBuilderConfig = InstanceType<typeof csl.TransactionBuilderConfig>;
+export type TransactionBuilderConfigBuilder = InstanceType<typeof csl.TransactionBuilderConfigBuilder>;
+export type TransactionHash = InstanceType<typeof csl.TransactionHash>;
+export type TransactionInput = InstanceType<typeof csl.TransactionInput>;
+export type TransactionInputs = InstanceType<typeof csl.TransactionInputs>;
+export type TransactionMetadatum = InstanceType<typeof csl.TransactionMetadatum>;
+export type TransactionMetadatumLabels = InstanceType<typeof csl.TransactionMetadatumLabels>;
+export type TransactionOutput = InstanceType<typeof csl.TransactionOutput>;
+export type TransactionOutputAmountBuilder = InstanceType<typeof csl.TransactionOutputAmountBuilder>;
+export type TransactionOutputBuilder = InstanceType<typeof csl.TransactionOutputBuilder>;
+export type TransactionOutputs = InstanceType<typeof csl.TransactionOutputs>;
+export type TransactionUnspentOutput = InstanceType<typeof csl.TransactionUnspentOutput>;
+export type TransactionUnspentOutputs = InstanceType<typeof csl.TransactionUnspentOutputs>;
+export type TransactionWitnessSet = InstanceType<typeof csl.TransactionWitnessSet>;
+export type TransactionWitnessSets = InstanceType<typeof csl.TransactionWitnessSets>;
+export type TxBuilderConstants = InstanceType<typeof csl.TxBuilderConstants>;
+export type TxInputsBuilder = InstanceType<typeof csl.TxInputsBuilder>;
+export type URL = InstanceType<typeof csl.URL>;
+export type UnitInterval = InstanceType<typeof csl.UnitInterval>;
+export type Update = InstanceType<typeof csl.Update>;
+export type VRFCert = InstanceType<typeof csl.VRFCert>;
+export type VRFKeyHash = InstanceType<typeof csl.VRFKeyHash>;
+export type VRFVKey = InstanceType<typeof csl.VRFVKey>;
+export type Value = InstanceType<typeof csl.Value>;
+export type Vkey = InstanceType<typeof csl.Vkey>;
+export type Vkeys = InstanceType<typeof csl.Vkeys>;
+export type Vkeywitness = InstanceType<typeof csl.Vkeywitness>;
+export type Vkeywitnesses = InstanceType<typeof csl.Vkeywitnesses>;
+export type Withdrawals = InstanceType<typeof csl.Withdrawals>;

package/dist/cjs/deser/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });