@meshsdk/common 1.6.0-alpha.21 → 1.6.2

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

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

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

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

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

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

package/src/utils/asset-fingerprint.ts

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

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

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

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

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

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

@@ -1,84 +0,0 @@
-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),
-          ]),
-        ),
-      );
-    });
-  });
-});