@bitgo/public-types 2.39.0 → 2.41.0

package/src/schema/transactionRequest/intents/baseIntent.ts

@@ -1,20 +1,28 @@
 import * as t from "io-ts";
 import { IntentType } from "./intentType";
-import { optionalNumber, optionalString } from "../../../utils";
+import { Optional, optionalString } from "../../../utils";
 
-export const BaseIntent = t.type({
-  intentType: IntentType,
-  sequenceId: optionalString,
-  comment: optionalString,
-  nonce: t.union([optionalString, optionalNumber]),
-});
+export const BaseIntent = t.intersection([
+  t.type({
+    intentType: IntentType,
+  }),
+  t.partial({
+    sequenceId: optionalString,
+    comment: optionalString,
+    nonce: Optional(t.union([t.string, t.number])),
+  }),
+]);
 
 export type BaseIntent = t.TypeOf<typeof BaseIntent>;
 
-export const BaseIntentWithoutNonce = t.type({
-  intentType: IntentType,
-  sequenceId: optionalString,
-  comment: optionalString,
-});
+export const BaseIntentWithoutNonce = t.intersection([
+  t.type({
+    intentType: IntentType,
+  }),
+  t.partial({
+    sequenceId: optionalString,
+    comment: optionalString,
+  }),
+]);
 
 export type BaseIntentWithoutNonce = t.TypeOf<typeof BaseIntentWithoutNonce>;

package/src/schema/transactionRequest/intents/consolidateTokenIntent.ts

@@ -11,6 +11,8 @@ export const ConsolidateTokenIntent = t.intersection([
   t.type({
     intentType: intentTypes.consolidateToken,
     recipients: t.array(TokenRecipientEntry),
+  }),
+  t.partial({
     consolidateId: optionalString,
     keepAlive: optionalBoolean,
   }),

package/src/schema/transactionRequest/intents/cosmosStakeIntent.ts

@@ -11,6 +11,8 @@ export const CosmosStakeIntent = t.intersection([
     intentType: intentTypes.delegate,
     validatorAddress: t.string,
     amount: Amount,
+  }),
+  t.partial({
     recipients: Optional(t.array(RecipientEntry)),
   }),
 ]);

package/src/schema/transactionRequest/intents/cosmosUnstakeIntent.ts

@@ -11,6 +11,8 @@ export const CosmosUnstakeIntent = t.intersection([
     intentType: intentTypes.undelegate,
     validatorAddress: t.string,
     amount: Amount,
+  }),
+  t.partial({
     recipients: Optional(t.array(RecipientEntry)),
   }),
 ]);

package/src/schema/transactionRequest/intents/dotAccountBaseBuildOptions.ts

