@bitgo/public-types 5.28.0 → 5.29.0

package/src/schema/transactionRequest/transactionRequest.ts

@@ -0,0 +1,118 @@
+import * as t from "io-ts";
+import { DateFromISOString, NonEmptyString } from "io-ts-types";
+import { WalletIdString } from "../wallet";
+import { WalletTypes } from "../wallet/walletTypes";
+import { EnterpriseIdString } from "../enterprise";
+import { TransactionIntent, TransactionRequestState } from ".";
+import { TransactionRequestApiVersion } from "./transactionRequestApiVersion";
+import { CommitmentShare } from "./commitmentShare";
+import { SignatureShare } from "./signatureShare";
+import { UnsignedTransaction } from "./unsignedTransaction";
+import { Message } from "./message";
+import { Transaction } from "./transaction";
+
+/**
+ * @format uuid
+ * @example 123e4567-e89b-12d3-a456-426614174000
+ */
+export const TransactionRequestId = t.string;
+
+export type TransactionRequestId = t.TypeOf<typeof TransactionRequestId>;
+
+/**
+ * @format uuid
+ * @example 123e4567-e89b-12d3-a456-426614174000
+ */
+export const TransactionRequestIdNonEmptyString = NonEmptyString; // Could also be UUID from io-ts-types if the team had complete confidence in the shape of all txRequestIds
+
+export type TransactionRequestIdNonEmptyString = t.TypeOf<
+  typeof TransactionRequestIdNonEmptyString
+>;
+
+export const TransactionRequestBase = t.intersection([
+  // Required fields
+  t.type({
+    /** A unique ID for the TxRequest document across all wallets. The combination of the txRequestId and version will always be unique. */
+    txRequestId: TransactionRequestId,
+    /** The id of the Wallet the TxRequest is for. */
+    walletId: WalletIdString,
+    /** The version of the transaction request */
+    version: t.number,
+    /** The state of the transaction request */
+    state: TransactionRequestState,
+    /**
+     * The date and time this version of the TxRequest document was created.
+     * @example 2021-01-01T00:00:00Z
+     */
+    date: DateFromISOString,
+    /**
+     * The date and time the version 1 TxRequest document was created.
+     * @example 2021-01-01T00:00:00Z
+     */
+    createdDate: DateFromISOString,
+    /** The Id of the User that produced this version of the TxRequest document. Could have created a new document or updated an existing document. */
+    userId: t.string,
+    /** The Id of the User that originally created the TxRequest document (initiated the TxRequest). */
+    initiatedBy: t.string,
+    /** The Id of the User that last updated the TxRequest document. This is an alias for the userId field. */
+    updatedBy: t.string,
+    /** The intents of the transaction request */
+    intents: t.array(t.unknown),
+    /** Indicates if this is the latest transaction request */
+    latest: t.boolean,
+  }),
+  // Optional fields
+  t.partial({
+    /** The API version of the transaction request */
+    apiVersion: TransactionRequestApiVersion,
+    /** The idempotency key of the transaction request */
+    idempotencyKey: t.string,
+    /** The type describes who owns the keys to the wallet associated to the TxRequest. */
+    walletType: WalletTypes,
+    /** If the wallet that owns the TxRequest is owned by an enterprise then this is the Id of said enterprise. */
+    enterpriseId: EnterpriseIdString,
+    /** The intent of the transaction request */
+    intent: t.unknown,
+    /** The id of the Pending Approval that was created for the TxRequest if one was required. */
+    pendingApprovalId: t.string,
+    /** Indicates if the transaction request has been checked against the policies. */
+    policiesChecked: t.boolean,
+    /** True, if the transaction request is canceled. */
+    isCanceled: t.boolean,
+  }),
+]);
+
+export const TransactionRequestLite = t.intersection([
+  TransactionRequestBase,
+  t.partial({
+    /** The intent of the transaction request */
+    intent: t.union([TransactionIntent, t.unknown]),
+    /** Holds all unsigned transactions that will be used to fulfill the TxRequest for MPC wallets. */
+    unsignedTxs: t.array(UnsignedTransaction),
+    /** Only used for MPC coins. This is used to collect signature shares from and exchange them with the user. */
+    signatureShares: t.array(SignatureShare),
+    /**Only used for MPC coins on EdDSA curve. This is used to collect commitment shares from and exchange them with the user.  */
+    commitmentShares: t.array(CommitmentShare),
+    /** The hashes of all transactions from the TxRequest that have been signed and are pending broadcast. */
+    txHashes: t.array(t.string),
+  }),
+]);
+export type TransactionRequestLite = t.TypeOf<typeof TransactionRequestLite>;
+
+export const TransactionRequestFull = t.intersection([
+  TransactionRequestBase,
+  t.partial({
+    /** The transactions associated with the transaction request */
+    transactions: t.array(Transaction),
+    /** The messages associated with the transaction request */
+    messages: t.array(Message),
+  }),
+]);
+export type TransactionRequestFull = t.TypeOf<typeof TransactionRequestFull>;
+
+export const TransactionRequest = t.union([
+  TransactionRequestLite,
+  TransactionRequestFull,
+]);
+
+export type TransactionRequest = t.TypeOf<typeof TransactionRequest>;

