@meshsdk/core-csl 1.5.28

package/README.md

@@ -0,0 +1,5 @@
+# mesh-core-csl
+
+Types and utilities functions between Mesh and [cardano-serialization-lib](https://github.com/Emurgo/cardano-serialization-lib)
+
+[meshjs.dev](https://meshjs.dev/)

package/dist/cjs/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/cjs/core/adaptor/data.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeemerToObj = exports.builderDataToCbor = void 0;
+const deser_1 = require("../../deser");
+const builderDataToCbor = ({ type, content }) => {
+    if (type === "Mesh") {
+        return (0, deser_1.toPlutusData)(content).to_hex();
+    }
+    if (type === "CBOR") {
+        return deser_1.csl.PlutusData.from_hex(content).to_hex();
+    }
+    return deser_1.csl.PlutusData.from_json(content, deser_1.csl.PlutusDatumSchema.DetailedSchema).to_hex();
+};
+exports.builderDataToCbor = builderDataToCbor;
+const redeemerToObj = (redeemer) => {
+    return {
+        data: (0, exports.builderDataToCbor)(redeemer.data),
+        exUnits: redeemer.exUnits,
+    };
+};
+exports.redeemerToObj = redeemerToObj;

package/dist/cjs/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/cjs/core/adaptor/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meshTxBuilderBodyToObj = void 0;
+const common_1 = require("@meshsdk/common");
+const mint_1 = require("./mint");
+const output_1 = require("./output");
+const txIn_1 = require("./txIn");
+const withdrawal_1 = require("./withdrawal");
+const meshTxBuilderBodyToObj = ({ inputs, outputs, collaterals, requiredSignatures, referenceInputs, mints, changeAddress, metadata, validityRange, certificates, signingKey, withdrawals, }) => {
+    return {
+        inputs: inputs.map(txIn_1.txInToObj),
+        outputs: outputs.map(output_1.outputToObj),
+        collaterals: collaterals.map(txIn_1.collateralTxInToObj),
+        requiredSignatures,
+        referenceInputs: referenceInputs,
+        mints: mints.map((mint) => (0, mint_1.mintItemToObj)(mint)),
+        changeAddress,
+        metadata: metadata,
+        validityRange: (0, common_1.validityRangeToObj)(validityRange),
+        certificates: certificates.map(common_1.certificateToObj),
+        signingKey: signingKey,
+        withdrawals: withdrawals.map(withdrawal_1.withdrawalToObj),
+    };
+};
+exports.meshTxBuilderBodyToObj = meshTxBuilderBodyToObj;

package/dist/cjs/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/cjs/core/adaptor/mint.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintParametersObj = exports.nativeMintItemToObj = exports.plutusMintItemToObj = exports.mintItemToObj = void 0;
+const data_1 = require("./data");
+const script_1 = require("./script");
+const mintItemToObj = (mintItem) => {
+    switch (mintItem.type) {
+        case "Plutus":
+            return {
+                scriptMint: (0, exports.plutusMintItemToObj)(mintItem),
+            };
+        case "Native":
+            return {
+                simpleScriptMint: (0, exports.nativeMintItemToObj)(mintItem),
+            };
+    }
+};
+exports.mintItemToObj = mintItemToObj;
+const plutusMintItemToObj = (mintItem) => {
+    let scriptSource = (0, script_1.scriptSourceToObj)(mintItem.scriptSource);
+    return {
+        mint: (0, exports.mintParametersObj)(mintItem),
+        redeemer: mintItem.redeemer ? (0, data_1.redeemerToObj)(mintItem.redeemer) : null,
+        scriptSource,
+    };
+};
+exports.plutusMintItemToObj = plutusMintItemToObj;
+const nativeMintItemToObj = (mintItem) => {
+    return {
+        mint: (0, exports.mintParametersObj)(mintItem),
+        scriptSource: (0, script_1.simpleScriptSourceToObj)(mintItem.scriptSource),
+    };
+};
+exports.nativeMintItemToObj = nativeMintItemToObj;
+const mintParametersObj = (mintItem) => {
+    return {
+        policyId: mintItem.policyId,
+        assetName: mintItem.assetName,
+        amount: BigInt(mintItem.amount),
+    };
+};
+exports.mintParametersObj = mintParametersObj;

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

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outputToObj = void 0;
+const data_1 = require("./data");
+const outputToObj = (output) => {
+    let datum = null;
+    if (output.datum) {
+        switch (output.datum.type) {
+            case "Inline":
+                datum = { inline: (0, data_1.builderDataToCbor)(output.datum.data) };
+                break;
+            case "Hash":
+                datum = { hash: (0, data_1.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,
+    };
+};
+exports.outputToObj = outputToObj;

package/dist/cjs/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/cjs/core/adaptor/script.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleScriptSourceToObj = exports.scriptSourceToObj = void 0;
+const scriptSourceToObj = (scriptSource) => {
+    var _a, _b;
+    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: (_a = scriptSource.scriptHash) !== null && _a !== void 0 ? _a : "",
+            languageVersion: scriptSource.version.toLocaleLowerCase(),
+            scriptSize: BigInt((_b = scriptSource.scriptSize) !== null && _b !== void 0 ? _b : "0"),
+        },
+    };
+};
+exports.scriptSourceToObj = scriptSourceToObj;
+const simpleScriptSourceToObj = (scriptSource) => {
+    var _a;
+    if (scriptSource.type === "Provided") {
+        return {
+            providedSimpleScriptSource: {
+                scriptCbor: scriptSource.scriptCode,
+            },
+        };
+    }
+    return {
+        inlineSimpleScriptSource: {
+            refTxIn: {
+                txHash: scriptSource.txHash,
+                txIndex: scriptSource.txIndex,
+            },
+            simpleScriptHash: (_a = scriptSource.simpleScriptHash) !== null && _a !== void 0 ? _a : "",
+        },
+    };
+};
+exports.simpleScriptSourceToObj = simpleScriptSourceToObj;

package/dist/cjs/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/cjs/core/adaptor/txIn.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptTxInParameterToObj = exports.txInParameterToObj = exports.collateralTxInToObj = exports.txInToObj = void 0;
+const data_1 = require("./data");
+const script_1 = require("./script");
+const txInToObj = (txIn) => {
+    switch (txIn.type) {
+        case "PubKey":
+            return {
+                pubKeyTxIn: {
+                    txIn: (0, exports.txInParameterToObj)(txIn.txIn),
+                },
+            };
+        case "Script":
+            return {
+                scriptTxIn: {
+                    txIn: (0, exports.txInParameterToObj)(txIn.txIn),
+                    scriptTxIn: (0, exports.scriptTxInParameterToObj)(txIn.scriptTxIn),
+                },
+            };
+        case "SimpleScript":
+            // Not implemented
+            return {};
+    }
+};
+exports.txInToObj = txInToObj;
+const collateralTxInToObj = (txIn) => {
+    return {
+        txIn: (0, exports.txInParameterToObj)(txIn.txIn),
+    };
+};
+exports.collateralTxInToObj = collateralTxInToObj;
+const txInParameterToObj = (txInParameter) => {
+    var _a, _b;
+    return {
+        txHash: txInParameter.txHash,
+        txIndex: txInParameter.txIndex,
+        amount: (_a = txInParameter.amount) !== null && _a !== void 0 ? _a : null,
+        address: (_b = txInParameter.address) !== null && _b !== void 0 ? _b : null,
+    };
+};
+exports.txInParameterToObj = txInParameterToObj;
+const scriptTxInParameterToObj = (scriptTxInParameter) => {
+    let scriptSource = null;
+    let datumSource = null;
+    if (scriptTxInParameter.scriptSource) {
+        scriptSource = (0, script_1.scriptSourceToObj)(scriptTxInParameter.scriptSource);
+    }
+    if (scriptTxInParameter.datumSource) {
+        switch (scriptTxInParameter.datumSource.type) {
+            case "Provided":
+                datumSource = {
+                    providedDatumSource: {
+                        data: (0, data_1.builderDataToCbor)(scriptTxInParameter.datumSource.data),
+                    },
+                };
+                break;
+            case "Inline":
+                datumSource = {
+                    inlineDatumSource: {
+                        txHash: scriptTxInParameter.datumSource.txHash,
+                        txIndex: scriptTxInParameter.datumSource.txIndex,
+                    },
+                };
+                break;
+        }
+    }
+    return {
+        scriptSource,
+        datumSource,
+        redeemer: scriptTxInParameter.redeemer
+            ? (0, data_1.redeemerToObj)(scriptTxInParameter.redeemer)
+            : null,
+    };
+};
+exports.scriptTxInParameterToObj = scriptTxInParameterToObj;

package/dist/cjs/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/cjs/core/adaptor/utxo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utxoToObj = void 0;
+const utxoToObj = ({ input: { outputIndex, txHash }, output: { address, amount, dataHash, plutusData, scriptRef, scriptHash }, }) => {
+    return {
+        input: {
+            outputIndex,
+            txHash,
+        },
+        output: {
+            address,
+            amount,
+            dataHash: dataHash !== null && dataHash !== void 0 ? dataHash : null,
+            plutusData: plutusData !== null && plutusData !== void 0 ? plutusData : null,
+            scriptRef: scriptRef !== null && scriptRef !== void 0 ? scriptRef : null,
+            scriptHash: scriptHash !== null && scriptHash !== void 0 ? scriptHash : null,
+        },
+    };
+};
+exports.utxoToObj = utxoToObj;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawalToObj = void 0;
+const data_1 = require("./data");
+const script_1 = require("./script");
+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: (0, script_1.scriptSourceToObj)(withdrawal.plutusScriptWithdrawal.scriptSource),
+            redeemer: (0, data_1.redeemerToObj)(withdrawal.plutusScriptWithdrawal.redeemer),
+        },
+    };
+};
+exports.withdrawalToObj = withdrawalToObj;

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

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

