@meshsdk/common 1.6.0-alpha.21 → 1.6.1

package/src/data/json/primitives.ts

@@ -1,154 +0,0 @@
-import { PlutusData } from ".";
-import { ConStr0, conStr0, ConStr1, conStr1 } from "./constructors";
-
-/**
- * The Plutus Data boolean in JSON
- */
-export type Bool = ConStr0<[]> | ConStr1<[]>;
-
-/**
- * The Plutus Data byte string, representing in hex, in JSON
- */
-export type BuiltinByteString = { bytes: string };
-
-/**
- * The Plutus Data byte string, representing in hex, in JSON
- */
-export type ByteString = { bytes: string };
-
-/**
- * The Plutus Data integer in JSON
- */
-export type Integer = { int: number | bigint };
-
-/**
- * The Plutus Data list in JSON
- */
-export type List<T = any> = { list: T[] };
-
-/**
- * PlutusTx alias
- * The Plutus Data association map item in JSON
- */
-export type AssocMapItem<K, V> = { k: K; v: V };
-
-/**
- * The Plutus Data association map in JSON
- */
-export type AssocMap<K = any, V = any> = { map: AssocMapItem<K, V>[] };
-
-/**
- * The utility function to create a Plutus Data boolean in JSON
- * @param b boolean value
- * @returns The Plutus Data boolean object
- */
-export const bool = (b: boolean): Bool =>
-  b ? conStr1<[]>([]) : conStr0<[]>([]);
-
-/**
- * The utility function to create a Plutus Data byte string in JSON
- * @param bytes The byte string in hex
- * @returns The Plutus Data byte string object
- */
-export const builtinByteString = (bytes: string): BuiltinByteString => {
-  return byteString(bytes);
-};
-
-/**
- * The utility function to create a Plutus Data byte string in JSON
- * @param bytes The byte string in hex
- * @returns The Plutus Data byte string object
- */
-export const byteString = (bytes: string): ByteString => {
-  // check if the string is a hex string with regex
-  if (bytes.length % 2 !== 0) {
-    throw new Error("Invalid hex string - odd length: " + bytes);
-  }
-  if (!/^[0-9a-fA-F]*$/.test(bytes)) {
-    throw new Error("Invalid hex string - non-hex string character: " + bytes);
-  }
-  return {
-    bytes,
-  };
-};
-
-/**
- * The utility function to create a Plutus Data integer in JSON
- * @param int The integer value
- * @returns The Plutus Data integer object
- */
-export const integer = (int: number | bigint): Integer => ({ int });
-
-/**
- * The utility function to create a Plutus Data list in JSON
- * @param pList The list of Plutus Data
- * @param validation Default true - If current data construction would perform validation (introducing this flag due to possible performance issue in loop validation)
- * @returns The Plutus Data list object
- */
-export const list = <T = PlutusData>(
-  pList: T[],
-  validation = true,
-): List<T> => {
-  if (validation) {
-    pList.forEach((item) => {
-      if (typeof item !== "object") {
-        throw new Error(
-          "List item of JSON Cardano data type must be an object - " + item,
-        );
-      }
-    });
-  }
-
-  return { list: pList };
-};
-
-/**
- * Converting a hex string into a ByteString Array, with max 32 bytes on each items
- * @param hexString The hex string to be converted into ByteString Array
- * @returns The ByteString Array representation of the hex string
- */
-export const stringToBSArray = (hexString: string): List<ByteString> => {
-  const processRawStringIntoPlutusByteArray = (hexString: string): string[] => {
-    const chunks = [];
-    for (let i = 0; i < hexString.length; i += 64) {
-      const chunk = hexString.substring(i, i + 64);
-      chunks.push(chunk);
-    }
-    return chunks;
-  };
-
-  return list(
-    processRawStringIntoPlutusByteArray(hexString).map(builtinByteString),
-  );
-};
-
-/**
- * Converting ByteString Array into a single string
- * @param bsArray The ByteString Array to be converted into a single string
- * @returns The string representation of the ByteString Array
- */
-export const plutusBSArrayToString = (bsArray: List<ByteString>): string => {
-  return bsArray.list.map((bs) => bs.bytes).join("");
-};
-
-/**
- * The utility function to create a Plutus Data association map in JSON
- * @param mapItems The items map in array
- * @param validation Default true - If current data construction would perform validation (introducing this flag due to possible performance issue in loop validation)
- * @returns The Plutus Data association map object
- */
-export const assocMap = <K, V>(
-  mapItems: [K, V][],
-  validation = true,
-): AssocMap<K, V> => ({
-  map: mapItems.map(([k, v]) => {
-    if (validation) {
-      if (typeof k !== "object" || typeof v !== "object") {
-        throw new Error(
-          `Map item of JSON Cardano data type must be an object - ${k}, ${v}`,
-        );
-      }
-    }
-    return { k, v };
-  }),
-});

