@meshsdk/core-csl 1.5.28

package/dist/mjs/deser/converter.js

@@ -0,0 +1,184 @@
+/* eslint-disable consistent-return */
+/* eslint-disable default-case */
+import JSONbig from "json-bigint";
+// import { LANGUAGE_VERSIONS } from ".";
+import { csl } from "./csl";
+import { deserializeEd25519KeyHash, deserializePlutusScript,
+// deserializePlutusScript,
+ } 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");
+};
+/* -----------------[ 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");
+/* -----------------[ Lovelace ]----------------- */
+export const fromLovelace = (lovelace) => lovelace / 1_000_000;
+export const toLovelace = (ada) => ada * 1_000_000;
+// /* -----------------[ NativeScript ]----------------- */
+// export const fromNativeScript = (script: csl.NativeScript) => {
+//   const fromNativeScripts = (scripts: csl.NativeScripts) => {
+//     const nativeScripts = new Array<NativeScript>();
+//     for (let index = 0; index < scripts.len(); index += 1) {
+//       nativeScripts.push(fromNativeScript(scripts.get(index)));
+//     }
+//     return nativeScripts;
+//   };
+//   switch (script.kind()) {
+//     case csl.NativeScriptKind.ScriptAll: {
+//       const scriptAll = script.as_script_all()!;
+//       return <NativeScript>{
+//         type: "all",
+//         scripts: fromNativeScripts(scriptAll.native_scripts()),
+//       };
+//     }
+//     case csl.NativeScriptKind.ScriptAny: {
+//       const scriptAny = script.as_script_any()!;
+//       return <NativeScript>{
+//         type: "any",
+//         scripts: fromNativeScripts(scriptAny.native_scripts()),
+//       };
+//     }
+//     case csl.NativeScriptKind.ScriptNOfK: {
+//       const scriptNOfK = script.as_script_n_of_k()!;
+//       return <NativeScript>{
+//         type: "atLeast",
+//         required: scriptNOfK.n(),
+//         scripts: fromNativeScripts(scriptNOfK.native_scripts()),
+//       };
+//     }
+//     case csl.NativeScriptKind.TimelockStart: {
+//       const timelockStart = script.as_timelock_start()!;
+//       return <NativeScript>{
+//         type: "after",
+//         slot: timelockStart.slot_bignum().to_str(),
+//       };
+//     }
+//     case csl.NativeScriptKind.TimelockExpiry: {
+//       const timelockExpiry = script.as_timelock_expiry()!;
+//       return <NativeScript>{
+//         type: "before",
+//         slot: timelockExpiry.slot_bignum().to_str(),
+//       };
+//     }
+//     case csl.NativeScriptKind.ScriptPubkey: {
+//       const scriptPubkey = script.as_script_pubkey()!;
+//       return <NativeScript>{
+//         type: "sig",
+//         keyHash: scriptPubkey.addr_keyhash().to_hex(),
+//       };
+//     }
+//     default:
+//       throw new Error(`Script Kind: ${script.kind()}, is not supported`);
+//   }
+// };
+// /* -----------------[ Scripts ]----------------- */
+// export const fromScriptRef = (
+//   scriptRef: string,
+// ): PlutusScript | NativeScript | undefined => {
+//   const script = csl.ScriptRef.from_hex(scriptRef);
+//   if (script.is_plutus_script()) {
+//     const plutusScript = script.plutus_script()!;
+//     return <PlutusScript>{
+//       code: plutusScript.to_hex(),
+//       version: Object.keys(LANGUAGE_VERSIONS).find(
+//         (key) =>
+//           LANGUAGE_VERSIONS[key as LanguageVersion].to_hex() ===
+//           plutusScript.language_version().to_hex(),
+//       ),
+//     };
+//   }
+//   const nativeScript = script.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));
+};
+/* -----------------[ PlutusData ]----------------- */
+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) => {
+                    const plutusMapValue = csl.PlutusMapValues.new();
+                    plutusMapValue.add(toPlutusData(value));
+                    plutusMap.insert(toPlutusData(key), plutusMapValue);
+                });
+                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)));
+    }
+};
+export const castRawDataToJsonString = (rawData) => {
+    if (typeof rawData === "object") {
+        return JSONbig.stringify(rawData);
+    }
+    return rawData;
+};
+export const castDataToPlutusData = ({ type, content, }) => {
+    if (type === "Mesh") {
+        return toPlutusData(content);
+    }
+    if (type === "CBOR") {
+        return csl.PlutusData.from_hex(content);
+    }
+    return csl.PlutusData.from_json(content, csl.PlutusDatumSchema.DetailedSchema);
+};
+export const toNativeScript = (script) => {
+    const toNativeScripts = (scripts) => {
+        const nativeScripts = csl.NativeScripts.new();
+        scripts.forEach((script) => {
+            nativeScripts.add(toNativeScript(script));
+        });
+        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)));
+    }
+};

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/common";
+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 { toBytes } from "./converter";
+import { csl } from "./csl";
+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,5 @@
+export * from "./deserializer";
+export * from "./converter";
+export * from "./csl";
+export * from "./constants";
+export * from "./resolver";