@@ -5,7 +5,7 @@ import { Optional } from "../../../utils";
 
 export const DotAccountBaseBuildOptions = t.intersection([
   AccountBaseBuildOptions,
-  t.type({
+  t.partial({
     fee: Optional(DotFeeOptions),
   }),
 ]);

package/src/schema/transactionRequest/intents/dotBaseIntent.ts

@@ -6,7 +6,7 @@ import { BaseIntent } from "./baseIntent";
 
 export const DotBaseIntent = t.intersection([
   BaseIntent,
-  t.type({
+  t.partial({
     senderAddressIndex: optionalNumber,
     fee: Optional(DotFeeOptions),
     recipients: Optional(t.array(RecipientEntry)),

package/src/schema/transactionRequest/intents/dotConsolidateIntent.ts

@@ -0,0 +1,6 @@
+import * as t from "io-ts";
+import { AccountBaseConsolidateIntent } from "./accountBaseConsolidateIntent";
+
+export const DotConsolidateIntent = AccountBaseConsolidateIntent;
+
+export type DotConsolidateIntent = t.TypeOf<typeof DotConsolidateIntent>;

package/src/schema/transactionRequest/intents/dotCreateAccountIntent.ts

@@ -10,6 +10,8 @@ export const DotCreateAccountIntent = t.intersection([
   t.type({
     delayBlocks: t.string,
     proxyType: t.string,
+  }),
+  t.partial({
     index: optionalNumber,
     // recipients array can be undefined or empty if txn is for anonymous proxy
     recipients: Optional(t.array(RecipientEntry)),

package/src/schema/transactionRequest/intents/dotFeeOptionFormula.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+
+export const dotFeeFormulas = {
+  fixed: t.literal("fixed"),
+  feeRate: t.literal("feeRate"),
+  perKB: t.literal("perKB"),
+  custom: t.literal("custom"),
+};
+
+export const DotFeeFormulas = t.keyof(dotFeeFormulas);
+
+export type DotFeeFormulas = t.TypeOf<typeof DotFeeFormulas>;

package/src/schema/transactionRequest/intents/dotFeeOptions.ts

@@ -1,12 +1,16 @@
 import * as t from "io-ts";
 import { FeeUnit } from "./feeOptionUnit";
 import { Optional } from "../../../utils";
-import { FeeFormula } from "./feeOptionFormula";
+import { DotFeeFormulas } from "./dotFeeOptionFormula";
 import { FeeType } from "./feeOptionFeeType";
 
-export const DotFeeOptions = t.type({
-  amount: t.union([t.string, t.number]),
-  unit: Optional(FeeUnit),
-  formula: Optional(FeeFormula),
-  type: Optional(FeeType),
-});
+export const DotFeeOptions = t.intersection([
+  t.type({
+    amount: t.union([t.string, t.number]),
+  }),
+  t.partial({
+    unit: Optional(FeeUnit),
+    formula: Optional(DotFeeFormulas),
+    type: Optional(FeeType),
+  }),
+]);

package/src/schema/transactionRequest/intents/dotProxy.ts

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 import { optionalString } from "../../../utils";
 
-export const DotProxy = t.type({
+export const DotProxy = t.partial({
   name: optionalString,
   addressString: optionalString,
   asset: optionalString,

package/src/schema/transactionRequest/intents/dotStakingIntent.ts

@@ -10,6 +10,8 @@ export const DotStakingIntent = t.intersection([
   t.type({
     amount: Amount,
     stakingProxy: t.string,
+  }),
+  t.partial({
     addToStake: optionalBoolean,
     addProxy: optionalBoolean,
   }),

package/src/schema/transactionRequest/intents/dotUnstakingIntent.ts

@@ -10,6 +10,8 @@ export const DotUnstakingIntent = t.intersection([
   t.type({
     amount: Amount,
     stakingProxy: t.string,
+  }),
+  t.partial({
     stopStaking: optionalBoolean,
   }),
 ]);

package/src/schema/transactionRequest/intents/eip1559FeeOptions.ts

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 import { optionalNumber } from "../../../utils";
 
-export const EIP1559FeeOptions = t.type({
+export const EIP1559FeeOptions = t.partial({
   gasLimit: optionalNumber,
   maxFeePerGas: optionalNumber,
   maxPriorityFeePerGas: optionalNumber,

package/src/schema/transactionRequest/intents/ethBuildOptions.ts

@@ -7,7 +7,7 @@ import { HopParams } from "./hopParams";
 
 export const EthBuildOptions = t.intersection([
   AccountBaseBuildOptions,
-  t.type({
+  t.partial({
     feeOptions: Optional(t.union([FeeOption, EIP1559FeeOptions])),
     hopParams: Optional(HopParams),
     receiveAddress: optionalString,
@@ -19,9 +19,33 @@ export type EthBuildOptions = t.TypeOf<typeof EthBuildOptions>;
 
 export const EthBuildOptionsWithoutFeeOptions = t.intersection([
   AccountBaseBuildOptions,
-  t.type({
+  t.partial({
     hopParams: Optional(HopParams),
     receiveAddress: optionalString,
     senderAddressIndex: optionalNumber,
   }),
 ]);
+
+export type EthBuildOptionsWithoutFeeOptions = t.TypeOf<
+  typeof EthBuildOptionsWithoutFeeOptions
+>;
+
+// This is the same as Omit<EthBuildOptions, 'hopParams' | 'nonce'>
+// but `omit` is not easily available in io-ts
+export const EthFillNonceBuildOptions = t.partial({
+  feeOptions: Optional(t.union([FeeOption, EIP1559FeeOptions])),
+  receiveAddress: optionalString,
+  senderAddressIndex: optionalNumber,
+});
+
+export type EthFillNonceBuildOptions = t.TypeOf<
+  typeof EthFillNonceBuildOptions
+>;
+
+export const AllEthBuildOptions = t.union([
+  EthBuildOptions,
+  EthBuildOptionsWithoutFeeOptions,
+  EthFillNonceBuildOptions,
+]);
+
+export type AllEthBuildOptions = t.TypeOf<typeof AllEthBuildOptions>;

package/src/schema/transactionRequest/intents/ethConsolidateIntent.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { AccountBaseConsolidateIntent } from "./accountBaseConsolidateIntent";
+import { EthBuildOptions } from "./ethBuildOptions";
+
+export const EthConsolidateIntent = t.intersection([
+  AccountBaseConsolidateIntent,
+  EthBuildOptions,
+]);
+
+export type EthConsolidateIntent = t.TypeOf<typeof EthConsolidateIntent>;

package/src/schema/transactionRequest/intents/ethConsolidateTokenIntent.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+import { optionalBoolean, optionalString } from "../../../utils";
+import { TokenRecipientEntry } from "./tokenRecipientEntry";
+import { EthBuildOptions } from "./ethBuildOptions";
+
+export const EthConsolidateTokenIntent = t.intersection([
+  BaseIntent,
+  EthBuildOptions,
+  t.type({
+    intentType: intentTypes.consolidateToken,
+    recipients: t.array(TokenRecipientEntry),
+    consolidateId: optionalString,
+    keepAlive: optionalBoolean,
+  }),
+]);
+
+export type EthConsolidateTokenIntent = t.TypeOf<
+  typeof EthConsolidateTokenIntent
+>;

package/src/schema/transactionRequest/intents/ethFillNonceIntent.ts

@@ -1,18 +1,10 @@
 import * as t from "io-ts";
 import { FillNonceIntent } from "./fillNonceIntent";
-import { Optional, optionalNumber, optionalString } from "../../../utils";
-import { FeeOption } from "./feeOption";
-import { EIP1559FeeOptions } from "./eip1559FeeOptions";
+import { EthFillNonceBuildOptions } from "./ethBuildOptions";
 
 export const EthFillNonceIntent = t.intersection([
   FillNonceIntent,
-  // This is the same as Omit<EthBuildOptions, 'hopParams' | 'nonce'>
-  // but `omit` is not easily available in io-ts
-  t.type({
-    feeOptions: Optional(t.union([FeeOption, EIP1559FeeOptions])),
-    receiveAddress: optionalString,
-    senderAddressIndex: optionalNumber,
-  }),
+  EthFillNonceBuildOptions,
 ]);
 
 export type EthFillNonceIntent = t.TypeOf<typeof EthFillNonceIntent>;

package/src/schema/transactionRequest/intents/ethPaymentIntent.ts

@@ -1,12 +1,13 @@
 import * as t from "io-ts";
 import { PaymentIntent } from "./paymentIntent";
 import { EthBuildOptions } from "./ethBuildOptions";
+import { optionalBoolean } from "../../../utils";
 
 export const EthPaymentIntent = t.intersection([
   PaymentIntent,
   EthBuildOptions,
   t.type({
-    selfSend: t.string,
+    selfSend: optionalBoolean,
   }),
 ]);
 

package/src/schema/transactionRequest/intents/ethTransferTokenIntent.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { EthBuildOptions } from "./ethBuildOptions";
+import { TransferTokenIntent } from "./transferTokenIntent";
+
+export const EthTransferTokenIntent = t.intersection([
+  TransferTokenIntent,
+  EthBuildOptions,
+]);
+
+export type EthTransferTokenIntent = t.TypeOf<typeof EthTransferTokenIntent>;

package/src/schema/transactionRequest/intents/feeOption.ts

@@ -4,10 +4,12 @@ import { FeeUnit } from "./feeOptionUnit";
 import { FeeFormula } from "./feeOptionFormula";
 import { FeeType } from "./feeOptionFeeType";
 
-export const FeeOption = t.type({
+export const FeeOption = t.partial({
   unit: Optional(FeeUnit),
   formula: Optional(FeeFormula),
   feeType: Optional(FeeType),
   gasLimit: optionalNumber,
   gasPrice: optionalNumber,
 });
+
+export type FeeOption = t.TypeOf<typeof FeeOption>;

package/src/schema/transactionRequest/intents/index.ts

@@ -29,7 +29,9 @@ export * from "./cosmosUnstakeIntent";
 export * from "./cosmosWithdrawIntent";
 export * from "./dotAccountBaseBuildOptions";
 export * from "./dotBaseIntent";
+export * from "./dotConsolidateIntent";
 export * from "./dotCreateAccountIntent";
+export * from "./dotFeeOptionFormula";
 export * from "./dotFeeOptions";
 export * from "./dotPaymentIntent";
 export * from "./dotProxy";
@@ -40,9 +42,12 @@ export * from "./eip1559FeeOptions";
 export * from "./enableTokenIntent";
 export * from "./ethAccelerationIntent";
 export * from "./ethBuildOptions";
+export * from "./ethConsolidateIntent";
+export * from "./ethConsolidateTokenIntent";
 export * from "./ethFillNonceIntent";
 export * from "./ethPaymentIntent";
 export * from "./ethStakingIntent";
+export * from "./ethTransferTokenIntent";
 export * from "./feeOption";
 export * from "./feeOptionFeeType";
 export * from "./feeOptionFormula";
@@ -53,6 +58,7 @@ export * from "./intent";
 export * from "./intentType";
 export * from "./lightningPaymentIntent";
 export * from "./mmiSignMessageIntent";
+export * from "./mmiSignTransactionIntent";
 export * from "./nearStakeIntent";
 export * from "./nearUnstakeIntent";
 export * from "./nearWithdrawIntent";
@@ -73,8 +79,10 @@ export * from "./stakeClaimRewardsIntent";
 export * from "./stakeIntent";
 export * from "./stakeSwitchValidatorIntent";
 export * from "./suiBuildOptions";
+export * from "./suiConsolidateIntent";
 export * from "./suiCustomTxIntent";
 export * from "./suiFeeOptions";
+export * from "./suiPaymentIntent";
 export * from "./suiStakingIntent";
 export * from "./suiUnstakingIntent";
 export * from "./supportedTokenRecipientEntryItem";

package/src/schema/transactionRequest/intents/intent.ts

@@ -46,6 +46,14 @@ import { SolConsolidateIntent } from "./solConsolidateIntent";
 import { TonConsolidateIntent } from "./tonConsolidateIntent";
 import { AdaStakeClaimRewardsIntent } from "./adaStakeClaimRewardsIntent";
 import { AdaUnstakeIntent } from "./adaUnstakeIntent";
+import { SuiPaymentIntent } from "./suiPaymentIntent";
+import { SuiConsolidateIntent } from "./suiConsolidateIntent";
+import { MmiSignTransactionIntent } from "./mmiSignTransactionIntent";
+import { EthConsolidateIntent } from "./ethConsolidateIntent";
+import { EthConsolidateTokenIntent } from "./ethConsolidateTokenIntent";
+import { EthTransferTokenIntent } from "./ethTransferTokenIntent";
+import { BaseIntent } from "./baseIntent";
+import { DotConsolidateIntent } from "./dotConsolidateIntent";
 
 export const TransactionIntent = t.union([
   AdaConsolidateIntent,
@@ -66,17 +74,23 @@ export const TransactionIntent = t.union([
   CosmosSwitchValidatorIntent,
   CosmosUnstakeIntent,
   CosmosWithdrawIntent,
+  DotConsolidateIntent,
   DotCreateAccountIntent,
   DotPaymentIntent,
   DotStakingIntent,
   DotUnstakingIntent,
   DotWithdrawStakeIntent,
   EthAccelerationIntent,
+  EthConsolidateIntent,
+  EthConsolidateIntent,
+  EthConsolidateTokenIntent,
   EthFillNonceIntent,
   EthPaymentIntent,
   EthStakingIntent,
+  EthTransferTokenIntent,
   LightningPaymentIntent,
   MmiSignMessageIntent,
+  MmiSignTransactionIntent,
   NearStakeIntent,
   NearUnstakeIntent,
   NearWithdrawIntent,
@@ -88,7 +102,9 @@ export const TransactionIntent = t.union([
   SolDelegateIntent,
   SolStakeIntent,
   SolUnstakeIntent,
+  SuiConsolidateIntent,
   SuiCustomTxIntent,
+  SuiPaymentIntent,
   SuiStakingIntent,
   SuiUnstakingIntent,
   TonConsolidateIntent,
@@ -99,7 +115,7 @@ export const TransactionIntent = t.union([
   /**
    * Catch all for past intents that have not been converted to codecs
    */
-  t.unknown,
+  BaseIntent,
 ]);
 
 export type TransactionIntent = t.TypeOf<typeof TransactionIntent>;

package/src/schema/transactionRequest/intents/mmiSignTransactionIntent.ts

@@ -0,0 +1,13 @@
+import * as t from "io-ts";
+import { PaymentIntent } from "./paymentIntent";
+
+export const MmiSignTransactionIntent = t.intersection([
+  PaymentIntent,
+  t.type({
+    custodianTransactionId: t.string,
+  }),
+]);
+
+export type MmiSignTransactionIntent = t.TypeOf<
+  typeof MmiSignTransactionIntent
+>;

package/src/schema/transactionRequest/intents/recipientEntry.ts

@@ -3,10 +3,14 @@ import { optionalString } from "../../../utils";
 import { Address } from "./address";
 import { Amount } from "./amount";
 
-export const RecipientEntry = t.type({
-  address: Address,
-  amount: Amount,
-  data: optionalString,
-});
+export const RecipientEntry = t.intersection([
+  t.type({
+    address: Address,
+    amount: Amount,
+  }),
+  t.partial({
+    data: optionalString,
+  }),
+]);
 
 export type RecipientEntry = t.TypeOf<typeof RecipientEntry>;

package/src/schema/transactionRequest/intents/solUnstakeIntent.ts

@@ -9,6 +9,8 @@ export const SolUnstakeIntent = t.intersection([
   SolBuildOptions,
   t.type({
     stakingAddress: t.string,
+  }),
+  t.partial({
     amount: Optional(Amount),
     remainingStakingAmount: Optional(Amount),
   }),

package/src/schema/transactionRequest/intents/suiConsolidateIntent.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { SuiBuildOptions } from "./suiBuildOptions";
+import { AccountBaseConsolidateIntent } from "./accountBaseConsolidateIntent";
+
+export const SuiConsolidateIntent = t.intersection([
+  AccountBaseConsolidateIntent,
+  SuiBuildOptions,
+]);
+
+export type SuiConsolidateIntent = t.TypeOf<typeof SuiConsolidateIntent>;

package/src/schema/transactionRequest/intents/suiPaymentIntent.ts

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { SuiBuildOptions } from "./suiBuildOptions";
+import { PaymentIntent } from "./paymentIntent";
+
+export const SuiPaymentIntent = t.intersection([
+  PaymentIntent,
+  SuiBuildOptions,
+]);
+
+export type SuiPaymentIntent = t.TypeOf<typeof SuiPaymentIntent>;

package/src/schema/transactionRequest/intents/suiStakingIntent.ts

@@ -6,7 +6,7 @@ import { RecipientEntry } from "./recipientEntry";
 
 export const SuiStakingIntent = t.intersection([
   StakeIntent,
-  t.type({
+  t.partial({
     validatorAddress: optionalString,
     amount: Optional(Amount),
     recipients: Optional(t.array(RecipientEntry)),

package/src/schema/transactionRequest/intents/suiUnstakingIntent.ts

@@ -7,6 +7,8 @@ export const SuiUnstakingIntent = t.intersection([
   WithdrawIntent,
   t.type({
     stakedSuiObjectId: t.string,
+  }),
+  t.partial({
     amount: Optional(Amount),
   }),
 ]);

package/src/schema/transactionRequest/intents/tokenEnablement.ts

@@ -1,9 +1,13 @@
 import * as t from "io-ts";
 import { optionalString } from "../../../utils";
 
-export const TokenEnablement = t.type({
-  name: t.string,
-  address: optionalString,
-});
+export const TokenEnablement = t.intersection([
+  t.type({
+    name: t.string,
+  }),
+  t.partial({
+    address: optionalString,
+  }),
+]);
 
 export type TokenEnablement = t.TypeOf<typeof TokenEnablement>;

package/src/schema/transactionRequest/intents/tokenRecipientEntryItem.ts

@@ -1,10 +1,14 @@
 import * as t from "io-ts";
 import { optionalString } from "../../../utils";
 
-export const TokenRecipientEntryItem = t.type({
-  tokenId: optionalString,
-  tokenQuantity: t.string,
-  tokenType: t.string,
-});
+export const TokenRecipientEntryItem = t.intersection([
+  t.type({
+    tokenQuantity: t.string,
+    tokenType: t.string,
+  }),
+  t.partial({
+    tokenId: optionalString,
+  }),
+]);
 
 export type TokenRecipientEntryItem = t.TypeOf<typeof TokenRecipientEntryItem>;

package/src/schema/transactionRequest/intents/tonPaymentIntent.ts

@@ -4,7 +4,7 @@ import { optionalString } from "../../../utils";
 
 export const TonPaymentIntent = t.intersection([
   PaymentIntent,
-  t.type({
+  t.partial({
     memo: optionalString,
   }),
 ]);

package/src/schema/transactionRequest/intents/transferTokenIntent.ts

@@ -1,12 +1,10 @@
 import * as t from "io-ts";
 import { BaseIntent } from "./baseIntent";
-import { EthBuildOptions } from "./ethBuildOptions";
 import { TokenRecipientEntry } from "./tokenRecipientEntry";
 import { intentTypes } from "./intentType";
 
 export const TransferTokenIntent = t.intersection([
   BaseIntent,
-  EthBuildOptions,
   t.type({
     intentType: intentTypes.transferToken,
     recipients: t.array(TokenRecipientEntry),

package/src/schema/transactionRequest/intents/unsupportedTokenRecipientEntryItem.ts

@@ -1,7 +1,7 @@
 import * as t from "io-ts";
 import { optionalNumber, optionalString } from "../../../utils";
 
-export const UnsupportedTokenRecipientEntryItem = t.type({
+export const UnsupportedTokenRecipientEntryItem = t.partial({
   tokenContractAddress: optionalString,
   decimals: optionalNumber,
 });

package/src/schema/transactionRequest/intents/withdrawIntent.ts

@@ -8,6 +8,8 @@ export const WithdrawIntent = t.intersection([
   BaseStakeIntent,
   t.type({
     intentType: intentTypes.claim,
+  }),
+  t.partial({
     amount: Optional(Amount),
   }),
 ]);