@meshsdk/common 1.5.30 → 1.6.0-alpha.20

package/src/types/transaction-builder/txin.ts

@@ -0,0 +1,46 @@
+import { Asset } from "../asset";
+import { DatumSource, Redeemer } from "./data";
+import { ScriptSource, SimpleScriptSourceInfo } from "./script";
+
+export type RefTxIn = { txHash: string; txIndex: number };
+
+export type TxInParameter = {
+  txHash: string;
+  txIndex: number;
+  amount?: Asset[];
+  address?: string;
+};
+
+export type TxIn = PubKeyTxIn | SimpleScriptTxIn | ScriptTxIn;
+
+export type PubKeyTxIn = { type: "PubKey"; txIn: TxInParameter };
+
+export type SimpleScriptTxIn = {
+  type: "SimpleScript";
+  txIn: TxInParameter;
+  simpleScriptTxIn: SimpleScriptTxInParameter;
+};
+
+export type SimpleScriptTxInParameter = {
+  scriptSource?:
+    | {
+        type: "Provided";
+        script: string;
+      }
+    | {
+        type: "Inline";
+        txInInfo: SimpleScriptSourceInfo;
+      };
+};
+
+export type ScriptTxInParameter = {
+  scriptSource?: ScriptSource;
+  datumSource?: DatumSource;
+  redeemer?: Redeemer;
+};
+
+export type ScriptTxIn = {
+  type: "Script";
+  txIn: TxInParameter;
+  scriptTxIn: ScriptTxInParameter;
+};

package/src/types/transaction-builder/withdrawal.ts

