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

package/src/interfaces/listener.ts

@@ -0,0 +1,3 @@
+export interface IListener {
+  onTxConfirmed(txHash: string, callback: () => void, limit?: number): void;
+}

package/src/interfaces/serializer.ts

@@ -0,0 +1,53 @@
+import {
+  BuilderData,
+  Data,
+  DeserializedAddress,
+  DeserializedScript,
+  MeshTxBuilderBody,
+  NativeScript,
+  Network,
+  PlutusScript,
+  Protocol,
+} from "../types";
+
+export interface IMeshTxSerializer {
+  serializeTxBody(
+    txBuilderBody: MeshTxBuilderBody,
+    protocolParams: Protocol,
+  ): string;
+  addSigningKeys(txHex: string, signingKeys: string[]): string;
+  resolver: IResolver;
+  deserializer: IDeserializer;
+  serializeData(data: BuilderData): string;
+  serializeAddress(address: DeserializedAddress, networkId?: 0 | 1): string;
+}
+export interface IResolver {
+  keys: {
+    resolvePrivateKey(words: string[]): string;
+    resolveRewardAddress(bech32: string): string;
+    resolveEd25519KeyHash(bech32: string): string;
+    resolveStakeKeyHash(bech32: string): string;
+  };
+  tx: {
+    resolveTxHash(txHex: string): string;
+  };
+  data: {
+    resolveDataHash(data: Data): string;
+  };
+  script: {
+    resolveScriptRef(script: NativeScript | PlutusScript): string;
+  };
+  pool: {
+    resolvePoolId(hash: string): string;
+  };
+}
+
+export interface IDeserializer {
+  key: {
+    deserializeAddress(bech32: string): DeserializedAddress;
+  };
+  script: {
+    deserializeNativeScript(script: NativeScript): DeserializedScript;
+    deserializePlutusScript(script: PlutusScript): DeserializedScript;
+  };
+}

package/src/interfaces/signer.ts

@@ -0,0 +1,12 @@
+import { DataSignature } from "../types";
+
+export interface ISigner {
+  signData(address: string, payload: string): SometimesPromise<DataSignature>;
+  signTx(unsignedTx: string, partialSign: boolean): SometimesPromise<string>;
+  signTxs(
+    unsignedTxs: string[],
+    partialSign: boolean,
+  ): SometimesPromise<string[]>;
+}
+
+type SometimesPromise<T> = Promise<T> | T;

package/src/interfaces/submitter.ts

@@ -0,0 +1,3 @@
+export interface ISubmitter {
+  submitTx(tx: string): Promise<string>;
+}

package/src/types/account-info.ts

@@ -0,0 +1,7 @@
+export type AccountInfo = {
+  active: boolean;
+  poolId?: string;
+  balance: string;
+  rewards: string;
+  withdrawals: string;
+};

package/src/types/action.ts

@@ -0,0 +1,15 @@
+import { Data } from "./data";
+
+export type RedeemerTagType = "CERT" | "MINT" | "REWARD" | "SPEND";
+
+export type Action = {
+  data: Data;
+  index: number;
+  budget: Budget;
+  tag: RedeemerTagType;
+};
+
+export type Budget = {
+  mem: number;
+  steps: number;
+};

package/src/types/asset-extended.ts

@@ -0,0 +1,9 @@
+import { Quantity, Unit } from "./asset";
+
+export type AssetExtended = {
+  unit: Unit;
+  policyId: string;
+  assetName: string;
+  fingerprint: string;
+  quantity: Quantity;
+};

package/src/types/asset-metadata.ts

