@bitgo/public-types 2.19.0 → 2.21.0

package/src/schema/mpcv2/signing/signingRound.ts

@@ -0,0 +1,113 @@
+import * as t from "io-ts";
+import {
+  MPCv2P2PMessage,
+  MPCv2BroadcastMessage,
+  MPCv2BroadcastMessageWithSignatureR,
+} from "../common";
+import { MPCv2SigningState } from "./mpcv2SigningState";
+
+export const MPCv2SignatureShareBase = t.type({
+  type: MPCv2SigningState,
+});
+
+/**
+ * User to BitGo round 1
+ */
+export const MPCv2SignatureShareRound1Input = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round1Input"),
+      data: t.type({
+        msg1: MPCv2BroadcastMessage,
+      }),
+    },
+    "MPCv2SignatureShareRound1",
+  ),
+]);
+
+export type MPCv2SignatureShareRound1Input = t.TypeOf<
+  typeof MPCv2SignatureShareRound1Input
+>;
+
+/**
+ * BitGo to User round 1
+ */
+export const MPCv2SignatureShareRound1Output = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round1Output"),
+      data: t.type({
+        msg1: MPCv2BroadcastMessage,
+        msg2: MPCv2P2PMessage,
+      }),
+    },
+    "MPCv2SignatureShareRound1Output",
+  ),
+]);
+
+export type MPCv2SignatureShareRound1Output = t.TypeOf<
+  typeof MPCv2SignatureShareRound1Output
+>;
+
+/**
+ * User to BitGo round 2
+ */
+export const MPCv2SignatureShareRound2Input = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round2Input"),
+      data: t.type({
+        msg2: MPCv2P2PMessage,
+        msg3: MPCv2P2PMessage,
+      }),
+    },
+    "MPCv2SignatureShareRound2Input",
+  ),
+]);
+
+export type MPCv2SignatureShareRound2Input = t.TypeOf<
+  typeof MPCv2SignatureShareRound2Input
+>;
+
+/**
+ * BitGo to User round 2
+ */
+export const MPCv2SignatureShareRound2Output = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round2Output"),
+      data: t.type({
+        msg3: MPCv2P2PMessage,
+      }),
+    },
+    "MPCv2SignatureShareRound2Output",
+  ),
+]);
+
+export type MPCv2SignatureShareRound2Output = t.TypeOf<
+  typeof MPCv2SignatureShareRound2Output
+>;
+
+/**
+ * User to BitGo round 3
+ */
+export const MPCv2SignatureShareRound3Input = t.intersection([
+  MPCv2SignatureShareBase,
+  t.type(
+    {
+      type: t.literal("round3Input"),
+      data: t.type({
+        msg4: MPCv2BroadcastMessageWithSignatureR,
+      }),
+    },
+    "MPCv2SignatureShareRound3Input",
+  ),
+]);
+
+export type MPCv2SignatureShareRound3Input = t.TypeOf<
+  typeof MPCv2SignatureShareRound3Input
+>;

package/src/schema/transactionRequest/index.ts

@@ -0,0 +1,2 @@
+export * from "./transactionState";
+export * from "./transactionRequestState";

package/src/schema/transactionRequest/transactionRequestState.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+
+export const TransactionRequestState = t.keyof(
+  {
+    pendingApproval: 1,
+    canceled: 1,
+    rejected: 1,
+    initialized: 1,
+    pendingDelivery: 1,
+    delivered: 1,
+    pendingUserSignature: 1,
+    pendingUserCommitment: 1,
+    pendingUserRShare: 1,
+    pendingUserGShare: 1,
+    readyToSend: 1,
+    signed: 1,
+    failed: 1,
+  },
+  "TransactionRequestState",
+);
+export type TransactionRequestState = t.TypeOf<typeof TransactionRequestState>;

package/src/schema/transactionRequest/transactionState.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+
+export const TransactionState = t.keyof(
+  {
+    initialized: 1,
+    pendingSignature: 1,
+    eddsaPendingCommitment: 1,
+    eddsaPendingRShare: 1,
+    eddsaPendingGShare: 1,
+    ecdsaMPCv2Round1: 1,
+    ecdsaMPCv2Round2: 1,
+    ecdsaMPCv2Round3: 1,
+    readyToCombineShares: 1,
+    signed: 1,
+    held: 1,
+    delivered: 1,
+    invalidSignature: 1,
+    rejected: 1,
+  },
+  "TransactionState",
+);
+export type TransactionState = t.TypeOf<typeof TransactionState>;