package/dist/mjs/deser/index.js

@@ -0,0 +1,5 @@
+export * from "./deserializer";
+export * from "./converter";
+export * from "./csl";
+export * from "./constants";
+export * from "./resolver";

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

@@ -0,0 +1,12 @@
+import { Data, NativeScript, PlutusScript } from "@meshsdk/common";
+export declare const resolveStakeKeyHash: (bech32: string) => string;
+export declare const resolvePrivateKey: (words: string[]) => string;
+export declare const resolveNativeScriptAddress: (script: NativeScript, networkId?: number) => string;
+export declare const resolvePlutusScriptAddress: (script: PlutusScript, networkId?: number) => string;
+export declare const resolveNativeScriptHash: (script: NativeScript) => string;
+export declare const resolveRewardAddress: (bech32: string) => string;
+export declare const resolveDataHash: (data: Data) => string;
+export declare const resolveNativeScriptHex: (script: NativeScript) => string;
+export declare const resolvePoolId: (hash: string) => string;
+export declare const resolveScriptRef: (script: PlutusScript | NativeScript) => string;
+export declare const resolveEd25519KeyHash: (bech32: string) => string;

package/dist/mjs/deser/resolver.js

@@ -0,0 +1,75 @@
+import { mnemonicToEntropy, } from "@meshsdk/common";
+import { deserializePlutusScript, fromUTF8, toAddress, toBaseAddress, toBytes, toNativeScript, toPlutusData, toRewardAddress, toScriptRef, } from ".";
+import { csl } from "./csl";
+export const resolveStakeKeyHash = (bech32) => {
+    try {
+        const stakeKeyHash = [
+            toBaseAddress(bech32)?.stake_cred().to_keyhash(),
+            toRewardAddress(bech32)?.payment_cred().to_keyhash(),
+        ].find((kh) => kh !== undefined);
+        if (stakeKeyHash !== undefined)
+            return stakeKeyHash.to_hex();
+        throw new Error(`Couldn't resolve stake key hash from address: ${bech32}`);
+    }
+    catch (error) {
+        throw new Error(`An error occurred during resolveStakeKeyHash: ${error}.`);
+    }
+};
+export const resolvePrivateKey = (words) => {
+    const buildBip32PrivateKey = (entropy, password = "") => {
+        return csl.Bip32PrivateKey.from_bip39_entropy(toBytes(entropy), toBytes(fromUTF8(password)));
+    };
+    const entropy = mnemonicToEntropy(words.join(" "));
+    const bip32PrivateKey = buildBip32PrivateKey(entropy);
+    const bech32PrivateKey = bip32PrivateKey.to_bech32();
+    bip32PrivateKey.free();
+    return bech32PrivateKey;
+};
+export const resolveNativeScriptAddress = (script, networkId = 0) => {
+    const nativeScript = toNativeScript(script);
+    const enterpriseAddress = csl.EnterpriseAddress.new(networkId, csl.Credential.from_scripthash(nativeScript.hash()));
+    return enterpriseAddress.to_address().to_bech32();
+};
+export const resolvePlutusScriptAddress = (script, networkId = 0) => {
+    const plutusScript = deserializePlutusScript(script.code, script.version);
+    const enterpriseAddress = csl.EnterpriseAddress.new(networkId, csl.Credential.from_scripthash(plutusScript.hash()));
+    return enterpriseAddress.to_address().to_bech32();
+};
+export const resolveNativeScriptHash = (script) => {
+    return toNativeScript(script).hash().to_hex();
+};
+export const resolveRewardAddress = (bech32) => {
+    const buildRewardAddress = (networkId, stakeKeyHash) => {
+        return csl.RewardAddress.new(networkId, csl.Credential.from_keyhash(stakeKeyHash));
+    };
+    try {
+        const address = toAddress(bech32);
+        const baseAddress = toBaseAddress(bech32);
+        const stakeKeyHash = baseAddress?.stake_cred().to_keyhash();
+        if (stakeKeyHash !== undefined)
+            return buildRewardAddress(address.network_id(), stakeKeyHash)
+                .to_address()
+                .to_bech32();
+        throw new Error(`Couldn't resolve reward address from address: ${bech32}`);
+    }
+    catch (error) {
+        throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
+    }
+};
+export const resolveDataHash = (data) => {
+    const plutusData = toPlutusData(data);
+    const dataHash = csl.hash_plutus_data(plutusData);
+    return dataHash.to_hex();
+};
+export const resolveNativeScriptHex = (script) => {
+    return toNativeScript(script).to_hex();
+};
+export const resolvePoolId = (hash) => {
+    return csl.Ed25519KeyHash.from_hex(hash).to_bech32("pool1");
+};
+export const resolveScriptRef = (script) => {
+    return toScriptRef(script).to_hex();
+};
+export const resolveEd25519KeyHash = (bech32) => {
+    return csl.Ed25519KeyHash.from_bech32(bech32).to_hex();
+};