package/src/data/mesh/aliases.ts

@@ -1,85 +0,0 @@
-import { POLICY_ID_LENGTH } from "../../constants";
-import { Data } from "../../types";
-import { mConStr0, MConStr0 } from "./constructors";
-
-/**
- * PlutusTx alias
- * The Mesh Data asset class
- */
-export type MAssetClass = MConStr0<[string, string]>;
-
-/**
- * Aiken alias
- * The Mesh Data output reference
- */
-export type MOutputReference = MConStr0<[MConStr0<[string]>, number]>;
-
-/**
- * PlutusTx alias
- * The Mesh Data TxOutRef
- */
-export type MTxOutRef = MConStr0<[MConStr0<[string]>, number]>;
-
-/**
- * Aiken alias
- * The Mesh Data tuple
- */
-export type MTuple<K, V> = [K, V];
-
-/**
- * The utility function to create a Mesh Data asset class
- * @param currencySymbolHex The currency symbol in hex
- * @param tokenNameHex The token name in hex
- * @returns The Mesh Data asset class object
- */
-export const mAssetClass = (
-  currencySymbolHex: string,
-  tokenNameHex: string,
-): MAssetClass => {
-  if (currencySymbolHex.length !== 56 && currencySymbolHex !== "") {
-    throw new Error(
-      `Invalid policy id for [${currencySymbolHex}] - should be ${POLICY_ID_LENGTH} bytes long or empty string for lovelace`,
-    );
-  }
-
-  if (tokenNameHex.length > 64) {
-    throw new Error(
-      `Invalid asset name for [${tokenNameHex}] - should be less than 32 bytes (64 hex length) long`,
-    );
-  }
-
-  return mConStr0([currencySymbolHex, tokenNameHex]);
-};
-
-/**
- * The utility function to create a Mesh Data output reference in Mesh Data type
- * @param txHash The transaction hash
- * @param index The index of the output
- * @returns The Mesh Data output reference object
- */
-export const mOutputReference = (
-  txHash: string,
-  index: number,
-): MOutputReference => {
-  if (txHash.length !== 64) {
-    throw new Error("Invalid transaction hash - should be 32 bytes long");
-  }
-  return mConStr0([mConStr0([txHash]), index]);
-};
-
-/**
- * The utility function to create a Mesh Data TxOutRef in Mesh Data type
- * @param txHash The transaction hash
- * @param index The index of the output
- * @returns The Mesh Data TxOutRef object
- */
-export const mTxOutRef = (txHash: string, index: number): MTxOutRef =>
-  mOutputReference(txHash, index);
-
-/**
- * The utility function to create a Mesh Data tuple in Mesh Data type
- * @param key The key of the tuple
- * @param value The value of the tuple
- * @returns The Mesh Data tuple object
- */
-export const mTuple = <K, V>(key: K, value: V): MTuple<K, V> => [key, value];

package/src/data/mesh/constructors.ts