@@ -0,0 +1,207 @@
+import { PoolParams, poolParamsToObj } from "..";
+import { Redeemer } from "./data";
+import { ScriptSource } from "./script";
+
+export type Certificate =
+  | { type: "RegisterPool"; poolParams: PoolParams }
+  | { type: "RegisterStake"; stakeKeyHash: string }
+  | { type: "DelegateStake"; stakeKeyHash: string; poolId: string }
+  | { type: "DeregisterStake"; stakeKeyHash: string }
+  | { type: "RetirePool"; poolId: string; epoch: number }
+  | { type: "VoteDelegation"; stakeKeyHash: string; drep: DRep }
+  | {
+      type: "StakeAndVoteDelegation";
+      stakeKeyHash: string;
+      poolKeyHash: string;
+      drep: DRep;
+    }
+  | {
+      type: "StakeRegistrationAndDelegation";
+      stakeKeyHash: string;
+      poolKeyHash: string;
+      coin: number;
+    }
+  | {
+      type: "VoteRegistrationAndDelegation";
+      stakeKeyHash: string;
+      drep: DRep;
+      coin: number;
+    }
+  | {
+      type: "StakeVoteRegistrationAndDelegation";
+      stakeKeyHash: string;
+      poolKeyHash: string;
+      drep: DRep;
+      coin: number;
+    }
+  | {
+      type: "CommitteeHotAuth";
+      committeeColdKeyHash: string;
+      committeeHotKeyHash: string;
+    }
+  | {
+      type: "CommitteeColdResign";
+      committeeColdKeyHash: string;
+      anchor?: Anchor;
+    }
+  | {
+      type: "DRepRegistration";
+      votingKeyHash: string;
+      coin: number;
+      anchor?: Anchor;
+    }
+  | {
+      type: "DRepDeregistration";
+      votingKeyHash: string;
+      coin: number;
+    }
+  | {
+      type: "DRepUpdate";
+      votingKeyHash: string;
+      anchor: Anchor;
+    };
+
+export type DRep =
+  | { keyHash: string }
+  | { scriptHash: string }
+  | {
+      alwaysAbstain: {};
+    }
+  | {
+      alwaysNoConfidence: {};
+    };
+
+export type Anchor = {
+  anchorUrl: string;
+  anchorDataHash: string;
+};
+
+export type Withdrawal =
+  | {
+      pubKeyWithdrawal: {
+        address: string;
+        coin: string;
+      };
+    }
+  | {
+      plutusScriptWithdrawal: {
+        address: string;
+        coin: string;
+        scriptSource?: ScriptSource;
+        redeemer?: Redeemer;
+      };
+    };
+
+export const certificateToObj = (certificate: Certificate): object => {
+  switch (certificate.type) {
+    case "RegisterPool":
+      return {
+        registerPool: {
+          poolParams: poolParamsToObj(certificate.poolParams),
+        },
+      };
+    case "RegisterStake":
+      return {
+        registerStake: {
+          stakeKeyHash: certificate.stakeKeyHash,
+        },
+      };
+    case "DelegateStake":
+      return {
+        delegateStake: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          poolId: certificate.poolId,
+        },
+      };
+    case "DeregisterStake":
+      return {
+        deregisterStake: {
+          stakeKeyHash: certificate.stakeKeyHash,
+        },
+      };
+    case "RetirePool":
+      return {
+        retirePool: {
+          poolId: certificate.poolId,
+          epoch: certificate.epoch,
+        },
+      };
+    case "VoteDelegation":
+      return {
+        voteDelegation: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          drep: certificate.drep,
+        },
+      };
+    case "StakeAndVoteDelegation":
+      return {
+        stakeAndVoteDelegation: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          poolKeyHash: certificate.poolKeyHash,
+          drep: certificate.drep,
+        },
+      };
+    case "StakeRegistrationAndDelegation":
+      return {
+        stakeRegistrationAndDelegation: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          poolKeyHash: certificate.poolKeyHash,
+          coin: certificate.coin,
+        },
+      };
+    case "VoteRegistrationAndDelegation":
+      return {
+        voteRegistrationAndDelegation: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          drep: certificate.drep,
+          coin: certificate.coin,
+        },
+      };
+    case "StakeVoteRegistrationAndDelegation":
+      return {
+        stakeVoteRegistrationAndDelegation: {
+          stakeKeyHash: certificate.stakeKeyHash,
+          poolKeyHash: certificate.poolKeyHash,
+          drep: certificate.drep,
+          coin: certificate.coin,
+        },
+      };
+    case "CommitteeHotAuth":
+      return {
+        committeeHotAuth: {
+          committeeColdKeyHash: certificate.committeeColdKeyHash,
+          committeeHotKeyHash: certificate.committeeHotKeyHash,
+        },
+      };
+    case "CommitteeColdResign":
+      return {
+        committeeColdResign: {
+          committeeColdKeyHash: certificate.committeeColdKeyHash,
+          anchor: certificate.anchor ?? null,
+        },
+      };
+
+    case "DRepRegistration":
+      return {
+        dRepRegistration: {
+          votingKeyHash: certificate.votingKeyHash,
+          coin: certificate.coin,
+          anchor: certificate.anchor ?? null,
+        },
+      };
+    case "DRepDeregistration":
+      return {
+        dRepDeregistration: {
+          votingKeyHash: certificate.votingKeyHash,
+          coin: certificate.coin,
+        },
+      };
+    case "DRepUpdate":
+      return {
+        dRepUpdate: {
+          votingKeyHash: certificate.votingKeyHash,
+          anchor: certificate.anchor,
+        },
+      };
+  }
+};

package/src/types/transaction-info.ts

@@ -0,0 +1,11 @@
+export type TransactionInfo = {
+  index: number;
+  block: string;
+  hash: string;
+  slot: string;
+  fees: string;
+  size: number;
+  deposit: string;
+  invalidBefore: string;
+  invalidAfter: string;
+};

package/src/types/utxo.ts

@@ -0,0 +1,16 @@
+import { Asset } from "./asset";
+
+export type UTxO = {
+  input: {
+    outputIndex: number;
+    txHash: string;
+  };
+  output: {
+    address: string;
+    amount: Asset[];
+    dataHash?: string;
+    plutusData?: string;
+    scriptRef?: string;
+    scriptHash?: string;
+  };
+};

package/src/types/wallet.ts

@@ -0,0 +1,6 @@
+export type Wallet = {
+  id: string;
+  name: string;
+  icon: string;
+  version: string;
+};

package/src/utils/asset-fingerprint.ts

@@ -0,0 +1,11 @@
+import CIP14 from "@emurgo/cip14-js";
+
+import { toBytes } from "../data";
+
+export const AssetFingerprint = CIP14;
+
+export const resolveFingerprint = (policyId: string, assetName: string) => {
+  return (AssetFingerprint as any).default
+    .fromParts(toBytes(policyId), toBytes(assetName))
+    .fingerprint();
+};

package/src/utils/bigNum.ts