package/dist/mjs/index.d.ts

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

package/dist/mjs/index.js

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

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

@@ -0,0 +1,9 @@
+import { DeserializedAddress, PubKeyAddress, ScriptAddress } from "@meshsdk/common";
+export declare const serialzeAddress: (deserializedAddress: Partial<DeserializedAddress>, networkId?: number) => string;
+export declare const addrBech32ToHex: (bech32: string) => string;
+export declare const addrBech32ToObj: <T>(bech32: string) => T;
+export declare const serializeAddressObj: (plutusDataAddressObject: PubKeyAddress | ScriptAddress, networkId?: number) => string;
+export declare const serializePlutusAddressToBech32: (plutusHex: string, networkId?: number) => string;
+export declare const deserializeBech32Address: (bech32Addr: string) => DeserializedAddress;
+export declare const scriptHashToBech32: (scriptHash: string, stakeCredentialHash?: string, networkId?: number, isScriptStakeCredentialHash?: boolean) => string;
+export declare const v2ScriptToBech32: (scriptCbor: string, stakeCredential?: string, networkId?: number, isScriptStakeCredential?: boolean) => string;

package/dist/mjs/utils/address.js

@@ -0,0 +1,50 @@
+import { pubKeyAddress, scriptAddress, } from "@meshsdk/common";
+import { csl } from "../deser";
+import { getV2ScriptHash } from "./scripts";
+export const serialzeAddress = (deserializedAddress, networkId = 0) => {
+    const { pubKeyHash, scriptHash, stakeCredentialHash, stakeScriptCredentialHash, } = deserializedAddress;
+    const isPaymentScript = !pubKeyHash;
+    const isStakeScript = !stakeCredentialHash;
+    const paymentHash = isPaymentScript ? scriptHash : pubKeyHash;
+    const stakeHash = isStakeScript
+        ? stakeScriptCredentialHash
+        : stakeCredentialHash;
+    if (!paymentHash)
+        throw new Error("Error: serializeAddress: Address must contain a payment part");
+    const addressObj = isPaymentScript
+        ? pubKeyAddress(paymentHash, stakeHash, isStakeScript)
+        : scriptAddress(paymentHash, stakeHash, isStakeScript);
+    return serializeAddressObj(addressObj, networkId);
+};
+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 serializeAddressObj = (plutusDataAddressObject, networkId = 0) => {
+    const bech32Addr = csl.parse_plutus_address_obj_to_bech32(JSON.stringify(plutusDataAddressObject), networkId);
+    return bech32Addr;
+};
+export const serializePlutusAddressToBech32 = (plutusHex, networkId = 0) => {
+    const cslPlutusDataAddress = csl.PlutusData.from_hex(plutusHex);
+    const plutusDataAddressObject = JSON.parse(cslPlutusDataAddress.to_json(csl.PlutusDatumSchema.DetailedSchema));
+    return serializeAddressObj(plutusDataAddressObject, networkId);
+};
+export const deserializeBech32Address = (bech32Addr) => {
+    const serializedAddress = csl.serialize_bech32_address(bech32Addr);
+    return {
+        pubKeyHash: serializedAddress.get_pub_key_hash(),
+        scriptHash: serializedAddress.get_script_hash(),
+        stakeCredentialHash: serializedAddress.get_stake_key_hash(),
+        stakeScriptCredentialHash: serializedAddress.get_stake_key_script_hash(),
+    };
+};
+export const scriptHashToBech32 = (scriptHash, stakeCredentialHash, networkId = 0, isScriptStakeCredentialHash = false) => csl.wasm_script_to_address(networkId, scriptHash, stakeCredentialHash, isScriptStakeCredentialHash);
+export const v2ScriptToBech32 = (scriptCbor, stakeCredential, networkId = 0, isScriptStakeCredential = false) => scriptHashToBech32(getV2ScriptHash(scriptCbor), stakeCredential, networkId, isScriptStakeCredential);

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