package/src/schema/transactionRequest/transactionRequestApiVersion.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+
+export const TransactionRequestApiVersion = t.keyof(
+  {
+    lite: 1,
+    full: 1,
+  },
+  "TransactionRequestApiVersion",
+);
+export type TransactionRequestApiVersion = t.TypeOf<
+  typeof TransactionRequestApiVersion
+>;

package/src/schema/transactionRequest/unsignedTransaction.ts

@@ -0,0 +1,77 @@
+import * as t from "io-ts";
+
+const Input = t.intersection([
+  t.type({
+    valueString: t.string,
+  }),
+  t.partial({
+    _id: t.string,
+    address: t.string,
+    chain: t.number,
+    derivationIndex: t.number,
+    index: t.number,
+    value: t.union([t.number, t.bigint]),
+  }),
+]);
+
+const Output = t.intersection([
+  t.type({
+    valueString: t.string,
+  }),
+  t.partial({
+    address: t.string,
+    change: t.boolean,
+    coinName: t.string,
+    data: t.string,
+    isPayGo: t.boolean,
+    value: t.union([t.number, t.bigint]),
+    wallet: t.string,
+    walletV1: t.string,
+    baseAddress: t.string,
+    enterprise: t.string,
+  }),
+]);
+
+const ParsedTx = t.intersection([
+  t.type({
+    inputs: t.array(Input),
+    minerFee: t.union([t.string, t.number]),
+    outputs: t.array(Output),
+    spendAmount: t.union([t.string, t.number]),
+  }),
+  t.partial({
+    gasPrice: t.number,
+    hasUnvalidatedData: t.boolean,
+    payGoFee: t.union([t.string, t.number]),
+    spendAmounts: t.array(t.UnknownRecord),
+    type: t.string,
+  }),
+]);
+
+export const UnsignedTransaction = t.intersection([
+  t.type({
+    parsedTx: ParsedTx,
+    /** The unsigned transaction as a hex string. */
+    serializedTxHex: t.string,
+    /** The portion of a transaction used to generate a signature (may or may not be the same as serializedTxHex) as a hex string. */
+    signableHex: t.string,
+  }),
+  t.partial({
+    /** A bip32 path. */
+    derivationPath: t.string,
+    /** Coin specific information. */
+    coinSpecific: t.intersection([
+      t.UnknownRecord,
+      t.partial({
+        nonceAddress: t.string,
+        stakingAddress: t.string,
+        signature: t.string,
+      }),
+    ]),
+    feeInfo: t.type({
+      fee: t.union([t.string, t.number]),
+      feeString: t.string,
+    }),
+  }),
+]);
+export type UnsignedTransaction = t.TypeOf<typeof UnsignedTransaction>;

package/src/schema/wallet/index.ts

@@ -1,2 +1,3 @@
 export * from "./wallet";
 export * from "./multisigTypeVersion";
+export * from "./walletTypes";

package/src/schema/wallet/wallet.ts

@@ -1,5 +1,12 @@
 import * as t from "io-ts";
 
+/**
+ * @example 59cd72485007a239fb00282ed480da1f
+ * @pattern ^[0-9a-f]{32}$
+ */
+export const WalletIdString = t.string;
+export type WalletIdString = t.TypeOf<typeof WalletIdString>;
+
 export const WalletUser = t.type({
   user: t.string,
   permissions: t.array(t.string),

package/src/schema/wallet/walletTypes.ts

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+
+export const WalletTypes = t.keyof(
+  {
+    backing: 1,
+    cold: 1,
+    custodial: 1,
+    custodialPaired: 1,
+    hot: 1,
+    advanced: 1,
+    trading: 1,
+  },
+  "WalletTypes",
+);
+
+export type WalletTypes = t.TypeOf<typeof WalletTypes>;