@meshsdk/common 1.5.30 → 1.6.0-alpha.20

package/test/data/json/primitives.test.ts

@@ -0,0 +1,133 @@
+import JSONBig from "json-bigint";
+
+import {
+  assocMap,
+  bool,
+  ByteString,
+  byteString,
+  integer,
+  List,
+  list,
+  plutusBSArrayToString,
+  stringToPlutusBSArray,
+} from "../../../src";
+
+const testByteString = { bytes: "abcd" };
+
+describe("Plutus data type", () => {
+  describe("bool", () => {
+    test("bool - true", () => {
+      const result = bool(true);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 1, fields: [] }),
+      );
+    });
+    test("bool - false", () => {
+      const result = bool(false);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 0, fields: [] }),
+      );
+    });
+  });
+
+  describe("byteString", () => {
+    test("byteString - valid hex", () => {
+      const hexString = "00112233445566aabbccddeeff";
+      const result = byteString(hexString);
+      expect(JSON.stringify(result)).toBe(JSON.stringify({ bytes: hexString }));
+    });
+    test("byteString - invalid hex - odd length", () => {
+      const hexString = "00112233445566aabbccddeef";
+      expect(() => byteString(hexString)).toThrow();
+    });
+    test("byteString - invalid hex - non hex string", () => {
+      const hexString = "00112233445566aabbccddeeffgg";
+      expect(() => byteString(hexString)).toThrow();
+    });
+  });
+
+  describe("integer", () => {
+    test("integer - number", () => {
+      const testNumber = 1234567890;
+      const result = integer(testNumber);
+      expect(JSON.stringify(result)).toBe(JSON.stringify({ int: testNumber }));
+    });
+    test("integer - bigint", () => {
+      const testBigInt = 1234567890123456789012345678901234567890n;
+      const result = integer(testBigInt);
+      expect(JSONBig.stringify(result)).toBe(
+        JSONBig.stringify({ int: testBigInt }),
+      );
+    });
+  });
+
+  describe("list", () => {
+    test("list - valid", () => {
+      const result = list([testByteString, testByteString, testByteString]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({
+          list: [testByteString, testByteString, testByteString],
+        }),
+      );
+    });
+    test("list - invalid non-JSON items", () => {
+      expect(() =>
+        list([testByteString, testByteString, testByteString.bytes]),
+      ).toThrow();
+    });
+  });
+
+  describe("assocMap", () => {
+    test("assocMap", () => {
+      const result = assocMap([
+        ["key1", "value1"],
+        ["key2", "value2"],
+      ]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({
+          map: [
+            { k: "key1", v: "value1" },
+            { k: "key2", v: "value2" },
+          ],
+        }),
+      );
+    });
+  });
+});
+
+describe("String List of byte array conversion", () => {
+  const testString =
+    "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461";
+  const testList: List<ByteString> = {
+    list: [
+      {
+        bytes:
+          "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374",
+      },
+      {
+        bytes:
+          "696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbd",
+      },
+      {
+        bytes:
+          "d3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b19",
+      },
+      {
+        bytes:
+          "1be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e6577",
+      },
+      {
+        bytes: "77616c2e616461",
+      },
+    ],
+  };
+
+  test("stringToPlutusBSArray", () => {
+    const result = stringToPlutusBSArray(testString);
+    expect(JSON.stringify(testList)).toBe(JSON.stringify(result));
+  });
+  test("plutusBSArrayToString", () => {
+    const result = plutusBSArrayToString(testList);
+    expect(result).toBe(testString);
+  });
+});

package/test/data/mesh/aliases.test.ts