package/src/schema/transactions/coinSpecific.ts

@@ -0,0 +1,59 @@
+import * as t from "io-ts";
+import {
+  optionalStringOrNumber,
+  optionalString,
+  optionalNumber,
+  optionalStringArray,
+  optionalBoolean,
+  optionalUnknown,
+} from "../../utils";
+
+const BaseBuildParams = {
+  type: t.string,
+  nonce: optionalNumber,
+  memo: t.partial({
+    type: optionalString,
+    value: optionalString,
+  }),
+  comment: optionalString,
+  ledgerSequenceDelta: optionalNumber,
+  lastLedgerSequence: optionalNumber,
+  feeRate: optionalStringOrNumber,
+  messageKey: optionalString,
+  previewPendingTxs: optionalBoolean,
+  pendingApprovalId: optionalString,
+  sequenceId: optionalString,
+};
+
+const ConsolidateBuildParams = {
+  ...BaseBuildParams,
+  consolidateId: optionalString,
+  senderAddress: optionalString,
+};
+
+// Coin Specific Build Params
+export const CoinSpecificBuildParams = {
+  avaxp: {
+    locktime: optionalNumber,
+    sourceChain: optionalString,
+    destinationChain: optionalString,
+    unspents: optionalStringArray,
+  },
+  dot: {
+    ...ConsolidateBuildParams,
+    sequenceId: optionalString,
+    senderAddressIndex: optionalNumber,
+    nonce: optionalNumber,
+    proxyType: optionalString,
+    forceProxyType: optionalString,
+    owner: optionalUnknown,
+    delay: optionalUnknown,
+    index: optionalUnknown,
+    validityWindow: optionalUnknown,
+    version: optionalUnknown,
+    referenceBlock: optionalUnknown,
+  },
+  sol: {
+    tokenName: optionalString,
+  },
+};

package/src/schema/transactions/index.ts

@@ -0,0 +1 @@
+export * from "./sendTransactions";

package/src/schema/transactions/sendTransactions.ts