@@ -1,68 +0,0 @@
-import { Data } from "../../types";
-
-/**
- * The Mesh Data constructor object, representing custom data type
- */
-export type MConStr<T = any> = { alternative: number; fields: T };
-
-/**
- * The Mesh Data index 0 constructor object, representing custom data type
- */
-export type MConStr0<T = any> = MConStr<T>;
-
-/**
- * The Mesh Data index 1 constructor object, representing custom data type
- */
-export type MConStr1<T = any> = MConStr<T>;
-
-/**
- * The Mesh Data index 2 constructor object, representing custom data type
- */
-export type MConStr2<T = any> = MConStr<T>;
-
-/**
- * The utility function to create a Mesh Data constructor object, representing custom data type
- * @param alternative The constructor index number
- * @param fields The items in array
- * @returns The Mesh Data constructor object
- */
-export const mConStr = <T extends Data[]>(
-  alternative: number,
-  fields: T,
-): MConStr<T> => ({
-  alternative,
-  fields,
-});
-
-/**
- * The utility function to create a Mesh Data index 0 constructor object, representing custom data type
- * @param alternative The constructor index number
- * @param fields The items in array
- * @returns The Mesh Data constructor object
- */
-export const mConStr0 = <T extends Data[]>(fields: T): MConStr0<T> => ({
-  alternative: 0,
-  fields,
-});
-
-/**
- * The utility function to create a Mesh Data index 1 constructor object, representing custom data type
- * @param alternative The constructor index number
- * @param fields The items in array
- * @returns The Mesh Data constructor object
- */
-export const mConStr1 = <T extends Data[]>(fields: T): MConStr1<T> => ({
-  alternative: 1,
-  fields,
-});
-
-/**
- * The utility function to create a Mesh Data index 2 constructor object, representing custom data type
- * @param alternative The constructor index number
- * @param fields The items in array
- * @returns The Mesh Data constructor object
- */
-export const mConStr2 = <T extends Data[]>(fields: T): MConStr2<T> => ({
-  alternative: 2,
-  fields,
-});

package/src/data/mesh/credentials.ts

@@ -1,77 +0,0 @@
-import { Data } from "../../types";
-import { mConStr0, MConStr0, mConStr1, MConStr1 } from "./constructors";
-
-/**
- * The Mesh Data staking credential
- */
-export type MMaybeStakingHash =
-  | MConStr1<[]>
-  | MConStr0<[MConStr0<[MConStr0<[string]>]>]>
-  | MConStr0<[MConStr0<[MConStr1<[string]>]>]>;
-
-/**
- * The Mesh Data public key address
- */
-export type MPubKeyAddress = MConStr0<[MConStr0<[string]>, MMaybeStakingHash]>;
-
-/**
- * The Mesh Data script address
- */
-export type MScriptAddress = MConStr0<[MConStr1<[string]>, MMaybeStakingHash]>;
-
-/**
- * The utility function to create a Mesh Data staking hash
- * @param stakeCredential The staking credential in hex
- * @param isScriptCredential The flag to indicate if the credential is a script credential
- * @returns The Mesh Data staking hash object
- */
-export const mMaybeStakingHash = (
-  stakeCredential: string,
-  isScriptCredential = false,
-): MMaybeStakingHash => {
-  if (stakeCredential === "") {
-    return mConStr1<[]>([]);
-  }
-  if (isScriptCredential) {
-    return mConStr0([mConStr0([mConStr1([stakeCredential])])]) as MConStr0<
-      [MConStr0<[MConStr1<[string]>]>]
-    >;
-  }
-  return mConStr0([mConStr0([mConStr0([stakeCredential])])]) as MConStr0<
-    [MConStr0<[MConStr1<[string]>]>]
-  >;
-};
-
-/**
- * The utility function to create a Mesh Data public key address
- * @param bytes The public key hash in hex
- * @param stakeCredential The staking credential in hex
- * @param isScriptCredential The flag to indicate if the credential is a script credential
- * @returns The Mesh Data public key address object
- */
-export const mPubKeyAddress = (
-  bytes: string,
-  stakeCredential?: string,
-  isScriptCredential = false,
-): Data =>
-  mConStr0([
-    { alternative: 0, fields: [bytes] },
-    mMaybeStakingHash(stakeCredential || ""),
-  ]);
-
-/**
- * The utility function to create a Mesh Data script address
- * @param bytes The validator hash in hex
- * @param stakeCredential The staking credential in hex
- * @param isScriptCredential The flag to indicate if the credential is a script credential
- * @returns The Mesh Data script address object
- */
-export const mScriptAddress = (
-  bytes: string,
-  stakeCredential?: string,
-  isScriptCredential = false,
-): Data =>
-  mConStr0([
-    { alternative: 1, fields: [bytes] },
-    mMaybeStakingHash(stakeCredential || ""),
-  ]);