@@ -0,0 +1,45 @@
+import {
+  assetClass,
+  mAssetClass,
+  mOutputReference,
+  mTxOutRef,
+  outputReference,
+  txOutRef,
+} from "../../../src";
+import { serializeData } from "./common";
+
+const testHash = "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700";
+const testTxHash =
+  "a0bd47e8938e7c41d4c1d7c22033892319d28f86fdace791d45c51946553791b";
+describe("Plutus data type", () => {
+  describe("assetClass", () => {
+    test("assetClass", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mAssetClass(testHash, "abcd"),
+        assetClass(testHash, "abcd"),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+  describe("outputReference", () => {
+    test("outputReference", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mOutputReference(testTxHash, 1),
+        outputReference(testTxHash, 1),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("outputReference - invalid length", () => {
+      expect(() => mOutputReference(testHash, 1)).toThrow;
+    });
+  });
+  describe("txOutRef", () => {
+    test("txOutRef", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mTxOutRef(testTxHash, 1),
+        txOutRef(testTxHash, 1),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+});

package/test/data/mesh/common.ts

@@ -0,0 +1,14 @@
+import { castDataToPlutusData } from "../../../../mesh-core-csl";
+import { Data } from "../../../src";
+
+export const serializeData = (mesh: Data, json: any) => {
+  const meshData = castDataToPlutusData({
+    type: "Mesh",
+    content: mesh,
+  }).to_hex();
+  const jsonData = castDataToPlutusData({
+    type: "JSON",
+    content: JSON.stringify(json),
+  }).to_hex();
+  return [meshData, jsonData];
+};

package/test/data/mesh/constructors.test.ts

@@ -0,0 +1,53 @@
+import {
+  byteString,
+  conStr,
+  conStr0,
+  conStr1,
+  conStr2,
+  Data,
+  mConStr,
+  mConStr0,
+  mConStr1,
+  mConStr2,
+} from "../../../src";
+import { serializeData } from "./common";
+
+const testByteString = "abcd";
+
+describe("Plutus data type", () => {
+  describe("constructor", () => {
+    test("mConStr", () => {
+      const mesh = mConStr(0, [testByteString]);
+      const [meshCbor, jsonCbor] = serializeData(
+        mesh,
+        conStr(0, [byteString(testByteString)]),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+
+    test("mConStr0", () => {
+      const mesh = mConStr0([testByteString]);
+      const [meshCbor, jsonCbor] = serializeData(
+        mesh,
+        conStr0([byteString(testByteString)]),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("mConStr1", () => {
+      const mesh = mConStr1([testByteString]);
+      const [meshCbor, jsonCbor] = serializeData(
+        mesh,
+        conStr1([byteString(testByteString)]),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("mConStr2", () => {
+      const mesh = mConStr2([testByteString]);
+      const [meshCbor, jsonCbor] = serializeData(
+        mesh,
+        conStr2([byteString(testByteString)]),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+});

package/test/data/mesh/credentials.test.ts

@@ -0,0 +1,74 @@
+import {
+  conStr0,
+  conStr1,
+  maybeStakingHash,
+  mMaybeStakingHash,
+  mPubKeyAddress,
+  mScriptAddress,
+  pubKeyAddress,
+  pubKeyHash,
+  scriptAddress,
+  scriptHash,
+} from "../../../src";
+import { serializeData } from "./common";
+
+const testKeyHash1 = "1e4eb194e3335a0dcc4f5c5d009318167c583bb3b0879d9f718cd9e0";
+const testKeyHash2 = "d63a93470bd4d8bb986c02ff8a6043796b91cc397ceb29058f5c9ac0";
+
+describe("Plutus data type", () => {
+  describe("maybeStakingHash", () => {
+    test("maybeStakingHash - no staking hash", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mMaybeStakingHash(""),
+        maybeStakingHash(""),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("maybeStakingHash - pub key staking hash", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mMaybeStakingHash(testKeyHash1),
+        maybeStakingHash(testKeyHash1),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("maybeStakingHash - script staking hash", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mMaybeStakingHash(testKeyHash1, true),
+        maybeStakingHash(testKeyHash1, true),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+  describe("pubKeyAddress", () => {
+    test("pubKeyAddress", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mPubKeyAddress(testKeyHash1),
+        pubKeyAddress(testKeyHash1),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("pubKeyAddress - full base address", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mPubKeyAddress(testKeyHash1, testKeyHash2),
+        pubKeyAddress(testKeyHash1, testKeyHash2),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+  describe("scriptAddress", () => {
+    test("scriptAddress", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mScriptAddress(testKeyHash1),
+        scriptAddress(testKeyHash1),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("scriptAddress - full base address", () => {
+      const [meshCbor, jsonCbor] = serializeData(
+        mScriptAddress(testKeyHash1, testKeyHash2),
+        scriptAddress(testKeyHash1, testKeyHash2),
+      );
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+});

package/test/data/mesh/primitives.test.ts

@@ -0,0 +1,41 @@
+import {
+  bool,
+  mBool,
+  mPlutusBSArrayToString,
+  mStringToPlutusBSArray,
+} from "../../../src";
+import { serializeData } from "./common";
+
+describe("Plutus data type", () => {
+  describe("bool", () => {
+    test("bool - true", () => {
+      const [meshCbor, jsonCbor] = serializeData(mBool(true), bool(true));
+      expect(meshCbor).toBe(jsonCbor);
+    });
+    test("bool - false", () => {
+      const [meshCbor, jsonCbor] = serializeData(mBool(false), bool(false));
+      expect(meshCbor).toBe(jsonCbor);
+    });
+  });
+});
+
+describe("String List of byte array conversion", () => {
+  const testString =
+    "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461";
+  const testList: string[] = [
+    "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374",
+    "696e676e657777616c2e616461baefdc6c5b191be372a794cd8d40d839ec0dbd",
+    "d3c28957267dc8170074657374696e676e657777616c2e616461baefdc6c5b19",
+    "1be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e6577",
+    "77616c2e616461",
+  ];
+
+  test("stringToPlutusBSArray", () => {
+    const result = mStringToPlutusBSArray(testString);
+    expect(JSON.stringify(testList)).toBe(JSON.stringify(result));
+  });
+  test("plutusBSArrayToString", () => {
+    const result = mPlutusBSArrayToString(testList);
+    expect(result).toBe(testString);
+  });
+});

package/test/data/value.test.ts

@@ -0,0 +1,108 @@
+import {
+  Asset,
+  byteString,
+  ByteString,
+  dict,
+  Dict,
+  Integer,
+  integer,
+  parsePlutusValueToAssets,
+  Value,
+  value,
+} from "../../src";
+
+describe("value", () => {
+  test("Simple ADA Value", () => {
+    const val: Asset[] = [{ unit: "lovelace", quantity: "1000000" }];
+    const datum: Value = value(val);
+
+    const nameMap = dict<Integer>([[byteString(""), integer(1000000)]]);
+    const valMap = dict<Dict<Integer>>([[byteString(""), nameMap]]);
+    expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+  });
+  test("Simple token Value", () => {
+    const val: Asset[] = [
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461",
+        quantity: "345",
+      },
+    ];
+    const datum: Value = value(val);
+
+    const nameMap = dict<Integer>([
+      [byteString("74657374696e676e657777616c2e616461"), integer(345)],
+    ]);
+    const valMap = dict<Dict<Integer>>([
+      [
+        byteString("baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700"),
+        nameMap,
+      ],
+    ]);
+    expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+  });
+  test("Complex Value", () => {
+    const val: Asset[] = [
+      { unit: "lovelace", quantity: "1000000" },
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461",
+        quantity: "345",
+      },
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc817001234",
+        quantity: "567",
+      },
+    ];
+    const datum: Value = value(val);
+
+    const nameMap = dict<Integer>([
+      [byteString("1234"), integer(567)],
+      [byteString("74657374696e676e657777616c2e616461"), integer(345)],
+    ]);
+    const valMap = dict<Dict<Integer>>([
+      [byteString(""), dict([[byteString(""), integer(1000000)]])],
+      [
+        byteString("baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700"),
+        nameMap,
+      ],
+    ]);
+    expect(JSON.stringify(datum)).toBe(JSON.stringify(valMap));
+  });
+});
+
+describe("Value", () => {
+  test("Simple ADA Value", () => {
+    const val: Asset[] = [{ unit: "lovelace", quantity: "1000000" }];
+    const plutusValue: Value = value(val);
+    const assets: Asset[] = parsePlutusValueToAssets(plutusValue);
+
+    expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+  });
+  test("Simple token Value", () => {
+    const val: Asset[] = [
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461",
+        quantity: "345",
+      },
+    ];
+    const plutusValue: Value = value(val);
+    const assets: Asset[] = parsePlutusValueToAssets(plutusValue);
+
+    expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+  });
+  test("Complex Value", () => {
+    const val: Asset[] = [
+      { unit: "lovelace", quantity: "1000000" },
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc817001234",
+        quantity: "567",
+      },
+      {
+        unit: "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc8170074657374696e676e657777616c2e616461",
+        quantity: "345",
+      },
+    ];
+    const plutusValue: Value = value(val);
+    const assets: Asset[] = parsePlutusValueToAssets(plutusValue);
+    expect(JSON.stringify(val)).toBe(JSON.stringify(assets));
+  });
+});

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@meshsdk/typescript-config/base.json",
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
+}