@meshsdk/core-csl 1.5.28

package/dist/cjs/utils/index.js

@@ -0,0 +1,23 @@
+"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("./address"), exports);
+__exportStar(require("./datum"), exports);
+__exportStar(require("./scripts"), exports);
+__exportStar(require("./credentials"), exports);
+__exportStar(require("./staking"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./aiken"), exports);

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

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

package/dist/cjs/utils/scripts.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getV2ScriptHash = void 0;
+const deser_1 = require("../deser");
+const getV2ScriptHash = (script) => deser_1.csl.get_v2_script_hash(script);
+exports.getV2ScriptHash = getV2ScriptHash;

package/dist/cjs/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/cjs/utils/staking.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewardAddressToKeyHash = exports.baseAddressToStakeAddress = exports.poolIdBech32ToHex = exports.poolIdHexToBech32 = void 0;
+const deser_1 = require("../deser");
+const poolIdHexToBech32 = (poolIdHash) => {
+    const cslPoolIdHash = deser_1.csl.Ed25519KeyHash.from_hex(poolIdHash);
+    return cslPoolIdHash.to_bech32("pool");
+};
+exports.poolIdHexToBech32 = poolIdHexToBech32;
+const poolIdBech32ToHex = (poolIdBech32) => {
+    const cslPoolIdHash = deser_1.csl.Ed25519KeyHash.from_bech32(poolIdBech32);
+    return Buffer.from(cslPoolIdHash.to_bytes()).toString("hex");
+};
+exports.poolIdBech32ToHex = poolIdBech32ToHex;
+const baseAddressToStakeAddress = (baseAddressBech32, network = 1) => {
+    var _a;
+    const networkId = network === 1
+        ? deser_1.csl.NetworkId.mainnet().kind()
+        : deser_1.csl.NetworkId.testnet().kind();
+    const stakeCred = (_a = deser_1.csl.BaseAddress.from_address(deser_1.csl.Address.from_bech32(baseAddressBech32))) === null || _a === void 0 ? void 0 : _a.stake_cred();
+    if (stakeCred) {
+        const stakeAddress = deser_1.csl.RewardAddress.new(networkId, stakeCred)
+            .to_address()
+            .to_bech32();
+        return stakeAddress;
+    }
+    return "";
+};
+exports.baseAddressToStakeAddress = baseAddressToStakeAddress;
+const rewardAddressToKeyHash = (rewardBech32) => {
+    var _a, _b;
+    return (_b = (_a = (0, deser_1.toRewardAddress)(rewardBech32)) === null || _a === void 0 ? void 0 : _a.payment_cred().to_keyhash()) === null || _b === void 0 ? void 0 : _b.to_hex();
+};
+exports.rewardAddressToKeyHash = rewardAddressToKeyHash;

package/dist/cjs/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/cjs/utils/transaction.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTransaction = exports.calculateTxHash = void 0;
+const deser_1 = require("../deser");
+const calculateTxHash = (txHex) => deser_1.csl.calculate_tx_hash(txHex);
+exports.calculateTxHash = calculateTxHash;
+const signTransaction = (txHex, signingKeys) => {
+    const cslSigningKeys = deser_1.csl.JsVecString.new();
+    signingKeys.forEach((key) => {
+        cslSigningKeys.add(key);
+    });
+    const signedTx = deser_1.csl.sign_transaction(txHex, cslSigningKeys);
+    return signedTx;
+};
+exports.signTransaction = signTransaction;

package/dist/mjs/core/adaptor/data.d.ts

@@ -0,0 +1,3 @@
+import { BuilderData, Redeemer } from "@meshsdk/common";
+export declare const builderDataToCbor: ({ type, content }: BuilderData) => string;
+export declare const redeemerToObj: (redeemer: Redeemer) => object;

package/dist/mjs/core/adaptor/data.js

@@ -0,0 +1,16 @@
+import { csl, toPlutusData } from "../../deser";
+export const builderDataToCbor = ({ type, content }) => {
+    if (type === "Mesh") {
+        return toPlutusData(content).to_hex();
+    }
+    if (type === "CBOR") {
+        return csl.PlutusData.from_hex(content).to_hex();
+    }
+    return csl.PlutusData.from_json(content, csl.PlutusDatumSchema.DetailedSchema).to_hex();
+};
+export const redeemerToObj = (redeemer) => {
+    return {
+        data: builderDataToCbor(redeemer.data),
+        exUnits: redeemer.exUnits,
+    };
+};

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

@@ -0,0 +1,15 @@
+import { MeshTxBuilderBody } from "@meshsdk/common";
+export declare const meshTxBuilderBodyToObj: ({ inputs, outputs, collaterals, requiredSignatures, referenceInputs, mints, changeAddress, metadata, validityRange, certificates, signingKey, withdrawals, }: MeshTxBuilderBody) => {
+    inputs: object[];
+    outputs: object[];
+    collaterals: object[];
+    requiredSignatures: string[];
+    referenceInputs: import("@meshsdk/common").RefTxIn[];
+    mints: object[];
+    changeAddress: string;
+    metadata: import("@meshsdk/common").Metadata[];
+    validityRange: object;
+    certificates: object[];
+    signingKey: string[];
+    withdrawals: object[];
+};

package/dist/mjs/core/adaptor/index.js

@@ -0,0 +1,21 @@
+import { certificateToObj, validityRangeToObj, } from "@meshsdk/common";
+import { mintItemToObj } from "./mint";
+import { outputToObj } from "./output";
+import { collateralTxInToObj, txInToObj } from "./txIn";
+import { withdrawalToObj } from "./withdrawal";
+export const meshTxBuilderBodyToObj = ({ inputs, outputs, collaterals, requiredSignatures, referenceInputs, mints, changeAddress, metadata, validityRange, certificates, signingKey, withdrawals, }) => {
+    return {
+        inputs: inputs.map(txInToObj),
+        outputs: outputs.map(outputToObj),
+        collaterals: collaterals.map(collateralTxInToObj),
+        requiredSignatures,
+        referenceInputs: referenceInputs,
+        mints: mints.map((mint) => mintItemToObj(mint)),
+        changeAddress,
+        metadata: metadata,
+        validityRange: validityRangeToObj(validityRange),
+        certificates: certificates.map(certificateToObj),
+        signingKey: signingKey,
+        withdrawals: withdrawals.map(withdrawalToObj),
+    };
+};

package/dist/mjs/core/adaptor/mint.d.ts

@@ -0,0 +1,5 @@
+import { MintItem } from "@meshsdk/common";
+export declare const mintItemToObj: (mintItem: MintItem) => object;
+export declare const plutusMintItemToObj: (mintItem: Required<MintItem>) => object;
+export declare const nativeMintItemToObj: (mintItem: Omit<Required<MintItem>, "redeemer">) => object;
+export declare const mintParametersObj: (mintItem: MintItem) => object;

package/dist/mjs/core/adaptor/mint.js

@@ -0,0 +1,35 @@
+import { redeemerToObj } from "./data";
+import { scriptSourceToObj, simpleScriptSourceToObj } from "./script";
+export const mintItemToObj = (mintItem) => {
+    switch (mintItem.type) {
+        case "Plutus":
+            return {
+                scriptMint: plutusMintItemToObj(mintItem),
+            };
+        case "Native":
+            return {
+                simpleScriptMint: nativeMintItemToObj(mintItem),
+            };
+    }
+};
+export const plutusMintItemToObj = (mintItem) => {
+    let scriptSource = scriptSourceToObj(mintItem.scriptSource);
+    return {
+        mint: mintParametersObj(mintItem),
+        redeemer: mintItem.redeemer ? redeemerToObj(mintItem.redeemer) : null,
+        scriptSource,
+    };
+};
+export const nativeMintItemToObj = (mintItem) => {
+    return {
+        mint: mintParametersObj(mintItem),
+        scriptSource: simpleScriptSourceToObj(mintItem.scriptSource),
+    };
+};
+export const mintParametersObj = (mintItem) => {
+    return {
+        policyId: mintItem.policyId,
+        assetName: mintItem.assetName,
+        amount: BigInt(mintItem.amount),
+    };
+};

package/dist/mjs/core/adaptor/output.d.ts

@@ -0,0 +1,2 @@
+import { Output } from "@meshsdk/common";
+export declare const outputToObj: (output: Output) => object;

package/dist/mjs/core/adaptor/output.js

@@ -0,0 +1,29 @@
+import { builderDataToCbor } from "./data";
+export const outputToObj = (output) => {
+    let datum = null;
+    if (output.datum) {
+        switch (output.datum.type) {
+            case "Inline":
+                datum = { inline: builderDataToCbor(output.datum.data) };
+                break;
+            case "Hash":
+                datum = { hash: builderDataToCbor(output.datum.data) };
+                break;
+        }
+    }
+    // TODO: add native script
+    const refScript = output.referenceScript;
+    return {
+        address: output.address,
+        amount: output.amount,
+        datum,
+        referenceScript: output.referenceScript
+            ? {
+                providedScriptSource: {
+                    scriptCbor: refScript.code,
+                    languageVersion: refScript.version.toLocaleLowerCase(),
+                },
+            }
+            : null,
+    };
+};

package/dist/mjs/core/adaptor/script.d.ts

@@ -0,0 +1,3 @@
+import { ScriptSource, SimpleScriptSourceInfo } from "@meshsdk/common";
+export declare const scriptSourceToObj: (scriptSource: ScriptSource) => object;
+export declare const simpleScriptSourceToObj: (scriptSource: SimpleScriptSourceInfo) => object;

package/dist/mjs/core/adaptor/script.js

@@ -0,0 +1,39 @@
+export const scriptSourceToObj = (scriptSource) => {
+    if (scriptSource.type === "Provided") {
+        return {
+            providedScriptSource: {
+                scriptCbor: scriptSource.script.code,
+                languageVersion: scriptSource.script.version.toLocaleLowerCase(),
+            },
+        };
+    }
+    return {
+        inlineScriptSource: {
+            refTxIn: {
+                txHash: scriptSource.txHash,
+                txIndex: scriptSource.txIndex,
+            },
+            spendingScriptHash: scriptSource.scriptHash ?? "",
+            languageVersion: scriptSource.version.toLocaleLowerCase(),
+            scriptSize: BigInt(scriptSource.scriptSize ?? "0"),
+        },
+    };
+};
+export const simpleScriptSourceToObj = (scriptSource) => {
+    if (scriptSource.type === "Provided") {
+        return {
+            providedSimpleScriptSource: {
+                scriptCbor: scriptSource.scriptCode,
+            },
+        };
+    }
+    return {
+        inlineSimpleScriptSource: {
+            refTxIn: {
+                txHash: scriptSource.txHash,
+                txIndex: scriptSource.txIndex,
+            },
+            simpleScriptHash: scriptSource.simpleScriptHash ?? "",
+        },
+    };
+};

package/dist/mjs/core/adaptor/txIn.d.ts

@@ -0,0 +1,5 @@
+import { ScriptTxInParameter, TxIn, TxInParameter } from "@meshsdk/common";
+export declare const txInToObj: (txIn: TxIn) => object;
+export declare const collateralTxInToObj: (txIn: TxIn) => object;
+export declare const txInParameterToObj: (txInParameter: TxInParameter) => object;
+export declare const scriptTxInParameterToObj: (scriptTxInParameter: ScriptTxInParameter) => object;

package/dist/mjs/core/adaptor/txIn.js

@@ -0,0 +1,68 @@
+import { builderDataToCbor, redeemerToObj } from "./data";
+import { scriptSourceToObj } from "./script";
+export const txInToObj = (txIn) => {
+    switch (txIn.type) {
+        case "PubKey":
+            return {
+                pubKeyTxIn: {
+                    txIn: txInParameterToObj(txIn.txIn),
+                },
+            };
+        case "Script":
+            return {
+                scriptTxIn: {
+                    txIn: txInParameterToObj(txIn.txIn),
+                    scriptTxIn: scriptTxInParameterToObj(txIn.scriptTxIn),
+                },
+            };
+        case "SimpleScript":
+            // Not implemented
+            return {};
+    }
+};
+export const collateralTxInToObj = (txIn) => {
+    return {
+        txIn: txInParameterToObj(txIn.txIn),
+    };
+};
+export const txInParameterToObj = (txInParameter) => {
+    return {
+        txHash: txInParameter.txHash,
+        txIndex: txInParameter.txIndex,
+        amount: txInParameter.amount ?? null,
+        address: txInParameter.address ?? null,
+    };
+};
+export const scriptTxInParameterToObj = (scriptTxInParameter) => {
+    let scriptSource = null;
+    let datumSource = null;
+    if (scriptTxInParameter.scriptSource) {
+        scriptSource = scriptSourceToObj(scriptTxInParameter.scriptSource);
+    }
+    if (scriptTxInParameter.datumSource) {
+        switch (scriptTxInParameter.datumSource.type) {
+            case "Provided":
+                datumSource = {
+                    providedDatumSource: {
+                        data: builderDataToCbor(scriptTxInParameter.datumSource.data),
+                    },
+                };
+                break;
+            case "Inline":
+                datumSource = {
+                    inlineDatumSource: {
+                        txHash: scriptTxInParameter.datumSource.txHash,
+                        txIndex: scriptTxInParameter.datumSource.txIndex,
+                    },
+                };
+                break;
+        }
+    }
+    return {
+        scriptSource,
+        datumSource,
+        redeemer: scriptTxInParameter.redeemer
+            ? redeemerToObj(scriptTxInParameter.redeemer)
+            : null,
+    };
+};

package/dist/mjs/core/adaptor/utxo.d.ts

@@ -0,0 +1,2 @@
+import { UTxO } from "@meshsdk/common";
+export declare const utxoToObj: ({ input: { outputIndex, txHash }, output: { address, amount, dataHash, plutusData, scriptRef, scriptHash }, }: UTxO) => object;

package/dist/mjs/core/adaptor/utxo.js

@@ -0,0 +1,16 @@
+export const utxoToObj = ({ input: { outputIndex, txHash }, output: { address, amount, dataHash, plutusData, scriptRef, scriptHash }, }) => {
+    return {
+        input: {
+            outputIndex,
+            txHash,
+        },
+        output: {
+            address,
+            amount,
+            dataHash: dataHash ?? null,
+            plutusData: plutusData ?? null,
+            scriptRef: scriptRef ?? null,
+            scriptHash: scriptHash ?? null,
+        },
+    };
+};

package/dist/mjs/core/adaptor/withdrawal.d.ts

@@ -0,0 +1,2 @@
+import { Withdrawal } from "@meshsdk/common";
+export declare const withdrawalToObj: (withdrawal: Withdrawal) => object;

package/dist/mjs/core/adaptor/withdrawal.js

@@ -0,0 +1,26 @@
+import { redeemerToObj } from "./data";
+import { scriptSourceToObj } from "./script";
+export const withdrawalToObj = (withdrawal) => {
+    if ("pubKeyWithdrawal" in withdrawal) {
+        return {
+            pubKeyWithdrawal: {
+                address: withdrawal.pubKeyWithdrawal.address,
+                coin: BigInt(withdrawal.pubKeyWithdrawal.coin),
+            },
+        };
+    }
+    if (!withdrawal.plutusScriptWithdrawal.scriptSource) {
+        throw new Error("withdrawalToObj: missing scriptSource in plutusScriptWithdrawal.");
+    }
+    if (!withdrawal.plutusScriptWithdrawal.redeemer) {
+        throw new Error("withdrawalToObj: missing redeemer in plutusScriptWithdrawal.");
+    }
+    return {
+        plutusScriptWithdrawal: {
+            address: withdrawal.plutusScriptWithdrawal.address,
+            coin: BigInt(withdrawal.plutusScriptWithdrawal.coin),
+            scriptSource: scriptSourceToObj(withdrawal.plutusScriptWithdrawal.scriptSource),
+            redeemer: redeemerToObj(withdrawal.plutusScriptWithdrawal.redeemer),
+        },
+    };
+};

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

@@ -0,0 +1 @@
+export * from "./serializer";

package/dist/mjs/core/index.js

@@ -0,0 +1 @@
+export * from "./serializer";

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

@@ -0,0 +1,12 @@
+import type { BuilderData, DeserializedAddress, IDeserializer, IMeshTxSerializer, IResolver, MeshTxBuilderBody, Protocol } from "@meshsdk/common";
+export declare class CSLSerializer implements IMeshTxSerializer {
+    protocolParams: Protocol;
+    meshTxBuilderBody: MeshTxBuilderBody;
+    constructor(protocolParams?: Protocol);
+    serializeTxBody(txBody: MeshTxBuilderBody, protocolParams?: Protocol): string;
+    addSigningKeys(txHex: string, signingKeys: string[]): string;
+    serializeData(data: BuilderData): string;
+    serializeAddress(address: Partial<DeserializedAddress>, networkId?: number): string;
+    deserializer: IDeserializer;
+    resolver: IResolver;
+}

package/dist/mjs/core/serializer.js

@@ -0,0 +1,105 @@
+/* eslint-disable default-case */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable radix */
+import JSONbig from "json-bigint";
+import { DEFAULT_PROTOCOL_PARAMETERS, emptyTxBuilderBody, } from "@meshsdk/common";
+import { csl, deserializePlutusScript, resolveDataHash, resolveEd25519KeyHash, resolvePoolId, resolvePrivateKey, resolveRewardAddress, resolveScriptRef, toNativeScript, } from "../deser";
+import { calculateTxHash, deserializeBech32Address, rewardAddressToKeyHash, serialzeAddress, signTransaction, } from "../utils";
+import { meshTxBuilderBodyToObj } from "./adaptor";
+import { builderDataToCbor } from "./adaptor/data";
+export class CSLSerializer {
+    protocolParams;
+    meshTxBuilderBody = emptyTxBuilderBody();
+    constructor(protocolParams) {
+        this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
+    }
+    serializeTxBody(txBody, protocolParams) {
+        const txBodyJson = JSONbig.stringify(meshTxBuilderBodyToObj(txBody));
+        const params = JSONbig.stringify(protocolParams || this.protocolParams);
+        console.log("txBodyJson", txBodyJson);
+        const txBuildResult = csl.js_serialize_tx_body(txBodyJson, params);
+        if (txBuildResult.get_status() !== "success") {
+            throw new Error(txBuildResult.get_data());
+        }
+        return txBuildResult.get_data();
+    }
+    addSigningKeys(txHex, signingKeys) {
+        if (signingKeys.length > 0) {
+            return signTransaction(txHex, signingKeys);
+        }
+        return txHex;
+    }
+    serializeData(data) {
+        return builderDataToCbor(data);
+    }
+    serializeAddress(address, networkId) {
+        return serialzeAddress(address, networkId);
+    }
+    deserializer = {
+        key: {
+            deserializeAddress: function (bech32) {
+                return deserializeBech32Address(bech32);
+            },
+        },
+        script: {
+            deserializeNativeScript: function (script) {
+                const nativeScript = toNativeScript(script);
+                const scriptCbor = nativeScript.to_hex();
+                const scriptHash = nativeScript.hash().to_hex();
+                return {
+                    scriptHash,
+                    scriptCbor,
+                };
+            },
+            deserializePlutusScript: function (script) {
+                const scriptHash = deserializePlutusScript(script.code, script.version)
+                    .hash()
+                    .to_hex();
+                return { scriptHash, scriptCbor: script.code };
+            },
+        },
+    };
+    resolver = {
+        keys: {
+            resolveStakeKeyHash: function (bech32) {
+                return (rewardAddressToKeyHash(bech32) ||
+                    deserializeBech32Address(bech32).stakeCredentialHash);
+            },
+            // resolveStakeScriptHash: function (bech32: string): string {
+            //   return (
+            //     rewardAddressToKeyHash(bech32) ||
+            //     serializeBech32Address(bech32).stakeScriptCredentialHash
+            //   );
+            // },
+            resolvePrivateKey: function (words) {
+                return resolvePrivateKey(words);
+            },
+            resolveRewardAddress: function (bech32) {
+                return resolveRewardAddress(bech32);
+            },
+            resolveEd25519KeyHash: function (bech32) {
+                return resolveEd25519KeyHash(bech32);
+            },
+        },
+        tx: {
+            resolveTxHash: function (txHex) {
+                return calculateTxHash(txHex);
+            },
+        },
+        data: {
+            resolveDataHash: function (data) {
+                return resolveDataHash(data);
+            },
+        },
+        script: {
+            resolveScriptRef: function (script) {
+                return resolveScriptRef(script);
+            },
+        },
+        pool: {
+            resolvePoolId: function (hash) {
+                return resolvePoolId(hash);
+            },
+        },
+    };
+}

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

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

package/dist/mjs/deser/constants.js

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

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

@@ -0,0 +1,17 @@
+import type { BuilderData, Data, NativeScript, PlutusScript } from "@meshsdk/common";
+import { csl } from "./csl";
+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 fromUTF8: (utf8: string) => string;
+export declare const toUTF8: (hex: string) => string;
+export declare const fromLovelace: (lovelace: number) => number;
+export declare const toLovelace: (ada: number) => number;
+export declare const toScriptRef: (script: PlutusScript | NativeScript) => csl.ScriptRef;
+export declare const toPlutusData: (data: Data) => csl.PlutusData;
+export declare const castRawDataToJsonString: (rawData: object | string) => string;
+export declare const castDataToPlutusData: ({ type, content, }: BuilderData) => csl.PlutusData;
+export declare const toNativeScript: (script: NativeScript) => csl.NativeScript;