package/src/data/mesh/index.ts

@@ -1,4 +0,0 @@
-export * from "./aliases";
-export * from "./constructors";
-export * from "./credentials";
-export * from "./primitives";

package/src/data/mesh/primitives.ts

@@ -1,37 +0,0 @@
-import { MConStr0, mConStr0, MConStr1, mConStr1 } from "./constructors";
-
-/**
- * The Mesh Data boolean
- */
-export type MBool = MConStr0<[]> | MConStr1<[]>;
-
-/**
- * The utility function to create a Mesh Data boolean
- * @param b boolean value
- * @returns The Mesh Data boolean object
- */
-export const mBool = (b: boolean): MBool =>
-  b ? mConStr1<[]>([]) : mConStr0<[]>([]);
-
-/**
- * Converting a hex string into a BuiltinByteString Array, with max 32 bytes on each items
- * @param hexString The hex string to be converted into BuiltinByteString Array
- * @returns The BuiltinByteString Array representation of the hex string
- */
-export const mStringToPlutusBSArray = (hexString: string): string[] => {
-  const chunks = [];
-  for (let i = 0; i < hexString.length; i += 64) {
-    const chunk = hexString.substring(i, i + 64);
-    chunks.push(chunk);
-  }
-  return chunks;
-};
-
-/**
- * Converting BuiltinByteString Array into a single string
- * @param bsArray The BuiltinByteString Array to be converted into a single string
- * @returns The string representation of the BuiltinByteString Array
- */
-export const mPlutusBSArrayToString = (bsArray: string[]): string => {
-  return bsArray.join("");
-};

package/src/data/parser.ts

@@ -1,36 +0,0 @@
-import { POLICY_ID_LENGTH } from "../constants";
-
-export const bytesToHex = (bytes: ArrayBuffer) =>
-  Buffer.from(bytes).toString("hex");
-
-export const hexToBytes = (hex: string) => Buffer.from(hex, "hex");
-
-export const stringToHex = (str: string) =>
-  Buffer.from(str, "utf8").toString("hex");
-
-export const hexToString = (hex: string) =>
-  Buffer.from(hex, "hex").toString("utf8");
-
-export const toBytes = (hex: string): Uint8Array => {
-  if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex))
-    return Buffer.from(hex, "hex");
-
-  return Buffer.from(hex, "utf-8");
-};
-
-export const fromUTF8 = (utf8: string) => {
-  if (utf8.length % 2 === 0 && /^[0-9A-F]*$/i.test(utf8)) return utf8;
-  return bytesToHex(Buffer.from(utf8, "utf-8"));
-};
-
-export const toUTF8 = (hex: string) =>
-  Buffer.from(hex, "hex").toString("utf-8");
-
-export const parseAssetUnit = (unit: string) => {
-  const policyId = unit.slice(0, POLICY_ID_LENGTH);
-  const assetName = unit.includes(".")
-    ? fromUTF8(unit.split(".")[1] as string)
-    : unit.slice(POLICY_ID_LENGTH);
-
-  return { policyId, assetName };
-};

package/src/data/time.ts