@@ -0,0 +1,61 @@
+export class BigNum {
+  value: bigint;
+
+  constructor(value: number | string) {
+    this.value = BigInt(value);
+  }
+
+  // Operators
+
+  divFloor(other: BigNum): BigNum {
+    this.value = this.value / other.value;
+    return this;
+  }
+
+  checkedMul(other: BigNum): BigNum {
+    this.value *= other.value;
+    return this;
+  }
+
+  checkedAdd(other: BigNum): BigNum {
+    this.value += other.value;
+    return this;
+  }
+
+  checkedSub(other: BigNum): BigNum {
+    this.value -= other.value;
+    return this;
+  }
+
+  clampedSub(other: BigNum): BigNum {
+    const result = this.value - other.value;
+    this.value = result < 0n ? 0n : result;
+    return this;
+  }
+
+  // Comparators
+
+  lessThan(other: BigNum): boolean {
+    return this.value < other.value;
+  }
+
+  compare(other: BigNum): -1 | 0 | 1 {
+    if (this.value === other.value) {
+      return 0;
+    } else if (this.value < other.value) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+
+  static new = (value: number | string): BigNum => {
+    return new BigNum(value);
+  };
+
+  // Override
+
+  toString(): string {
+    return this.value.toString();
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./bigNum";
+export * from "./asset-fingerprint";

package/test/data/json/aliases.test.ts

@@ -0,0 +1,135 @@
+import {
+  assetClass,
+  assetName,
+  assocMap,
+  byteString,
+  conStr0,
+  currencySymbol,
+  integer,
+  outputReference,
+  policyId,
+  posixTime,
+  pubKeyHash,
+  scriptHash,
+  tokenName,
+  tuple,
+  txOutRef,
+} from "../../../src";
+
+const testHash = "baefdc6c5b191be372a794cd8d40d839ec0dbdd3c28957267dc81700";
+const testTxHash =
+  "a0bd47e8938e7c41d4c1d7c22033892319d28f86fdace791d45c51946553791b";
+
+describe("Plutus byte hash types", () => {
+  describe("hashByteString", () => {
+    test("hashByteString - valid", () => {
+      const result = byteString(testHash);
+      expect(JSON.stringify(result)).toBe(JSON.stringify({ bytes: testHash }));
+    });
+    test("hashByteString - invalid string", () => {
+      expect(() => byteString("invalid string")).toThrow();
+    });
+  });
+  describe("scriptHash", () => {
+    test("scriptHash", () => {
+      const result = scriptHash(testHash);
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString(testHash)));
+    });
+  });
+  describe("pubKeyHash", () => {
+    test("pubKeyHash", () => {
+      const result = pubKeyHash(testHash);
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString(testHash)));
+    });
+  });
+});
+
+describe("Plutus data type", () => {
+  describe("policyId", () => {
+    test("policyId", () => {
+      const result = policyId(testHash);
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString(testHash)));
+    });
+  });
+  describe("currencySymbol", () => {
+    test("currencySymbol", () => {
+      const result = currencySymbol(testHash);
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString(testHash)));
+    });
+  });
+  describe("assetName", () => {
+    test("assetName", () => {
+      const result = assetName("abcd");
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString("abcd")));
+    });
+  });
+  describe("tokenName", () => {
+    test("tokenName", () => {
+      const result = tokenName("abcd");
+      expect(JSON.stringify(result)).toBe(JSON.stringify(byteString("abcd")));
+    });
+  });
+  describe("assetClass", () => {
+    test("assetClass", () => {
+      const result = assetClass(testHash, "abcd");
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(conStr0([currencySymbol(testHash), tokenName("abcd")])),
+      );
+    });
+  });
+  describe("outputReference", () => {
+    test("outputReference", () => {
+      const result = outputReference(testTxHash, 1);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([conStr0([byteString(testTxHash)]), integer(1)]),
+        ),
+      );
+    });
+    test("outputReference - invalid length", () => {
+      expect(() => outputReference(testHash, 1)).toThrow;
+    });
+  });
+  describe("txOutRef", () => {
+    test("txOutRef", () => {
+      const result = txOutRef(testTxHash, 1);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([conStr0([byteString(testTxHash)]), integer(1)]),
+        ),
+      );
+    });
+  });
+  describe("posixTime", () => {
+    test("posixTime", () => {
+      const result = posixTime(123456789000000);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(integer(123456789000000)),
+      );
+    });
+  });
+  describe("dict", () => {
+    test("dict", () => {
+      const result = assocMap([
+        ["key1", "value1"],
+        ["key2", "value2"],
+      ]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          assocMap([
+            ["key1", "value1"],
+            ["key2", "value2"],
+          ]),
+        ),
+      );
+    });
+  });
+  describe("tuple", () => {
+    test("tuple", () => {
+      const result = tuple({ bytes: "1234" }, { bytes: "abcd" });
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ list: [{ bytes: "1234" }, { bytes: "abcd" }] }),
+      );
+    });
+  });
+});

