@meshsdk/common 1.0.0-alpha.8 → 1.6.0-alpha.11

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"]
+}

package/dist/cjs/builder/data/index.d.ts

@@ -1,4 +0,0 @@
-export * from './mesh';
-export * from './plutus';
-export * from './parser';
-export * from './time';

package/dist/cjs/builder/data/index.js

@@ -1,20 +0,0 @@
-"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("./mesh"), exports);
-__exportStar(require("./plutus"), exports);
-__exportStar(require("./parser"), exports);
-__exportStar(require("./time"), exports);

package/dist/cjs/builder/data/mesh.d.ts

@@ -1,8 +0,0 @@
-import { Data } from '../../types';
-export declare const mConStr: <T extends Data[]>(alternative: number, fields: T) => Data;
-export declare const mConStr0: <T extends Data[]>(fields: T) => Data;
-export declare const mConStr1: <T extends Data[]>(fields: T) => Data;
-export declare const mConStr2: <T extends Data[]>(fields: T) => Data;
-export declare const mMaybeStakingHash: (stakeCredential: string) => Data;
-export declare const mPubKeyAddress: (bytes: string, stakeCredential?: string) => Data;
-export declare const mScriptAddress: (bytes: string, stakeCredential?: string) => Data;

package/dist/cjs/builder/data/mesh.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mScriptAddress = exports.mPubKeyAddress = exports.mMaybeStakingHash = exports.mConStr2 = exports.mConStr1 = exports.mConStr0 = exports.mConStr = void 0;
-const mConStr = (alternative, fields) => ({
-    alternative,
-    fields,
-});
-exports.mConStr = mConStr;
-const mConStr0 = (fields) => ({
-    alternative: 0,
-    fields,
-});
-exports.mConStr0 = mConStr0;
-const mConStr1 = (fields) => ({
-    alternative: 1,
-    fields,
-});
-exports.mConStr1 = mConStr1;
-const mConStr2 = (fields) => ({
-    alternative: 2,
-    fields,
-});
-exports.mConStr2 = mConStr2;
-const mMaybeStakingHash = (stakeCredential) => {
-    if (stakeCredential === '') {
-        return (0, exports.mConStr1)([]);
-    }
-    return (0, exports.mConStr0)([(0, exports.mConStr0)([(0, exports.mConStr0)([stakeCredential])])]);
-};
-exports.mMaybeStakingHash = mMaybeStakingHash;
-const mPubKeyAddress = (bytes, stakeCredential) => (0, exports.mConStr0)([{ alternative: 0, fields: [bytes] }, (0, exports.mMaybeStakingHash)(stakeCredential || '')]);
-exports.mPubKeyAddress = mPubKeyAddress;
-const mScriptAddress = (bytes, stakeCredential) => (0, exports.mConStr0)([{ alternative: 1, fields: [bytes] }, (0, exports.mMaybeStakingHash)(stakeCredential || '')]);
-exports.mScriptAddress = mScriptAddress;

package/dist/cjs/builder/data/parser.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" />
-export declare const bytesToHex: (bytes: ArrayBuffer) => string;
-export declare const hexToBytes: (hex: string) => Buffer;
-export declare const stringToHex: (str: string) => string;
-export declare const hexToString: (hex: string) => string;

package/dist/cjs/builder/data/parser.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexToString = exports.stringToHex = exports.hexToBytes = exports.bytesToHex = void 0;
-const bytesToHex = (bytes) => Buffer.from(bytes).toString('hex');
-exports.bytesToHex = bytesToHex;
-const hexToBytes = (hex) => Buffer.from(hex, 'hex');
-exports.hexToBytes = hexToBytes;
-const stringToHex = (str) => Buffer.from(str, 'utf8').toString('hex');
-exports.stringToHex = stringToHex;
-const hexToString = (hex) => Buffer.from(hex, 'hex').toString('utf8');
-exports.hexToString = hexToString;

package/dist/cjs/builder/data/plutus.d.ts