@@ -1,92 +0,0 @@
-import { Network } from "../types";
-
-export type SlotConfig = {
-  zeroTime: number;
-  zeroSlot: number;
-  slotLength: number; // number of milliseconds.
-  startEpoch: number;
-  epochLength: number;
-};
-
-// export const SUPPORTED_CLOCKS: Record<
-//   Network,
-//   [epoch: string, slot: string, systemStart: string, epochLength: string]
-// > = {
-//   testnet: ["74", "1598400", "1595967616", "432000"],
-//   preview: ["183", "15811222", "1682467200", "86400"],
-//   preprod: ["65", "26438400", "1682121600", "432000"],
-//   mainnet: ["208", "4492800", "1596059091", "432000"],
-// };
-
-export const SLOT_CONFIG_NETWORK: Record<Network, SlotConfig> = {
-  mainnet: {
-    zeroTime: 1596059091000,
-    zeroSlot: 4492800,
-    slotLength: 1000,
-    startEpoch: 208,
-    epochLength: 432000,
-  }, // Starting at Shelley era
-  preview: {
-    zeroTime: 1666656000000,
-    zeroSlot: 0,
-    slotLength: 1000,
-    startEpoch: 183,
-    epochLength: 86400,
-  }, // Starting at Shelley era
-  preprod: {
-    zeroTime: 1654041600000 + 1728000000,
-    zeroSlot: 86400,
-    slotLength: 1000,
-    startEpoch: 65,
-    epochLength: 432000,
-  }, // Starting at Shelley era
-  /** Customizable slot config (Initialized with 0 values). */
-  testnet: {
-    zeroTime: 0,
-    zeroSlot: 0,
-    slotLength: 0,
-    startEpoch: 0,
-    epochLength: 0,
-  },
-};
-
-export const slotToBeginUnixTime = (
-  slot: number,
-  slotConfig: SlotConfig,
-): number => {
-  const msAfterBegin = (slot - slotConfig.zeroSlot) * slotConfig.slotLength;
-  return slotConfig.zeroTime + msAfterBegin;
-};
-
-export const unixTimeToEnclosingSlot = (
-  unixTime: number,
-  slotConfig: SlotConfig,
-): number => {
-  const timePassed = unixTime - slotConfig.zeroTime;
-  const slotsPassed = Math.floor(timePassed / slotConfig.slotLength);
-  return slotsPassed + slotConfig.zeroSlot;
-};
-
-export const resolveSlotNo = (
-  network: Network,
-  milliseconds = Date.now(),
-): string => {
-  return unixTimeToEnclosingSlot(
-    milliseconds,
-    SLOT_CONFIG_NETWORK[network],
-  ).toString();
-};
-
-export const resolveEpochNo = (
-  network: Network,
-  milliseconds = Date.now(),
-): number => {
-  const config = SLOT_CONFIG_NETWORK[network];
-
-  const msBigInt = BigInt(milliseconds);
-  const epoch =
-    (msBigInt / 1000n - BigInt(config.zeroTime)) / BigInt(config.epochLength) +
-    BigInt(config.startEpoch);
-
-  return Number(epoch);
-};

package/src/data/value.ts