@@ -0,0 +1,102 @@
+import { Data } from "./data";
+
+export type RoyaltiesStandard = {
+  rate: string;
+  address: string;
+};
+
+export const royaltiesStandardKeys = ["rate", "address"];
+
+// export type MetadataStandard = {
+//   name: string;
+//   image: `${string}://${string}`;
+//   mediaType?: `image/${string}`;
+//   description?: string | string[];
+//   instagram?: `https://instagram.com/${string}`;
+//   twitter?: `https://twitter.com/${string}`;
+//   discord?: `https://discord.gg/${string}`;
+//   website?: `https://${string}`;
+//   metadata?: object;
+// };
+type MetadataStandard = any;
+
+export const metadataStandardKeys = [
+  "name",
+  "image",
+  "mediaType",
+  "description",
+  "instagram",
+  "twitter",
+  "discord",
+  "website",
+];
+
+export type Files = {
+  files?: [
+    {
+      name: string;
+      src: `${string}://${string}`;
+      mediaType: `${string}/${string}`;
+    },
+  ];
+};
+
+export type AssetMetadata =
+  | FungibleAssetMetadata
+  | NonFungibleAssetMetadata
+  | RoyaltiesStandard;
+
+export type FungibleAssetMetadata = MetadataStandard & {
+  ticker: string;
+  decimals: number;
+  version: `${number}.${number}`;
+};
+
+export const fungibleAssetKeys = ["ticker", "decimals"];
+
+export type NonFungibleAssetMetadata =
+  | AudioAssetMetadata
+  | ImageAssetMetadata
+  | SmartAssetMetadata
+  | VideoAssetMetadata;
+
+type AudioAssetMetadata = MetadataStandard & Files;
+
+export type ImageAssetMetadata = MetadataStandard &
+  Files & {
+    artists?: [
+      {
+        name: string;
+        twitter?: `https://twitter.com/${string}`;
+      },
+    ];
+    attributes?: {
+      [key: string]: string;
+    };
+    traits?: string[];
+  };
+
+type SmartAssetMetadata = MetadataStandard & Files;
+
+type VideoAssetMetadata = MetadataStandard & Files;
+
+export const metadataToCip68 = (metadata: any): Data => {
+  switch (typeof metadata) {
+    case "object":
+      if (metadata instanceof Array) {
+        return metadata.map((item) => metadataToCip68(item));
+      }
+      const metadataMap = new Map();
+      const keys = Object.keys(metadata);
+      keys.forEach((key) => {
+        metadataMap.set(key, metadataToCip68(metadata[key]));
+      });
+      return {
+        alternative: 0,
+        fields: [metadataMap, 1],
+      };
+
+    default:
+      return metadata;
+  }
+};

package/src/types/asset.ts

@@ -0,0 +1,23 @@
+export type Asset = {
+  unit: Unit;
+  quantity: Quantity;
+};
+
+export type Unit = string;
+
+export type Quantity = string;
+
+export const mergeAssets = (assets: Asset[]): Asset[] => {
+  const merged: Asset[] = [];
+  assets.forEach((asset) => {
+    const existing = merged.find((a) => a.unit === asset.unit);
+    if (existing) {
+      existing.quantity = (
+        BigInt(existing.quantity) + BigInt(asset.quantity)
+      ).toString();
+    } else {
+      merged.push(asset);
+    }
+  });
+  return merged;
+};

package/src/types/block-info.ts

@@ -0,0 +1,17 @@
+export type BlockInfo = {
+  time: number;
+  hash: string;
+  slot: string;
+  epoch: number;
+  epochSlot: string;
+  slotLeader: string;
+  size: number;
+  txCount: number;
+  output: string;
+  fees: string;
+  previousBlock: string;
+  nextBlock: string;
+  confirmations: number;
+  operationalCertificate: string;
+  VRFKey: string;
+};

package/src/types/data-signature.ts

@@ -0,0 +1,4 @@
+export type DataSignature = {
+  signature: string;
+  key: string;
+};

package/src/types/data.ts

@@ -0,0 +1,10 @@
+export type Data =
+  | string
+  | number
+  | bigint
+  | Array<Data>
+  | Map<Data, Data>
+  | {
+      alternative: number;
+      fields: Array<Data>;
+    };

package/src/types/deserialized/deserialized-address.ts

@@ -0,0 +1,6 @@
+export type DeserializedAddress = {
+  pubKeyHash: string;
+  scriptHash: string;
+  stakeCredentialHash: string;
+  stakeScriptCredentialHash: string;
+};

package/src/types/deserialized/deserialized-script.ts

@@ -0,0 +1,4 @@
+export type DeserializedScript = {
+  scriptHash: string;
+  scriptCbor?: string;
+};

package/src/types/deserialized/index.ts

@@ -0,0 +1,2 @@
+export * from "./deserialized-address";
+export * from "./deserialized-script";

package/src/types/era.ts

@@ -0,0 +1 @@
+export type Era = "ALONZO" | "BABBAGE";

package/src/types/index.ts

@@ -0,0 +1,24 @@
+export * from "./account-info";
+export * from "./action";
+export * from "./asset";
+export * from "./asset-extended";
+export * from "./asset-metadata";
+export * from "./block-info";
+export * from "./data";
+export * from "./data-signature";
+export * from "./era";
+export * from "./message";
+export * from "./mint";
+export * from "./native-script";
+export * from "./network";
+export * from "./plutus-script";
+export * from "./pool-params";
+export * from "./protocol";
+export * from "./recipient";
+export * from "./relay";
+export * from "./token";
+export * from "./transaction-info";
+export * from "./utxo";
+export * from "./wallet";
+export * from "./transaction-builder";
+export * from "./deserialized";

package/src/types/message.ts

@@ -0,0 +1,4 @@
+export type Message = {
+  payload: string;
+  externalAAD?: string;
+};

package/src/types/mint.ts

