@meshsdk/core-csl 1.6.0-alpha.1

package/dist/mjs/deser/converter.js

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

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

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

package/dist/mjs/deser/csl.js

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

package/dist/mjs/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/mjs/deser/deserializer.js

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

package/dist/mjs/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/mjs/deser/index.js

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

package/dist/mjs/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/mjs/deser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './deser';
+export * from './utils';
+export * from './core';

package/dist/mjs/index.js

@@ -0,0 +1,3 @@
+export * from './deser';
+export * from './utils';
+export * from './core';

package/dist/mjs/utils/address.d.ts

@@ -0,0 +1,12 @@
+import { PubKeyAddress, ScriptAddress } from '@meshsdk/core';
+export declare const addrBech32ToHex: (bech32: string) => string;
+export declare const addrBech32ToObj: <T>(bech32: string) => T;
+export declare const parsePlutusAddressObjToBech32: (plutusDataAddressObject: PubKeyAddress | ScriptAddress, networkId?: number) => string;
+export declare const parsePlutusAddressToBech32: (plutusHex: string, networkId?: number) => string;
+export declare const serializeBech32Address: (bech32Addr: string) => {
+    pubKeyHash: string;
+    scriptHash: string;
+    stakeCredential: string;
+};
+export declare const scriptHashToBech32: (scriptHash: string, stakeCredential?: string, networkId?: number) => string;
+export declare const v2ScriptToBech32: (scriptCbor: string, stakeCredential?: string, networkId?: number) => string;

package/dist/mjs/utils/address.js

@@ -0,0 +1,50 @@
+import { csl } from '../deser';
+import { getV2ScriptHash } from './scripts';
+export const addrBech32ToHex = (bech32) => {
+    const hexAddress = csl.Address.from_bech32(bech32).to_hex();
+    const cslAddress = csl.Address.from_hex(hexAddress);
+    const hex = csl.PlutusData.from_address(cslAddress).to_hex();
+    return hex;
+};
+export const addrBech32ToObj = (bech32) => {
+    const hexAddress = csl.Address.from_bech32(bech32).to_hex();
+    const cslAddress = csl.Address.from_hex(hexAddress);
+    const json = JSON.parse(csl.PlutusData.from_address(cslAddress).to_json(1));
+    return json;
+};
+export const parsePlutusAddressObjToBech32 = (plutusDataAddressObject, networkId = 0) => {
+    const plutusDataPaymentKeyObject = plutusDataAddressObject.fields[0];
+    const plutusDataStakeKeyObject = plutusDataAddressObject.fields[1];
+    const cslPaymentKeyHash = plutusDataPaymentKeyObject.fields[0].bytes;
+    // Take into account whether the hash is a PubKeyHash or ScriptHash
+    const cslPaymentCredential = plutusDataPaymentKeyObject.constructor === 0
+        ? csl.StakeCredential.from_keyhash(csl.Ed25519KeyHash.from_hex(cslPaymentKeyHash))
+        : csl.StakeCredential.from_scripthash(csl.ScriptHash.from_hex(cslPaymentKeyHash));
+    let bech32Addr = '';
+    // Parsing address according to whether it has a stake key
+    if (plutusDataStakeKeyObject.constructor === 0) {
+        const cslStakeKeyHash = csl.Ed25519KeyHash.from_hex(plutusDataStakeKeyObject.fields[0].fields[0].fields[0].bytes);
+        const cslBaseAddress = csl.BaseAddress.new(networkId, cslPaymentCredential, csl.StakeCredential.from_keyhash(cslStakeKeyHash));
+        bech32Addr = cslBaseAddress.to_address().to_bech32();
+    }
+    else {
+        const cslEnterpriseAddress = csl.EnterpriseAddress.new(networkId, cslPaymentCredential);
+        bech32Addr = cslEnterpriseAddress.to_address().to_bech32();
+    }
+    return bech32Addr;
+};
+export const parsePlutusAddressToBech32 = (plutusHex, networkId = 0) => {
+    const cslPlutusDataAddress = csl.PlutusData.from_hex(plutusHex);
+    const plutusDataAddressObject = JSON.parse(cslPlutusDataAddress.to_json(csl.PlutusDatumSchema.DetailedSchema));
+    return parsePlutusAddressObjToBech32(plutusDataAddressObject, networkId);
+};
+export const serializeBech32Address = (bech32Addr) => {
+    const serializedAddress = csl.serialize_bech32_address(bech32Addr);
+    return {
+        pubKeyHash: serializedAddress.get_pub_key_hash(),
+        scriptHash: serializedAddress.get_script_hash(),
+        stakeCredential: serializedAddress.get_stake_key_hash(),
+    };
+};
+export const scriptHashToBech32 = (scriptHash, stakeCredential, networkId = 0) => csl.script_to_address(networkId, scriptHash, stakeCredential);
+export const v2ScriptToBech32 = (scriptCbor, stakeCredential, networkId = 0) => scriptHashToBech32(getV2ScriptHash(scriptCbor), stakeCredential, networkId);

package/dist/mjs/utils/aiken.d.ts

@@ -0,0 +1,2 @@
+export declare const applyParamsToScript: (rawAikenScriptBlueprint: string, params: string[]) => string;
+export declare const applyObjParamsToScript: <T extends object>(rawAikenScriptBlueprint: string, params: T[]) => string;

package/dist/mjs/utils/aiken.js

@@ -0,0 +1,15 @@
+import { csl } from '../deser';
+export const applyParamsToScript = (rawAikenScriptBlueprint, params) => {
+    const cslParams = csl.JsVecString.new();
+    params.forEach((param) => {
+        cslParams.add(param);
+    });
+    return csl.apply_params_to_script(cslParams, rawAikenScriptBlueprint);
+};
+export const applyObjParamsToScript = (rawAikenScriptBlueprint, params) => {
+    const cslParams = csl.JsVecString.new();
+    params.forEach((param) => {
+        cslParams.add(JSON.stringify(param));
+    });
+    return csl.apply_params_to_script(cslParams, rawAikenScriptBlueprint);
+};

package/dist/mjs/utils/credentials.d.ts

@@ -0,0 +1 @@
+export declare const skeyToPubKeyHash: (skeyHex: string) => string;

package/dist/mjs/utils/credentials.js

@@ -0,0 +1,6 @@
+import { csl } from '../deser';
+export const skeyToPubKeyHash = (skeyHex) => {
+    const isHexUnclean = skeyHex.slice(0, 4) === '5820' && skeyHex.length === 68;
+    const cleanHex = isHexUnclean ? skeyHex.slice(4) : skeyHex;
+    return csl.PrivateKey.from_hex(cleanHex).to_public().hash().to_hex();
+};

package/dist/mjs/utils/datum.d.ts

@@ -0,0 +1,4 @@
+export declare const parseInlineDatum: <T extends {
+    inline_datum?: string | undefined;
+}, X>(utxo: T) => X;
+export declare const parseDatumCbor: <T = any>(datumCbor: string) => T;