@@ -1,69 +0,0 @@
-import { Asset } from '../../types';
-export type ConStr<N = any, T = any> = {
-    constructor: N;
-    fields: T;
-};
-export type ConStr0<T = any> = ConStr<0, T>;
-export type ConStr1<T = any> = ConStr<1, T>;
-export type ConStr2<T = any> = ConStr<2, T>;
-export type Bool = ConStr0<[]> | ConStr1<[]>;
-export type BuiltinByteString = {
-    bytes: string;
-};
-export type Integer = {
-    int: number;
-};
-export type List = {
-    list: PlutusData[];
-};
-export type ValidatorHash = BuiltinByteString;
-export type PaymentPubKeyHash = BuiltinByteString;
-export type PubKeyHash = PaymentPubKeyHash;
-export type POSIXTime = Integer;
-export type CurrencySymbol = BuiltinByteString;
-export type TokenName = BuiltinByteString;
-export type MaybeStakingHash = ConStr1<[]> | ConStr0<[ConStr0<[ConStr0<[BuiltinByteString]>]>]>;
-export type PubKeyAddress = ConStr0<[ConStr0<[PubKeyHash]>, MaybeStakingHash]>;
-export type ScriptAddress = ConStr0<[ConStr1<[ValidatorHash]>, MaybeStakingHash]>;
-export type AssetClass = ConStr0<[CurrencySymbol, TokenName]>;
-export type TxOutRef = ConStr0<[ConStr0<[BuiltinByteString]>, Integer]>;
-export type AssocMapItem<K, V> = {
-    k: K;
-    v: V;
-};
-export type DictItem<K, V> = {
-    k: K;
-    v: V;
-};
-export type AssocMap<K, V> = {
-    map: AssocMapItem<K, V>[];
-};
-export type Dict<K, V> = {
-    map: DictItem<K, V>[];
-};
-export type Tuple<K, V> = ConStr0<[K, V]>;
-export type Value = AssocMap<CurrencySymbol, AssocMap<TokenName, Integer>>;
-export type PlutusData = BuiltinByteString | Integer | MaybeStakingHash | PubKeyAddress | ScriptAddress | AssetClass | PaymentPubKeyHash | PubKeyHash | POSIXTime | TxOutRef;
-export declare const conStr: <N, T>(constructor: N, fields: T) => ConStr<N, T>;
-export declare const conStr0: <T>(fields: T) => ConStr0<T>;
-export declare const conStr1: <T>(fields: T) => ConStr1<T>;
-export declare const conStr2: <T>(fields: T) => ConStr2<T>;
-export declare const bool: (b: boolean) => Bool;
-export declare const builtinByteString: (bytes: string) => BuiltinByteString;
-export declare const integer: (int: number) => Integer;
-export declare const list: (pList: PlutusData[]) => List;
-export declare const currencySymbol: (bytes: string) => CurrencySymbol;
-export declare const tokenName: (bytes: string) => TokenName;
-export declare const maybeStakingHash: (stakeCredential: string) => MaybeStakingHash;
-export declare const pubKeyAddress: (bytes: string, stakeCredential?: string) => PubKeyAddress;
-export declare const scriptAddress: (bytes: string, stakeCredential?: string) => ScriptAddress;
-export declare const assetClass: (policyId: string, assetName: string) => AssetClass;
-export declare const txOutRef: (txHash: string, index: number) => TxOutRef;
-export declare const paymentPubKeyHash: (bytes: string) => PaymentPubKeyHash;
-export declare const pubKeyHash: (bytes: string) => PubKeyHash;
-export declare const posixTime: (int: number) => POSIXTime;
-export declare const assocMap: <K, V>(itemsMap: [K, V][]) => AssocMap<K, V>;
-export declare const dict: <K, V>(itemsMap: [K, V][]) => AssocMap<K, V>;
-export declare const tuple: <K, V>(key: K, value: V) => Tuple<K, V>;
-export declare const value: (assets: Asset[]) => Value;
-export declare const parsePlutusValueToAssets: (plutusValue: Value) => Asset[];