@@ -0,0 +1,17 @@
+import { Data } from "@meshsdk/common";
+/**
+ * Apply parameters to a given script blueprint.
+ *
+ * @param rawScript - The raw script CborHex from blueprint.
+ * @param params - The parameters to apply, in an array.
+ * @param type - The type of the parameters, default to be Mesh's Data type. It could also be in JSON and raw CBOR.
+ * @returns The double-cbor encoded script CborHex with the parameters applied.
+ */
+export declare const applyParamsToScript: (rawScript: string, params: object[] | Data[], type?: "Mesh" | "JSON" | "CBOR") => string;
+/**
+ * Apply Cbor encoding.
+ *
+ * @param rawScript - The raw script CborHex from blueprint.
+ * @returns The double-cbor encoded script CborHex.
+ */
+export declare const applyCborEncoding: (rawScript: string) => string;

package/dist/mjs/utils/aiken.js

@@ -0,0 +1,47 @@
+import { csl, toPlutusData } from "../deser";
+/**
+ * Apply parameters to a given script blueprint.
+ *
+ * @param rawScript - The raw script CborHex from blueprint.
+ * @param params - The parameters to apply, in an array.
+ * @param type - The type of the parameters, default to be Mesh's Data type. It could also be in JSON and raw CBOR.
+ * @returns The double-cbor encoded script CborHex with the parameters applied.
+ */
+export const applyParamsToScript = (rawScript, params, type = "Mesh") => {
+    const cslParams = csl.JsVecString.new();
+    let paramType = csl.BuilderDataType.CBOR;
+    switch (type) {
+        case "JSON":
+            paramType = csl.BuilderDataType.JSON;
+            params.forEach((param) => {
+                if (typeof param === "object") {
+                    cslParams.add(JSON.stringify(param));
+                }
+                else if (typeof param === "string") {
+                    cslParams.add(param);
+                }
+            });
+            break;
+        case "Mesh":
+            params.forEach((param) => {
+                const paramCbor = toPlutusData(param);
+                cslParams.add(paramCbor.to_hex());
+            });
+            break;
+        default:
+            params.forEach((param) => {
+                cslParams.add(param);
+            });
+            break;
+    }
+    return csl.apply_params_to_script(rawScript, cslParams, paramType);
+};
+/**
+ * Apply Cbor encoding.
+ *
+ * @param rawScript - The raw script CborHex from blueprint.
+ * @returns The double-cbor encoded script CborHex.
+ */
+export const applyCborEncoding = (rawScript) => {
+    return csl.apply_params_to_script(rawScript, csl.JsVecString.new(), csl.BuilderDataType.CBOR);
+};

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;
+}, X>(utxo: T) => X;
+export declare const parseDatumCbor: <T = any>(datumCbor: string) => T;

package/dist/mjs/utils/datum.js

@@ -0,0 +1,13 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { csl } from "../deser";
+export const parseInlineDatum = (utxo) => {
+    const datumCbor = utxo.inline_datum || "";
+    const parsedDatum = csl.PlutusData.from_hex(datumCbor);
+    const datum = JSON.parse(parsedDatum.to_json(1));
+    return datum;
+};
+export const parseDatumCbor = (datumCbor) => {
+    const parsedDatum = csl.PlutusData.from_hex(datumCbor);
+    const datum = JSON.parse(parsedDatum.to_json(1));
+    return datum;
+};

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

@@ -0,0 +1,7 @@
+export * from "./address";
+export * from "./datum";
+export * from "./scripts";
+export * from "./credentials";
+export * from "./staking";
+export * from "./transaction";
+export * from "./aiken";