@@ -0,0 +1,245 @@
+import * as t from "io-ts";
+import {
+  Optional,
+  optionalString,
+  optionalBoolean,
+  optionalNumber,
+  optionalStringOrNumber,
+  optionalUnknown,
+} from "../../utils";
+import { CoinSpecificBuildParams } from "./coinSpecific";
+
+const recipient = t.partial({
+  address: t.string,
+  amount: t.union([t.string, t.number]),
+  feeLimit: optionalString,
+  data: optionalString,
+  memo: optionalString,
+  tokenName: optionalString,
+});
+export type TransactionRecipient = t.TypeOf<typeof recipient>;
+const recipients = t.array(recipient);
+
+const eip1559 = t.partial({
+  maxPriorityFeePerGas: optionalString,
+  maxFeePerGas: optionalString,
+});
+
+const lightningPaymentRequest = t.intersection([
+  t.type({
+    invoice: t.string,
+  }),
+  t.partial({
+    amount: t.number,
+    sequenceId: t.string,
+    feeLimit: t.number,
+    feeLimitRatio: t.number,
+  }),
+]);
+export type LightningPaymentRequest = t.TypeOf<typeof lightningPaymentRequest>;
+
+const halfSigned = t.partial({
+  txHex: optionalString,
+  recipients: Optional(recipients),
+  eip1559: Optional(eip1559),
+  isBatch: optionalBoolean,
+  expireTime: optionalNumber,
+  contractSequenceId: optionalNumber,
+  nextContractSequenceId: optionalNumber,
+  operationHash: optionalString,
+  signedChildPsbt: optionalString,
+  signature: optionalString,
+  lightningPaymentRequest: Optional(lightningPaymentRequest),
+});
+export type HalfSignedTransaction = t.TypeOf<typeof halfSigned>;
+
+export const memo = t.partial({
+  type: optionalString,
+  value: optionalString,
+});
+
+const feeOptions = {
+  amount: optionalStringOrNumber,
+  unit: Optional(
+    t.union([t.literal("baseUnit"), t.literal("cpu"), t.literal("ram")]),
+  ),
+  formula: Optional(
+    t.union([
+      t.literal("fixed"),
+      t.literal("feeRate"),
+      t.literal("perKB"),
+      t.literal("custom"),
+    ]),
+  ),
+  type: Optional(
+    t.union([t.literal("base"), t.literal("max"), t.literal("tip")]),
+  ),
+};
+
+export const txSendBody = {
+  comment: optionalString,
+  consolidateId: optionalString,
+  halfSigned: Optional(halfSigned),
+  invoice: optionalString,
+  memo: Optional(memo),
+  otp: optionalString,
+  recipients: Optional(recipients),
+  suppressBroadcast: optionalBoolean,
+  txHex: optionalString,
+  txRequestId: optionalString,
+  videoApprovers: Optional(t.array(t.string)),
+
+  numBlocks: optionalNumber,
+  feeRate: optionalNumber,
+  maxFeeRate: optionalNumber,
+  minConfirms: optionalNumber,
+  enforceMinConfirmsForChange: optionalBoolean,
+  targetWalletUnspents: optionalNumber,
+  message: optionalString,
+  minValue: optionalStringOrNumber,
+  maxValue: optionalStringOrNumber,
+  sequenceId: optionalStringOrNumber,
+  lastLedgerSequence: optionalNumber,
+  ledgerSequenceDelta: optionalNumber,
+  gasPrice: optionalNumber,
+  noSplitChange: optionalBoolean,
+  unspents: t.array(t.string),
+  changeAddress: optionalString,
+  instant: optionalBoolean,
+  transferId: optionalNumber,
+  gasLimit: optionalNumber,
+  custodianTransactionId: optionalString,
+
+  cpfpTxIds: Optional(t.array(t.string)),
+  cpfpFeeRate: optionalNumber,
+  noCpfpFeeRate: optionalBoolean,
+  maxFee: optionalNumber,
+  noMaxFee: optionalBoolean,
+
+  /// all other props from wp whitelist
+  feeMultiplier: optionalNumber,
+  addressType: optionalString,
+  changeAddressType: optionalString,
+  strategy: optionalString,
+  strategyAllowFallback: optionalBoolean,
+  fee: t.union([optionalString, t.partial(feeOptions)]),
+  timeBounds: Optional(
+    t.partial({
+      minTime: optionalStringOrNumber,
+      maxTime: optionalStringOrNumber,
+    }),
+  ),
+  idfSignedTimestamp: optionalString,
+  idfVersion: optionalNumber,
+  idfUserId: optionalString,
+  hopParams: t.partial({
+    gasPriceMax: optionalNumber,
+    paymentId: optionalString,
+    userReqSig: optionalString,
+  }),
+  validFromBlock: optionalNumber,
+  validToBlock: optionalNumber,
+  type: optionalString,
+  trustlines: t.partial({
+    token: optionalString,
+    action: optionalString,
+    limit: optionalString,
+  }),
+  reservation: t.partial({
+    expireTime: optionalString,
+    pendingApprovalId: optionalString,
+  }),
+  delayMs: optionalNumber,
+  messageKey: optionalString,
+  senderAddress: optionalString,
+  startTime: optionalString,
+  nonParticipation: optionalBoolean,
+  keyregTxBase64: optionalString,
+  closeRemainderTo: optionalString,
+  stateProofKey: optionalString,
+  contractName: optionalString,
+  functionName: optionalString,
+  eip1559: Optional(eip1559),
+  maxChangeOutputs: optionalNumber,
+  smallestChangeSplitSize: optionalNumber,
+  emergency: optionalBoolean,
+  sourceChain: optionalString,
+  destinationChain: optionalString,
+  txFormat: optionalString,
+  previewPendingTxs: optionalBoolean,
+  pendingApprovalId: optionalString,
+  stakingOptions: optionalUnknown,
+  unstakingOptions: optionalUnknown,
+  refundOptions: optionalUnknown,
+  stakingParams: t.partial({
+    actionType: optionalString,
+    validator: optionalString,
+    coin: optionalString,
+    amount: optionalString,
+  }),
+  isReplaceableByFee: optionalBoolean,
+  rbfTxIds: Optional(t.array(t.string)),
+};
+
+export const TxSendBody = t.exact(
+  t.intersection([
+    t.partial(txSendBody, "TxSendBody"),
+    t.partial(CoinSpecificBuildParams.avaxp),
+    t.partial(CoinSpecificBuildParams.dot),
+    t.partial(CoinSpecificBuildParams.sol),
+  ]),
+);
+export type TxSendBody = t.TypeOf<typeof TxSendBody>;
+
+const entry = t.partial({
+  address: t.string,
+  wallet: t.string,
+  value: t.number,
+  valueString: t.string,
+  isChange: t.boolean,
+  isPayGo: t.boolean,
+});
+const historyItem = t.partial({
+  date: t.string,
+  action: t.string,
+  user: t.string,
+});
+
+export const TxSendResponse = t.partial({
+  baseValue: t.number,
+  baseValueString: t.string,
+  coin: t.string,
+  coinSpecific: t.record(t.string, t.unknown),
+  createdTime: t.string,
+  date: t.string,
+  enterprise: t.string,
+  entries: t.array(entry),
+  feeString: t.string,
+  height: t.number,
+  heightId: t.string,
+  history: t.array(historyItem),
+  id: t.string,
+  instant: t.boolean,
+  intendedValueString: t.string,
+  isFee: t.boolean,
+  isReward: t.boolean,
+  metadata: t.record(t.string, t.unknown),
+  payGoFee: t.number,
+  payGoFeeString: t.string,
+  signedDate: t.string,
+  signedTime: t.string,
+  state: t.string,
+  tags: t.array(t.string),
+  txid: t.string,
+  txidType: t.string,
+  txRequestId: t.string,
+  type: t.string,
+  usd: t.number,
+  usdRate: t.number,
+  value: t.number,
+  valueString: t.string,
+  vSize: t.number,
+  wallet: t.string,
+  walletType: t.string,
+});
+export type TxSendResponse = t.TypeOf<typeof TxSendResponse>;