@@ -0,0 +1,12 @@
+import { Quantity } from "./asset";
+import { AssetMetadata } from "./asset-metadata";
+import { Recipient } from "./recipient";
+
+export type Mint = {
+  assetName: string;
+  assetQuantity: Quantity;
+  recipient?: Recipient;
+  metadata?: AssetMetadata;
+  label?: "20" | "721" | "777" | `${number}`;
+  cip68ScriptAddress?: string;
+};

package/src/types/native-script.ts

@@ -0,0 +1,18 @@
+export type NativeScript =
+  | {
+      type: "after" | "before";
+      slot: string;
+    }
+  | {
+      type: "all" | "any";
+      scripts: NativeScript[];
+    }
+  | {
+      type: "atLeast";
+      required: number;
+      scripts: NativeScript[];
+    }
+  | {
+      type: "sig";
+      keyHash: string;
+    };

package/src/types/network.ts

@@ -0,0 +1,7 @@
+const ALL_NETWORKS = ["testnet", "preview", "preprod", "mainnet"] as const;
+
+export type Network = (typeof ALL_NETWORKS)[number];
+
+export const isNetwork = (value: unknown): value is Network => {
+  return ALL_NETWORKS.includes(value as Network);
+};

package/src/types/plutus-script.ts

@@ -0,0 +1,8 @@
+import { LANGUAGE_VERSIONS } from "../constants";
+
+export type PlutusScript = {
+  version: LanguageVersion;
+  code: string;
+};
+
+export type LanguageVersion = keyof typeof LANGUAGE_VERSIONS;

package/src/types/pool-params.ts

@@ -0,0 +1,41 @@
+import { Relay, relayToObj } from "./relay";
+
+export type PoolParams = {
+  vrfKeyHash: string;
+  operator: string;
+  pledge: string;
+  cost: string;
+  margin: [number, number];
+  relays: Relay[];
+  owners: string[];
+  rewardAddress: string;
+  metadata?: PoolMetadata;
+};
+
+export const poolParamsToObj = (poolParams: PoolParams): object => {
+  return {
+    vrfKeyHash: poolParams.vrfKeyHash,
+    operator: poolParams.operator,
+    pledge: poolParams.pledge,
+    cost: poolParams.cost,
+    margin: poolParams.margin,
+    relays: poolParams.relays.map((relay) => relayToObj(relay)),
+    owners: poolParams.owners,
+    rewardAddress: poolParams.rewardAddress,
+    metadata: poolParams.metadata
+      ? poolMetadataToObj(poolParams.metadata)
+      : undefined,
+  };
+};
+
+export type PoolMetadata = {
+  URL: string;
+  hash: string;
+};
+
+export const poolMetadataToObj = (poolMetadata: PoolMetadata): object => {
+  return {
+    url: poolMetadata.URL,
+    metadata: poolMetadata.hash,
+  };
+};

package/src/types/protocol.ts

@@ -0,0 +1,22 @@
+export type Protocol = {
+  epoch: number;
+  minFeeA: number;
+  minFeeB: number;
+  maxBlockSize: number;
+  maxTxSize: number;
+  maxBlockHeaderSize: number;
+  keyDeposit: number;
+  poolDeposit: number;
+  decentralisation: number;
+  minPoolCost: string;
+  priceMem: number;
+  priceStep: number;
+  maxTxExMem: string;
+  maxTxExSteps: string;
+  maxBlockExMem: string;
+  maxBlockExSteps: string;
+  maxValSize: number;
+  collateralPercent: number;
+  maxCollateralInputs: number;
+  coinsPerUtxoSize: number;
+};

package/src/types/recipient.ts

@@ -0,0 +1,15 @@
+import { Data } from "./data";
+
+// import { NativeScript } from './native-script';
+// import { PlutusScript } from './plutus-script';
+
+export type Recipient =
+  | string
+  | {
+      address: string;
+      datum?: {
+        value: Data;
+        inline?: boolean;
+      };
+      // script?: PlutusScript | NativeScript;
+    };

package/src/types/relay.ts

@@ -0,0 +1,42 @@
+export type Relay =
+  | {
+      type: "SingleHostAddr";
+      IPV4?: string;
+      IPV6?: string;
+      port?: number;
+    }
+  | {
+      type: "SingleHostName";
+      domainName: string;
+      port?: number;
+    }
+  | {
+      type: "MultiHostName";
+      domainName: string;
+    };
+
+export const relayToObj = (relay: Relay): object => {
+  switch (relay.type) {
+    case "SingleHostAddr":
+      return {
+        singleHostAddr: {
+          ipv4: relay.IPV4,
+          ipv6: relay.IPV6,
+          port: relay.port,
+        },
+      };
+    case "SingleHostName":
+      return {
+        singleHostName: {
+          hostname: relay.domainName,
+          port: relay.port,
+        },
+      };
+    case "MultiHostName":
+      return {
+        multiHostName: {
+          dnsName: relay.domainName,
+        },
+      };
+  }
+};