package/dist/mjs/utils/index.js

@@ -0,0 +1,7 @@
+export * from "./address";
+export * from "./datum";
+export * from "./scripts";
+export * from "./credentials";
+export * from "./staking";
+export * from "./transaction";
+export * from "./aiken";

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

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

package/dist/mjs/utils/scripts.js

@@ -0,0 +1,2 @@
+import { csl } from "../deser";
+export const getV2ScriptHash = (script) => csl.get_v2_script_hash(script);

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

@@ -0,0 +1,4 @@
+export declare const poolIdHexToBech32: (poolIdHash: string) => string;
+export declare const poolIdBech32ToHex: (poolIdBech32: string) => string;
+export declare const baseAddressToStakeAddress: (baseAddressBech32: string, network?: number) => string;
+export declare const rewardAddressToKeyHash: (rewardBech32: string) => string | undefined;

package/dist/mjs/utils/staking.js

@@ -0,0 +1,25 @@
+import { csl, toRewardAddress } from "../deser";
+export const poolIdHexToBech32 = (poolIdHash) => {
+    const cslPoolIdHash = csl.Ed25519KeyHash.from_hex(poolIdHash);
+    return cslPoolIdHash.to_bech32("pool");
+};
+export const poolIdBech32ToHex = (poolIdBech32) => {
+    const cslPoolIdHash = csl.Ed25519KeyHash.from_bech32(poolIdBech32);
+    return Buffer.from(cslPoolIdHash.to_bytes()).toString("hex");
+};
+export const baseAddressToStakeAddress = (baseAddressBech32, network = 1) => {
+    const networkId = network === 1
+        ? csl.NetworkId.mainnet().kind()
+        : csl.NetworkId.testnet().kind();
+    const stakeCred = csl.BaseAddress.from_address(csl.Address.from_bech32(baseAddressBech32))?.stake_cred();
+    if (stakeCred) {
+        const stakeAddress = csl.RewardAddress.new(networkId, stakeCred)
+            .to_address()
+            .to_bech32();
+        return stakeAddress;
+    }
+    return "";
+};
+export const rewardAddressToKeyHash = (rewardBech32) => {
+    return toRewardAddress(rewardBech32)?.payment_cred().to_keyhash()?.to_hex();
+};

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

@@ -0,0 +1,2 @@
+export declare const calculateTxHash: (txHex: string) => string;
+export declare const signTransaction: (txHex: string, signingKeys: string[]) => string;

package/dist/mjs/utils/transaction.js

@@ -0,0 +1,10 @@
+import { csl } from "../deser";
+export const calculateTxHash = (txHex) => csl.calculate_tx_hash(txHex);
+export const signTransaction = (txHex, signingKeys) => {
+    const cslSigningKeys = csl.JsVecString.new();
+    signingKeys.forEach((key) => {
+        cslSigningKeys.add(key);
+    });
+    const signedTx = csl.sign_transaction(txHex, cslSigningKeys);
+    return signedTx;
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@meshsdk/core-csl",
+  "version": "1.5.28",
+  "description": "",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build:mesh": "rm -fr dist/* && tsc -p ./tsconfig.json && tsc -p ./tsconfig-cjs.json",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint",
+    "test": "jest --verbose",
+    "clean": "rm -rf .turbo && rm -rf dist && rm -rf node_modules",
+    "format": "prettier --check . --ignore-path ../../.gitignore",
+    "build:docs": "typedoc src/index.ts --json ../../apps/docs/src/data/mesh-core-csl.json"
+  },
+  "browser": {
+    "@sidan-lab/sidan-csl-rs-nodejs": "@sidan-lab/sidan-csl-rs-browser"
+  },
+  "devDependencies": {
+    "@meshsdk/eslint-config": "*",
+    "@meshsdk/typescript-config": "*",
+    "@types/json-bigint": "^1.0.4",
+    "eslint": "^8.57.0",
+    "ts-jest": "^29.1.4",
+    "tsup": "^8.0.2",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "@meshsdk/common": "*",
+    "@sidan-lab/sidan-csl-rs-browser": "^0.6.13",
+    "@sidan-lab/sidan-csl-rs-nodejs": "^0.6.13",
+    "json-bigint": "^1.0.0"
+  },
+  "prettier": "@meshsdk/prettier-config"
+}