package/src/schema/wallet/index.ts

@@ -0,0 +1 @@
+export * from "./wallet";

package/src/schema/wallet/wallet.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+
+export const WalletUser = t.type({
+  user: t.string,
+  permissions: t.array(t.string),
+});
+
+export type WalletUser = t.TypeOf<typeof WalletUser>;

package/src/schema/webhook/addWalletWebhookRequest.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+import { NonEmptyString, NumberFromString } from "io-ts-types";
+import { Optional } from "../../utils/optional";
+import { TransactionRequestState } from "../transactionRequest/transactionRequestState";
+import { TransactionState } from "../transactionRequest/transactionState";
+import { WalletWebhookType } from "./webhookType";
+
+export const AddWalletWebhookRequestBody = {
+  type: WalletWebhookType,
+  url: NonEmptyString,
+  label: Optional(t.string),
+  numConfirmations: t.union([t.number, NumberFromString, t.undefined]),
+  allToken: Optional(t.boolean),
+  listenToFailureStates: Optional(t.boolean),
+  txRequestStates: Optional(t.array(TransactionRequestState)),
+  txRequestTransactionStates: Optional(t.array(TransactionState)),
+};
+export const AddWalletWebhookRequestBodyC = t.type({
+  ...AddWalletWebhookRequestBody,
+});
+
+export type AddWalletWebhookRequestBody = t.TypeOf<
+  typeof AddWalletWebhookRequestBodyC
+>;

package/src/schema/webhook/enterpriseWebhooks.ts