package/test/data/json/constructors.test.ts

@@ -0,0 +1,38 @@
+import { conStr, conStr0, conStr1, conStr2 } from "../../../src";
+
+const testByteString = { bytes: "abcd" };
+
+describe("Plutus data type", () => {
+  describe("constructor", () => {
+    test("conStr", () => {
+      const result = conStr(0, [testByteString]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 0, fields: [testByteString] }),
+      );
+    });
+    test("conStr0", () => {
+      const result = conStr0([testByteString]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 0, fields: [testByteString] }),
+      );
+    });
+    test("conStr1", () => {
+      const result = conStr1([testByteString]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 1, fields: [testByteString] }),
+      );
+    });
+    test("conStr2", () => {
+      const result = conStr2([testByteString]);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 2, fields: [testByteString] }),
+      );
+    });
+  });
+
+  describe("Input validation", () => {
+    test("Non array fields", () => {
+      expect(() => conStr(0, testByteString)).toThrow();
+    });
+  });
+});

package/test/data/json/credentials.test.ts

@@ -0,0 +1,84 @@
+import {
+  conStr0,
+  conStr1,
+  maybeStakingHash,
+  pubKeyAddress,
+  pubKeyHash,
+  scriptAddress,
+  scriptHash,
+} from "../../../src";
+
+const testKeyHash1 = "1e4eb194e3335a0dcc4f5c5d009318167c583bb3b0879d9f718cd9e0";
+const testKeyHash2 = "d63a93470bd4d8bb986c02ff8a6043796b91cc397ceb29058f5c9ac0";
+
+describe("Plutus data type", () => {
+  describe("maybeStakingHash", () => {
+    test("maybeStakingHash - no staking hash", () => {
+      const result = maybeStakingHash("");
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify({ constructor: 1, fields: [] }),
+      );
+    });
+    test("maybeStakingHash - pub key staking hash", () => {
+      const result = maybeStakingHash(testKeyHash1);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([conStr0([conStr0([pubKeyHash(testKeyHash1)])])]),
+        ),
+      );
+    });
+    test("maybeStakingHash - script staking hash", () => {
+      const result = maybeStakingHash(testKeyHash1, true);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([conStr0([conStr1([scriptHash(testKeyHash1)])])]),
+        ),
+      );
+    });
+  });
+  describe("pubKeyAddress", () => {
+    test("pubKeyAddress", () => {
+      const result = pubKeyAddress(testKeyHash1);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([conStr0([pubKeyHash(testKeyHash1)]), maybeStakingHash("")]),
+        ),
+      );
+    });
+    test("pubKeyAddress - full base address", () => {
+      const result = pubKeyAddress(testKeyHash1, testKeyHash2);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([
+            conStr0([pubKeyHash(testKeyHash1)]),
+            maybeStakingHash(testKeyHash2),
+          ]),
+        ),
+      );
+    });
+  });
+  describe("scriptAddress", () => {
+    test("scriptAddress", () => {
+      const result = scriptAddress(testKeyHash1, testKeyHash2);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([
+            conStr1([pubKeyHash(testKeyHash1)]),
+            maybeStakingHash(testKeyHash2),
+          ]),
+        ),
+      );
+    });
+    test("scriptAddress - full base address", () => {
+      const result = scriptAddress(testKeyHash1, testKeyHash2);
+      expect(JSON.stringify(result)).toBe(
+        JSON.stringify(
+          conStr0([
+            conStr1([pubKeyHash(testKeyHash1)]),
+            maybeStakingHash(testKeyHash2),
+          ]),
+        ),
+      );
+    });
+  });
+});