@@ -1,70 +0,0 @@
-/**
- * It is suggested to keep the value representation as map of map,
- * where first key as policy id, second key as asset name, and final value as quantity.
- */
-
-import { Asset } from "../types";
-import {
-  assocMap,
-  AssocMap,
-  CurrencySymbol,
-  currencySymbol,
-  Integer,
-  integer,
-  TokenName,
-  tokenName,
-} from "./json";
-
-export type Value = AssocMap<CurrencySymbol, AssocMap<TokenName, Integer>>;
-
-export type MValue = Map<string, Map<string, bigint>>;
-
-export const value = (assets: Asset[]): Value => {
-  const valueMapToParse: [CurrencySymbol, AssocMap<TokenName, Integer>][] = [];
-  const valueMap: { [key: string]: { [key: string]: number } } = {};
-
-  assets.forEach((asset) => {
-    const sanitizedName = asset.unit.replace("lovelace", "");
-    const policy = sanitizedName.slice(0, 56) || "";
-    const token = sanitizedName.slice(56) || "";
-
-    if (!valueMap[policy]) {
-      valueMap[policy] = {};
-    }
-
-    if (!valueMap[policy]![token]) {
-      valueMap[policy]![token] = Number(asset.quantity);
-    } else {
-      valueMap[policy]![token] += Number(asset.quantity);
-    }
-  });
-
-  Object.keys(valueMap).forEach((policy) => {
-    const policyByte = currencySymbol(policy);
-    const tokens: [TokenName, Integer][] = Object.keys(valueMap[policy]!).map(
-      (name) => [tokenName(name), integer(valueMap[policy]![name]!)],
-    );
-
-    const policyMap = assocMap(tokens);
-    valueMapToParse.push([policyByte, policyMap]);
-  });
-
-  return assocMap(valueMapToParse);
-};
-
-export const parsePlutusValueToAssets = (plutusValue: Value): Asset[] => {
-  const assets: Asset[] = [];
-
-  plutusValue.map.forEach((policyMap) => {
-    const policy = policyMap.k.bytes;
-    policyMap.v.map.forEach((tokenMap) => {
-      const token = tokenMap.k.bytes;
-      const quantity = tokenMap.v.int.toString();
-      const unsanitizedUnit = policy + token;
-      const unit = unsanitizedUnit === "" ? "lovelace" : unsanitizedUnit;
-      assets.push({ unit, quantity });
-    });
-  });
-
-  return assets;
-};

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from "./constants";
-export * from "./interfaces";
-export * from "./types";
-export * from "./data";
-export * from "./utils";
-
-export { generateMnemonic, mnemonicToEntropy } from "bip39";

package/src/interfaces/evaluator.ts

@@ -1,5 +0,0 @@
-import { Action } from "../types";
-
-export interface IEvaluator {
-  evaluateTx(tx: string): Promise<Omit<Action, "data">[]>;
-}

package/src/interfaces/fetcher.ts

@@ -1,31 +0,0 @@
-import type {
-  AccountInfo,
-  Asset,
-  AssetMetadata,
-  BlockInfo,
-  Protocol,
-  TransactionInfo,
-  UTxO,
-} from "../types";
-
-/**
- * Fetcher interface defines end points to query blockchain data.
- */
-export interface IFetcher {
-  fetchAccountInfo(address: string): Promise<AccountInfo>;
-  fetchAddressUTxOs(address: string, asset?: string): Promise<UTxO[]>;
-  fetchAssetAddresses(
-    asset: string,
-  ): Promise<{ address: string; quantity: string }[]>;
-  fetchAssetMetadata(asset: string): Promise<AssetMetadata>;
-  fetchBlockInfo(hash: string): Promise<BlockInfo>;
-  fetchCollectionAssets(
-    policyId: string,
-    cursor?: number | string,
-  ): Promise<{ assets: Asset[]; next?: string | number | null }>;
-  fetchHandle(handle: string): Promise<object>;
-  fetchHandleAddress(handle: string): Promise<string>;
-  fetchProtocolParameters(epoch: number): Promise<Protocol>;
-  fetchTxInfo(hash: string): Promise<TransactionInfo>;
-  fetchUTxOs(hash: string): Promise<UTxO[]>;
-}

package/src/interfaces/index.ts

@@ -1,7 +0,0 @@
-export * from "./fetcher";
-export * from "./initiator";
-export * from "./listener";
-export * from "./submitter";
-export * from "./serializer";
-export * from "./signer";
-export * from "./evaluator";

package/src/interfaces/initiator.ts

@@ -1,9 +0,0 @@
-import { UTxO } from "../types";
-
-export interface IInitiator {
-  getChangeAddress(): SometimesPromise<string>;
-  getCollateral(): SometimesPromise<UTxO[]>;
-  getUtxos(): SometimesPromise<UTxO[]>;
-}
-
-type SometimesPromise<T> = Promise<T> | T;