@@ -0,0 +1,44 @@
+import { EnterpriseWebhookType } from "./webhookType";
+import { NonEmptyString } from "io-ts-types";
+import { Optional, optionalString, optionalStringOrNumber } from "../../utils";
+import * as t from "io-ts";
+import { Webhook } from "./webhook";
+
+export const AddEnterpriseWebhookRequestBody = {
+  type: EnterpriseWebhookType,
+  url: NonEmptyString,
+  label: Optional(t.string),
+};
+export const AddEnterpriseWebhookRequestBodyC = t.type({
+  ...AddEnterpriseWebhookRequestBody,
+});
+
+export type AddEnterpriseWebhookRequestBody = t.TypeOf<
+  typeof AddEnterpriseWebhookRequestBodyC
+>;
+
+export const ListEnterpriseWebhooksRequestBody = {
+  type: Optional(EnterpriseWebhookType),
+  limit: optionalStringOrNumber,
+  prevId: optionalString,
+};
+
+export const ListEnterpriseWebhooksRequestBodyC = t.type({
+  ...ListEnterpriseWebhooksRequestBody,
+});
+
+export type ListEnterpriseWebhooksRequestBody = t.TypeOf<
+  typeof ListEnterpriseWebhooksRequestBodyC
+>;
+
+export const ListEnterpriseWebhooksResponse = t.intersection([
+  t.type({
+    webhooks: t.array(Webhook),
+  }),
+  t.partial({
+    nextBatchPrevId: Optional(t.union([t.string, t.undefined])),
+  }),
+]);
+export type ListEnterpriseWebhooksResponse = t.TypeOf<
+  typeof ListEnterpriseWebhooksResponse
+>;

package/src/schema/webhook/index.ts

@@ -0,0 +1,7 @@
+export * from "./enterpriseWebhooks";
+export * from "./addWalletWebhookRequest";
+export * from "./webhook";
+export * from "./webhookNotification";
+export * from "./webhookScope";
+export * from "./webhookState";
+export * from "./webhookType";

package/src/schema/webhook/webhook.ts

@@ -0,0 +1,35 @@
+import * as t from "io-ts";
+import { DateFromISOString } from "io-ts-types";
+import { TransactionRequestState } from "../transactionRequest/transactionRequestState";
+import { TransactionState } from "../transactionRequest/transactionState";
+import { WebhookState } from "./webhookState";
+import { WebhookType } from "./webhookType";
+import { WebhookScope } from "./webhookScope";
+
+export const Webhook = t.intersection([
+  t.type({
+    id: t.string,
+    created: DateFromISOString,
+    coin: t.string,
+    url: t.string,
+    version: t.number,
+    state: WebhookState,
+    successiveFailedAttempts: t.number,
+    listenToFailureStates: t.boolean,
+  }),
+  t.partial({
+    label: t.string,
+    walletId: t.string,
+    enterpriseId: t.string,
+    organizationId: t.string,
+    scope: WebhookScope,
+    userId: t.string,
+    type: WebhookType,
+    numConfirmations: t.number,
+    lastAttempt: DateFromISOString,
+    failingSince: DateFromISOString,
+    allToken: t.boolean,
+    txRequestStates: t.array(TransactionRequestState),
+    txRequestTransactionStates: t.array(TransactionState),
+  }),
+]);

package/src/schema/webhook/webhookNotification.ts

@@ -0,0 +1,33 @@
+import * as t from "io-ts";
+import { DateFromISOString } from "io-ts-types";
+
+export const WebhookNotification = t.intersection([
+  t.type({
+    id: t.string,
+  }),
+  t.partial({
+    type: t.string,
+    wallet: t.string,
+    url: t.string,
+    hash: t.string,
+    coin: t.string,
+    coinChain: t.string,
+    transfer: t.string,
+    state: t.string,
+    simulation: t.boolean,
+    retries: t.number,
+    webhook: t.string,
+    updatedAt: DateFromISOString,
+    nextAttempt: DateFromISOString,
+    version: t.number,
+    allowBlockedHosts: t.boolean,
+    heightToConfirm: t.number,
+    payload: t.string,
+    response: t.partial({
+      code: t.unknown,
+      type: t.string,
+      body: t.string,
+      error: t.string,
+    }),
+  }),
+]);

package/src/schema/webhook/webhookScope.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+
+export enum WebhookScopeEnum {
+  "wallet" = "wallet",
+  "enterprise" = "enterprise",
+  "organization" = "organization",
+}
+
+export const WebhookScope = t.keyof(WebhookScopeEnum, "WebhookScope");
+export type WebhookScope = t.TypeOf<typeof WebhookScope>;

package/src/schema/webhook/webhookState.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+
+export enum WebhookStateEnum {
+  "active" = "active",
+  "suspended" = "suspended",
+}
+
+export const WebhookState = t.keyof(WebhookStateEnum, "WebhookState");
+export type WebhookState = t.TypeOf<typeof WebhookState>;