@meshsdk/core-csl 1.6.0-alpha.1 → 1.6.0-alpha.11

package/README.md

@@ -1,9 +1,5 @@
-# mesh-csl
+# mesh-core-csl
 
-It is a Typescript wrapper around [`sidan-csl-rs`](https://github.com/sidan-lab/sidan-csl-rs) to add user-friendliness and useful APIs for building Cardano off-chain transactions. The APIs in this package are mostly low-level, closely tied with `sidan-csl-rs`. This package also serves some new utils functions that are yet to be packaged into `@meshsdk/core`.
+Types and utilities functions between Mesh and [cardano-serialization-lib](https://github.com/Emurgo/cardano-serialization-lib)
 
-## Install
-
-```sh
-yarn add @meshsdk/mesh-csl
-```
+[meshjs.dev](https://meshjs.dev/)

package/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

package/package.json

@@ -1,53 +1,42 @@
 {
-    "name": "@meshsdk/core-csl",
-    "description": "Cardano Off-chain Code APIs built on cardano-serialization-lib",
-    "version": "1.6.0-alpha.1",
-    "license": "Apache-2.0",
-    "main": "dist/cjs/index.js",
-    "module": "dist/mjs/index.js",
-    "exports": {
-        ".": {
-            "import": "./dist/mjs/index.js",
-            "require": "./dist/cjs/index.js"
-        }
-    },
-    "homepage": "https://github.com/MeshJS/mesh-core",
-    "author": {
-        "name": "SIDAN Lab",
-        "email": "contact@sidan.io"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/MeshJS/mesh-core.git"
-    },
-    "files": [
-        "dist"
-    ],
-    "keywords": [
-        "blockchain",
-        "cardano",
-        "plutus",
-        "cardano-serialization-lib"
-    ],
-    "scripts": {
-        "prepare": "cp ../tsconfig-base.json ./ && cp ../tsconfig-cjs.json ./ && cp ../tsconfig.json ./",
-        "build": "rm -fr dist/* && tsc -p ./tsconfig.json && tsc -p ./tsconfig-cjs.json",
-        "ci": "yarn && yarn build"
-    },
-    "browser": {
-        "@sidan-lab/sidan-csl-rs-nodejs": "@sidan-lab/sidan-csl-rs-browser"
-    },
-    "dependencies": {
-        "@meshsdk/common": "^1.0.0-alpha.3",
-        "@sidan-lab/sidan-csl-rs-browser": "^0.3.6",
-        "@sidan-lab/sidan-csl-rs-nodejs": "^0.3.6",
-        "blakejs": "^1.2.1",
-        "json-bigint": "^1.0.0"
-    },
-    "devDependencies": {
-        "@types/json-bigint": "^1.0.4",
-        "@types/node": "^18.16.3",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.0.4"
+  "name": "@meshsdk/core-csl",
+  "version": "1.6.0-alpha.11",
+  "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"
     }
-}
+  },
+  "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"
+}

package/src/core/adaptor/data.ts

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

package/src/core/adaptor/index.ts

@@ -0,0 +1,40 @@
+import {
+  certificateToObj,
+  MeshTxBuilderBody,
+  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,
+}: MeshTxBuilderBody) => {
+  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/src/core/adaptor/mint.ts

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

package/src/core/adaptor/output.ts

@@ -0,0 +1,34 @@
+import { Output, PlutusScript } from "@meshsdk/common";
+
+import { builderDataToCbor } from "./data";
+
+export const outputToObj = (output: Output): object => {
+  let datum: object | null = 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 as PlutusScript;
+
+  return {
+    address: output.address,
+    amount: output.amount,
+    datum,
+    referenceScript: output.referenceScript
+      ? {
+          providedScriptSource: {
+            scriptCbor: refScript.code,
+            languageVersion: refScript.version.toLocaleLowerCase(),
+          },
+        }
+      : null,
+  };
+};

package/src/core/adaptor/script.ts

@@ -0,0 +1,52 @@
+import {
+  PlutusScript,
+  ScriptSource,
+  SimpleScriptSourceInfo,
+} from "@meshsdk/common";
+
+export const scriptSourceToObj = (scriptSource: ScriptSource): object => {
+  if (scriptSource.type === "Provided") {
+    return {
+      providedScriptSource: {
+        scriptCbor: scriptSource.script.code,
+        languageVersion: (
+          scriptSource.script as PlutusScript
+        ).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: SimpleScriptSourceInfo,
+): object => {
+  if (scriptSource.type === "Provided") {
+    return {
+      providedSimpleScriptSource: {
+        scriptCbor: scriptSource.scriptCode,
+      },
+    };
+  }
+
+  return {
+    inlineSimpleScriptSource: {
+      refTxIn: {
+        txHash: scriptSource.txHash,
+        txIndex: scriptSource.txIndex,
+      },
+      simpleScriptHash: scriptSource.simpleScriptHash ?? "",
+    },
+  };
+};

package/src/core/adaptor/txIn.ts

@@ -0,0 +1,81 @@
+import { ScriptTxInParameter, TxIn, TxInParameter } from "@meshsdk/common";
+
+import { builderDataToCbor, redeemerToObj } from "./data";
+import { scriptSourceToObj } from "./script";
+
+export const txInToObj = (txIn: TxIn): object => {
+  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: TxIn): object => {
+  return {
+    txIn: txInParameterToObj(txIn.txIn),
+  };
+};
+
+export const txInParameterToObj = (txInParameter: TxInParameter): object => {
+  return {
+    txHash: txInParameter.txHash,
+    txIndex: txInParameter.txIndex,
+    amount: txInParameter.amount ?? null,
+    address: txInParameter.address ?? null,
+  };
+};
+
+export const scriptTxInParameterToObj = (
+  scriptTxInParameter: ScriptTxInParameter,
+): object => {
+  let scriptSource: object | null = null;
+  let datumSource: object | null = 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/src/core/adaptor/utxo.ts

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

package/src/core/adaptor/withdrawal.ts

@@ -0,0 +1,37 @@
+import { Withdrawal } from "@meshsdk/common";
+
+import { redeemerToObj } from "./data";
+import { scriptSourceToObj } from "./script";
+
+export const withdrawalToObj = (withdrawal: Withdrawal): object => {
+  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/src/core/index.ts

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

package/src/core/serializer.ts

@@ -0,0 +1,162 @@
+/* eslint-disable default-case */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable radix */
+import JSONbig from "json-bigint";
+
+import type {
+  BuilderData,
+  Data,
+  DeserializedAddress,
+  DeserializedScript,
+  IDeserializer,
+  IMeshTxSerializer,
+  IResolver,
+  MeshTxBuilderBody,
+  NativeScript,
+  PlutusScript,
+  Protocol,
+} from "@meshsdk/common";
+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 implements IMeshTxSerializer {
+  protocolParams: Protocol;
+
+  meshTxBuilderBody: MeshTxBuilderBody = emptyTxBuilderBody();
+
+  constructor(protocolParams?: Protocol) {
+    this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
+  }
+
+  serializeTxBody(
+    txBody: MeshTxBuilderBody,
+    protocolParams?: Protocol,
+  ): string {
+    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: string, signingKeys: string[]): string {
+    if (signingKeys.length > 0) {
+      return signTransaction(txHex, signingKeys);
+    }
+    return txHex;
+  }
+
+  serializeData(data: BuilderData): string {
+    return builderDataToCbor(data);
+  }
+
+  serializeAddress(
+    address: Partial<DeserializedAddress>,
+    networkId?: number,
+  ): string {
+    return serialzeAddress(address, networkId);
+  }
+
+  deserializer: IDeserializer = {
+    key: {
+      deserializeAddress: function (bech32: string): DeserializedAddress {
+        return deserializeBech32Address(bech32);
+      },
+    },
+    script: {
+      deserializeNativeScript: function (
+        script: NativeScript,
+      ): DeserializedScript {
+        const nativeScript = toNativeScript(script);
+        const scriptCbor = nativeScript.to_hex();
+        const scriptHash = nativeScript.hash().to_hex();
+        return {
+          scriptHash,
+          scriptCbor,
+        };
+      },
+      deserializePlutusScript: function (
+        script: PlutusScript,
+      ): DeserializedScript {
+        const scriptHash = deserializePlutusScript(script.code, script.version)
+          .hash()
+          .to_hex();
+        return { scriptHash, scriptCbor: script.code };
+      },
+    },
+  };
+
+  resolver: IResolver = {
+    keys: {
+      resolveStakeKeyHash: function (bech32: string): string {
+        return (
+          rewardAddressToKeyHash(bech32) ||
+          deserializeBech32Address(bech32).stakeCredentialHash
+        );
+      },
+      // resolveStakeScriptHash: function (bech32: string): string {
+      //   return (
+      //     rewardAddressToKeyHash(bech32) ||
+      //     serializeBech32Address(bech32).stakeScriptCredentialHash
+      //   );
+      // },
+      resolvePrivateKey: function (words: string[]): string {
+        return resolvePrivateKey(words);
+      },
+      resolveRewardAddress: function (bech32: string): string {
+        return resolveRewardAddress(bech32);
+      },
+      resolveEd25519KeyHash: function (bech32: string): string {
+        return resolveEd25519KeyHash(bech32);
+      },
+    },
+    tx: {
+      resolveTxHash: function (txHex: string): string {
+        return calculateTxHash(txHex);
+      },
+    },
+    data: {
+      resolveDataHash: function (data: Data): string {
+        return resolveDataHash(data);
+      },
+    },
+    script: {
+      resolveScriptRef: function (script: PlutusScript | NativeScript): string {
+        return resolveScriptRef(script);
+      },
+    },
+    pool: {
+      resolvePoolId: function (hash: string): string {
+        return resolvePoolId(hash);
+      },
+    },
+  };
+}

package/src/deser/constants.ts

@@ -0,0 +1,16 @@
+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;