package/{dist/cjs/types/Token.d.ts → src/types/token.ts}

@@ -1,2 +1,3 @@
-import { SUPPORTED_TOKENS } from '../constants';
+import { SUPPORTED_TOKENS } from "../constants";
+
 export type Token = keyof typeof SUPPORTED_TOKENS;

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

@@ -0,0 +1,31 @@
+import { Budget, Data } from "..";
+
+export type BuilderData =
+  | {
+      type: "Mesh";
+      content: Data;
+    }
+  | {
+      type: "JSON";
+      content: object | string;
+    }
+  | {
+      type: "CBOR";
+      content: string;
+    };
+
+export type Redeemer = {
+  data: BuilderData;
+  exUnits: Budget;
+};
+
+export type DatumSource =
+  | {
+      type: "Provided";
+      data: BuilderData;
+    }
+  | {
+      type: "Inline";
+      txHash: string;
+      txIndex: number;
+    };

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

@@ -0,0 +1,73 @@
+import { UTxO } from "../utxo";
+import { MintItem } from "./mint";
+import { Output } from "./output";
+import { PubKeyTxIn, RefTxIn, TxIn } from "./txin";
+import { Certificate, Withdrawal } from "./withdrawal";
+
+export * from "./data";
+export * from "./mint";
+export * from "./output";
+export * from "./script";
+export * from "./txin";
+export * from "./withdrawal";
+
+export type MeshTxBuilderBody = {
+  inputs: TxIn[];
+  outputs: Output[];
+  extraInputs: UTxO[];
+  selectionThreshold: number;
+  collaterals: PubKeyTxIn[];
+  requiredSignatures: string[];
+  referenceInputs: RefTxIn[];
+  mints: MintItem[];
+  changeAddress: string;
+  metadata: Metadata[];
+  validityRange: ValidityRange;
+  certificates: Certificate[];
+  withdrawals: Withdrawal[];
+  signingKey: string[];
+};
+
+export const emptyTxBuilderBody = (): MeshTxBuilderBody => ({
+  inputs: [],
+  outputs: [],
+  extraInputs: [],
+  selectionThreshold: 0,
+  collaterals: [],
+  requiredSignatures: [],
+  referenceInputs: [],
+  mints: [],
+  changeAddress: "",
+  metadata: [],
+  validityRange: {},
+  certificates: [],
+  withdrawals: [],
+  signingKey: [],
+});
+
+// Here
+
+export type ValidityRange = {
+  invalidBefore?: number;
+  invalidHereafter?: number;
+};
+
+// Mint Types
+
+export type Metadata = {
+  tag: string;
+  metadata: string;
+};
+
+// Utilities
+
+export type RequiredWith<T, K extends keyof T> = Required<T> & {
+  [P in K]: Required<T[P]>;
+};
+
+export const validityRangeToObj = (validityRange: ValidityRange): object => {
+  return {
+    invalidBefore: validityRange.invalidBefore ?? null,
+    invalidHereafter: validityRange.invalidHereafter ?? null,
+  };
+};

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

@@ -0,0 +1,11 @@
+import { Redeemer } from "./data";
+import { ScriptSource, SimpleScriptSourceInfo } from "./script";
+
+export type MintItem = {
+  type: "Plutus" | "Native";
+  policyId: string;
+  assetName: string;
+  amount: string;
+  redeemer?: Redeemer;
+  scriptSource?: ScriptSource | SimpleScriptSourceInfo;
+};

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

@@ -0,0 +1,12 @@
+import { Asset, PlutusScript } from "..";
+import { BuilderData } from "./data";
+
+export type Output = {
+  address: string;
+  amount: Asset[];
+  datum?: {
+    type: "Hash" | "Inline";
+    data: BuilderData;
+  };
+  referenceScript?: PlutusScript;
+};

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

@@ -0,0 +1,27 @@
+import { LanguageVersion, PlutusScript } from "..";
+
+export type ScriptSource =
+  | {
+      type: "Provided";
+      script: PlutusScript;
+    }
+  | {
+      type: "Inline";
+      txHash: string;
+      txIndex: number;
+      scriptHash?: string;
+      scriptSize?: string;
+      version?: LanguageVersion;
+    };
+
+export type SimpleScriptSourceInfo =
+  | {
+      type: "Provided";
+      scriptCode: string;
+    }
+  | {
+      type: "Inline";
+      txHash: string;
+      txIndex: number;
+      simpleScriptHash: string;
+    };