package/dist/cjs/core/index.js

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

package/dist/cjs/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/cjs/core/serializer.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSLSerializer = void 0;
+/* eslint-disable default-case */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable radix */
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const common_1 = require("@meshsdk/common");
+const deser_1 = require("../deser");
+const utils_1 = require("../utils");
+const adaptor_1 = require("./adaptor");
+const data_1 = require("./adaptor/data");
+class CSLSerializer {
+    constructor(protocolParams) {
+        this.meshTxBuilderBody = (0, common_1.emptyTxBuilderBody)();
+        this.deserializer = {
+            key: {
+                deserializeAddress: function (bech32) {
+                    return (0, utils_1.deserializeBech32Address)(bech32);
+                },
+            },
+            script: {
+                deserializeNativeScript: function (script) {
+                    const nativeScript = (0, deser_1.toNativeScript)(script);
+                    const scriptCbor = nativeScript.to_hex();
+                    const scriptHash = nativeScript.hash().to_hex();
+                    return {
+                        scriptHash,
+                        scriptCbor,
+                    };
+                },
+                deserializePlutusScript: function (script) {
+                    const scriptHash = (0, deser_1.deserializePlutusScript)(script.code, script.version)
+                        .hash()
+                        .to_hex();
+                    return { scriptHash, scriptCbor: script.code };
+                },
+            },
+        };
+        this.resolver = {
+            keys: {
+                resolveStakeKeyHash: function (bech32) {
+                    return ((0, utils_1.rewardAddressToKeyHash)(bech32) ||
+                        (0, utils_1.deserializeBech32Address)(bech32).stakeCredentialHash);
+                },
+                // resolveStakeScriptHash: function (bech32: string): string {
+                //   return (
+                //     rewardAddressToKeyHash(bech32) ||
+                //     serializeBech32Address(bech32).stakeScriptCredentialHash
+                //   );
+                // },
+                resolvePrivateKey: function (words) {
+                    return (0, deser_1.resolvePrivateKey)(words);
+                },
+                resolveRewardAddress: function (bech32) {
+                    return (0, deser_1.resolveRewardAddress)(bech32);
+                },
+                resolveEd25519KeyHash: function (bech32) {
+                    return (0, deser_1.resolveEd25519KeyHash)(bech32);
+                },
+            },
+            tx: {
+                resolveTxHash: function (txHex) {
+                    return (0, utils_1.calculateTxHash)(txHex);
+                },
+            },
+            data: {
+                resolveDataHash: function (data) {
+                    return (0, deser_1.resolveDataHash)(data);
+                },
+            },
+            script: {
+                resolveScriptRef: function (script) {
+                    return (0, deser_1.resolveScriptRef)(script);
+                },
+            },
+            pool: {
+                resolvePoolId: function (hash) {
+                    return (0, deser_1.resolvePoolId)(hash);
+                },
+            },
+        };
+        this.protocolParams = protocolParams || common_1.DEFAULT_PROTOCOL_PARAMETERS;
+    }
+    serializeTxBody(txBody, protocolParams) {
+        const txBodyJson = json_bigint_1.default.stringify((0, adaptor_1.meshTxBuilderBodyToObj)(txBody));
+        const params = json_bigint_1.default.stringify(protocolParams || this.protocolParams);
+        console.log("txBodyJson", txBodyJson);
+        const txBuildResult = deser_1.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 (0, utils_1.signTransaction)(txHex, signingKeys);
+        }
+        return txHex;
+    }
+    serializeData(data) {
+        return (0, data_1.builderDataToCbor)(data);
+    }
+    serializeAddress(address, networkId) {
+        return (0, utils_1.serialzeAddress)(address, networkId);
+    }
+}
+exports.CSLSerializer = CSLSerializer;

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

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

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