@bitgo/public-types 2.33.5 → 2.35.0

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

@@ -0,0 +1,13 @@
+import * as t from "io-ts";
+import { Amount } from "./amount";
+import { WithdrawIntent } from "./withdrawIntent";
+
+export const AtomWithdrawIntent = t.intersection([
+  WithdrawIntent,
+  t.type({
+    validatorAddress: t.string,
+    amount: Amount,
+  }),
+]);
+
+export type AtomWithdrawIntent = t.TypeOf<typeof AtomWithdrawIntent>;

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

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

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+
+export const BaseStakeIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    stakingRequestId: t.string,
+  }),
+]);
+
+export type BaseStakeIntent = t.TypeOf<typeof BaseStakeIntent>;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { Amount } from "./amount";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+
+export const BscDelegateIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.delegate,
+    validatorAddress: t.string,
+    amount: Amount,
+    relayerFee: Amount,
+  }),
+]);
+
+export type BscDelegateIntent = t.TypeOf<typeof BscDelegateIntent>;

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

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+import { StakeClaimRewardsIntent } from "./stakeClaimRewardsIntent";
+
+export const BscStakeClaimRewardsIntent = StakeClaimRewardsIntent;
+
+export type BscStakeClaimRewardsIntent = t.TypeOf<
+  typeof BscStakeClaimRewardsIntent
+>;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { Amount } from "./amount";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+
+export const BscUnDelegateIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.undelegate,
+    validatorAddress: t.string,
+    amount: Amount,
+    relayerFee: Amount,
+  }),
+]);
+
+export type BscUnDelegateIntent = t.TypeOf<typeof BscUnDelegateIntent>;

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

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

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

@@ -0,0 +1,19 @@
+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 ConsolidateTokenIntent = t.intersection([
+  BaseIntent,
+  EthBuildOptions,
+  t.type({
+    intentType: intentTypes.consolidateToken,
+    recipients: t.array(TokenRecipientEntry),
+    consolidateId: optionalString,
+    keepAlive: optionalBoolean,
+  }),
+]);
+
+export type ConsolidateTokenIntent = t.TypeOf<typeof ConsolidateTokenIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { PaymentIntent } from "./paymentIntent";
+import { optionalString } from "../../../utils";
+
+export const CosmosPaymentIntent = t.intersection([
+  PaymentIntent,
+  t.type({
+    memo: optionalString,
+  }),
+]);
+
+export type CosmosPaymentIntent = t.TypeOf<typeof CosmosPaymentIntent>;

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+import { Amount } from "./amount";
+import { RecipientEntry } from "./recipientEntry";
+import { Optional } from "../../../utils";
+
+export const CosmosStakeIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.delegate,
+    validatorAddress: t.string,
+    amount: Amount,
+    recipients: Optional(t.array(RecipientEntry)),
+  }),
+]);
+
+export type CosmosStakeIntent = t.TypeOf<typeof CosmosStakeIntent>;

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

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+import { StakeSwitchValidatorIntent } from "./stakeSwitchValidatorIntent";
+
+export const CosmosSwitchValidatorIntent = StakeSwitchValidatorIntent;
+
+export type CosmosSwitchValidatorIntent = t.TypeOf<
+  typeof CosmosSwitchValidatorIntent
+>;

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+import { Amount } from "./amount";
+import { RecipientEntry } from "./recipientEntry";
+import { Optional } from "../../../utils";
+
+export const CosmosUnstakeIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.undelegate,
+    validatorAddress: t.string,
+    amount: Amount,
+    recipients: Optional(t.array(RecipientEntry)),
+  }),
+]);
+
+export type CosmosUnstakeIntent = t.TypeOf<typeof CosmosUnstakeIntent>;

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { WithdrawIntent } from "./withdrawIntent";
+
+export const CosmosWithdrawIntent = t.intersection([
+  WithdrawIntent,
+  t.type({
+    validatorAddress: t.string,
+  }),
+]);
+
+export type CosmosWithdrawIntent = t.TypeOf<typeof CosmosWithdrawIntent>;

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

@@ -0,0 +1,15 @@
+import * as t from "io-ts";
+import { AccountBaseBuildOptions } from "./accountBaseBuildOptions";
+import { DotFeeOptions } from "./dotFeeOptions";
+import { Optional } from "../../../utils";
+
+export const DotAccountBaseBuildOptions = t.intersection([
+  AccountBaseBuildOptions,
+  t.type({
+    fee: Optional(DotFeeOptions),
+  }),
+]);
+
+export type DotAccountBaseBuildOptions = t.TypeOf<
+  typeof DotAccountBaseBuildOptions
+>;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { Optional, optionalNumber } from "../../../utils";
+import { DotFeeOptions } from "./dotFeeOptions";
+import { RecipientEntry } from "./recipientEntry";
+import { BaseIntent } from "./baseIntent";
+
+export const DotBaseIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    senderAddressIndex: optionalNumber,
+    fee: Optional(DotFeeOptions),
+    recipients: Optional(t.array(RecipientEntry)),
+  }),
+]);
+
+export type DotBaseIntent = t.TypeOf<typeof DotBaseIntent>;

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

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+import { DotAccountBaseBuildOptions } from "./dotAccountBaseBuildOptions";
+import { Optional, optionalNumber } from "../../../utils";
+import { RecipientEntry } from "./recipientEntry";
+import { AccountBaseCreateAccountIntent } from "./accountBaseCreateAccountIntent";
+
+export const DotCreateAccountIntent = t.intersection([
+  AccountBaseCreateAccountIntent,
+  DotAccountBaseBuildOptions,
+  t.type({
+    delayBlocks: t.string,
+    proxyType: t.string,
+    index: optionalNumber,
+    // recipients array can be undefined or empty if txn is for anonymous proxy
+    recipients: Optional(t.array(RecipientEntry)),
+  }),
+]);
+
+export type DotCreateAccountIntent = t.TypeOf<typeof DotCreateAccountIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { FeeUnit } from "./feeOptionUnit";
+import { Optional } from "../../../utils";
+import { FeeFormula } from "./feeOptionFormula";
+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),
+});

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { DotAccountBaseBuildOptions } from "./dotAccountBaseBuildOptions";
+import { optionalString } from "../../../utils";
+import { PaymentIntent } from "./paymentIntent";
+import { DotProxy } from "./dotProxy";
+
+export const DotPaymentIntent = t.intersection([
+  PaymentIntent,
+  DotAccountBaseBuildOptions,
+  t.type({
+    proxy: DotProxy,
+    owner: optionalString,
+  }),
+]);
+
+export type DotPaymentIntent = t.TypeOf<typeof DotPaymentIntent>;

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { optionalString } from "../../../utils";
+
+export const DotProxy = t.type({
+  name: optionalString,
+  addressString: optionalString,
+  asset: optionalString,
+  amountString: optionalString,
+});
+
+export type DotProxy = t.TypeOf<typeof DotProxy>;

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import { DotAccountBaseBuildOptions } from "./dotAccountBaseBuildOptions";
+import { Amount } from "./amount";
+import { StakeIntent } from "./stakeIntent";
+import { optionalBoolean } from "../../../utils";
+
+export const DotStakingIntent = t.intersection([
+  StakeIntent,
+  DotAccountBaseBuildOptions,
+  t.type({
+    amount: Amount,
+    stakingProxy: t.string,
+    addToStake: optionalBoolean,
+    addProxy: optionalBoolean,
+  }),
+]);
+
+export type DotStakingIntent = t.TypeOf<typeof DotStakingIntent>;

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+import { UnstakeIntent } from "./unstakeIntent";
+import { DotAccountBaseBuildOptions } from "./dotAccountBaseBuildOptions";
+import { Amount } from "./amount";
+import { optionalBoolean } from "../../../utils";
+
+export const DotUnstakingIntent = t.intersection([
+  UnstakeIntent,
+  DotAccountBaseBuildOptions,
+  t.type({
+    amount: Amount,
+    stakingProxy: t.string,
+    stopStaking: optionalBoolean,
+  }),
+]);
+
+export type DotUnstakingIntent = t.TypeOf<typeof DotUnstakingIntent>;

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

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { DotAccountBaseBuildOptions } from "./dotAccountBaseBuildOptions";
+import { WithdrawIntent } from "./withdrawIntent";
+
+export const DotWithdrawStakeIntent = t.intersection([
+  WithdrawIntent,
+  DotAccountBaseBuildOptions,
+]);
+
+export type DotWithdrawStakeIntent = t.TypeOf<typeof DotWithdrawStakeIntent>;

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

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { optionalNumber } from "../../../utils";
+
+export const EIP1559FeeOptions = t.type({
+  gasLimit: optionalNumber,
+  maxFeePerGas: optionalNumber,
+  maxPriorityFeePerGas: optionalNumber,
+});
+
+export type EIP1559FeeOptions = t.TypeOf<typeof EIP1559FeeOptions>;

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

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+import { intentTypes } from "./intentType";
+import { BaseIntent } from "./baseIntent";
+import { TokenEnablement } from "./tokenEnablement";
+
+export const EnableTokenIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intentType: intentTypes.enableToken,
+    enableTokens: t.array(TokenEnablement),
+  }),
+]);
+
+export type EnableTokenIntent = t.TypeOf<typeof EnableTokenIntent>;

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

@@ -0,0 +1,15 @@
+import * as t from "io-ts";
+import { AccelerationIntent } from "./accelerationIntent";
+import { EthBuildOptionsWithoutFeeOptions } from "./ethBuildOptions";
+import { FeeOption } from "./feeOption";
+import { EIP1559FeeOptions } from "./eip1559FeeOptions";
+
+export const EthAccelerationIntent = t.intersection([
+  AccelerationIntent,
+  EthBuildOptionsWithoutFeeOptions,
+  t.type({
+    feeOptions: t.union([FeeOption, EIP1559FeeOptions]),
+  }),
+]);
+
+export type EthAccelerationIntent = t.TypeOf<typeof EthAccelerationIntent>;

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

@@ -0,0 +1,27 @@
+import * as t from "io-ts";
+import { AccountBaseBuildOptions } from "./accountBaseBuildOptions";
+import { Optional, optionalNumber, optionalString } from "../../../utils";
+import { FeeOption } from "./feeOption";
+import { EIP1559FeeOptions } from "./eip1559FeeOptions";
+import { HopParams } from "./hopParams";
+
+export const EthBuildOptions = t.intersection([
+  AccountBaseBuildOptions,
+  t.type({
+    feeOptions: Optional(t.union([FeeOption, EIP1559FeeOptions])),
+    hopParams: Optional(HopParams),
+    receiveAddress: optionalString,
+    senderAddressIndex: optionalNumber,
+  }),
+]);
+
+export type EthBuildOptions = t.TypeOf<typeof EthBuildOptions>;
+
+export const EthBuildOptionsWithoutFeeOptions = t.intersection([
+  AccountBaseBuildOptions,
+  t.type({
+    hopParams: Optional(HopParams),
+    receiveAddress: optionalString,
+    senderAddressIndex: optionalNumber,
+  }),
+]);

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import { FillNonceIntent } from "./fillNonceIntent";
+import { Optional, optionalNumber, optionalString } from "../../../utils";
+import { FeeOption } from "./feeOption";
+import { EIP1559FeeOptions } from "./eip1559FeeOptions";
+
+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,
+  }),
+]);
+
+export type EthFillNonceIntent = t.TypeOf<typeof EthFillNonceIntent>;

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

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

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { StakeIntent } from "./stakeIntent";
+import { EthBuildOptions } from "./ethBuildOptions";
+
+export const EthStakingIntent = t.intersection([
+  StakeIntent,
+  EthBuildOptions,
+  t.type({
+    pubkey: t.string,
+    withdrawalCredentials: t.string,
+    signature: t.string,
+    depositDataRoot: t.string,
+  }),
+]);
+
+export type EthStakingIntent = t.TypeOf<typeof EthStakingIntent>;

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

@@ -0,0 +1,13 @@
+import * as t from "io-ts";
+import { Optional, optionalNumber } from "../../../utils";
+import { FeeUnit } from "./feeOptionUnit";
+import { FeeFormula } from "./feeOptionFormula";
+import { FeeType } from "./feeOptionFeeType";
+
+export const FeeOption = t.type({
+  unit: Optional(FeeUnit),
+  formula: Optional(FeeFormula),
+  feeType: Optional(FeeType),
+  gasLimit: optionalNumber,
+  gasPrice: optionalNumber,
+});

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+export const feeTypes = {
+  base: t.literal("base"),
+  max: t.literal("max"),
+  tip: t.literal("tip"),
+};
+
+export const FeeType = t.keyof(feeTypes);
+
+export type FeeType = t.TypeOf<typeof FeeType>;

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

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

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

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+
+export const feeUnits = {
+  baseUnit: t.literal("baseUnit"),
+  cpu: t.literal("cpu"),
+  ram: t.literal("ram"),
+};
+
+export const FeeUnit = t.keyof(feeUnits);
+
+export type FeeUnit = t.TypeOf<typeof FeeUnit>;

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

@@ -0,0 +1,13 @@
+import * as t from "io-ts";
+import { BaseIntentWithoutNonce } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+export const FillNonceIntent = t.intersection([
+  BaseIntentWithoutNonce,
+  t.type({
+    intentType: intentTypes.fillNonce,
+    nonce: t.union([t.string, t.number]),
+  }),
+]);
+
+export type FillNonceIntent = t.TypeOf<typeof FillNonceIntent>;

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

@@ -0,0 +1,10 @@
+import * as t from "io-ts";
+import { optionalNumber, optionalString } from "../../../utils";
+
+export const HopParams = t.type({
+  paymentId: optionalString,
+  userReqSig: optionalString,
+  gasPriceMax: optionalNumber,
+});
+
+export type HopParams = t.TypeOf<typeof HopParams>;

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

@@ -0,0 +1,89 @@
+export * from "./accelerationIntent";
+export * from "./accountBaseBuildOptions";
+export * from "./accountBaseConsolidateIntent";
+export * from "./accountBaseCreateAccountIntent";
+export * from "./accountBaseUpdateAccountIntent";
+export * from "./adaConsolidateIntent";
+export * from "./adaPaymentIntent";
+export * from "./adaPledgeIntent";
+export * from "./adaStakeIntent";
+export * from "./address";
+export * from "./amount";
+export * from "./atomPaymentIntent";
+export * from "./atomStakeIntent";
+export * from "./atomUnstakeIntent";
+export * from "./atomWithdrawIntent";
+export * from "./baseIntent";
+export * from "./baseStakeIntent";
+export * from "./bscDelegateIntent";
+export * from "./bscStakeClaimRewardsIntent";
+export * from "./bscUndelegateIntent";
+export * from "./bscWithdrawIntent";
+export * from "./consolidateTokenIntent";
+export * from "./cosmosPaymentIntent";
+export * from "./cosmosStakeIntent";
+export * from "./cosmosSwitchValidatorIntent";
+export * from "./cosmosUnstakeIntent";
+export * from "./cosmosWithdrawIntent";
+export * from "./dotAccountBaseBuildOptions";
+export * from "./dotBaseIntent";
+export * from "./dotCreateAccountIntent";
+export * from "./dotFeeOptions";
+export * from "./dotPaymentIntent";
+export * from "./dotProxy";
+export * from "./dotStakingIntent";
+export * from "./dotUnstakingIntent";
+export * from "./dotWithdrawStakeIntent";
+export * from "./eip1559FeeOptions";
+export * from "./enableTokenIntent";
+export * from "./ethAccelerationIntent";
+export * from "./ethBuildOptions";
+export * from "./ethFillNonceIntent";
+export * from "./ethPaymentIntent";
+export * from "./ethStakingIntent";
+export * from "./feeOption";
+export * from "./feeOptionFeeType";
+export * from "./feeOptionFormula";
+export * from "./feeOptionUnit";
+export * from "./fillNonceIntent";
+export * from "./hopParams";
+export * from "./intent";
+export * from "./intentType";
+export * from "./lightningPaymentIntent";
+export * from "./mmiSignMessageIntent";
+export * from "./nearStakeIntent";
+export * from "./nearUnstakeIntent";
+export * from "./nearWithdrawIntent";
+export * from "./paymentIntent";
+export * from "./recipientEntry";
+export * from "./signMessageIntent";
+export * from "./solAuthorizeIntent";
+export * from "./solBuildOptions";
+export * from "./solClaimIntent";
+export * from "./solCreateAssociatedTokenAccountIntent";
+export * from "./solDeactivateIntent";
+export * from "./solDelegateIntent";
+export * from "./solPaymentIntent";
+export * from "./solStakeIntent";
+export * from "./solUnstakeIntent";
+export * from "./stakeClaimRewardsIntent";
+export * from "./stakeIntent";
+export * from "./stakeSwitchValidatorIntent";
+export * from "./suiBuildOptions";
+export * from "./suiCustomTxIntent";
+export * from "./suiFeeOptions";
+export * from "./suiStakingIntent";
+export * from "./suiUnstakingIntent";
+export * from "./supportedTokenRecipientEntryItem";
+export * from "./tokenData";
+export * from "./tokenEnablement";
+export * from "./tokenRecipientEntry";
+export * from "./tokenRecipientEntryItem";
+export * from "./tonDelegateIntent";
+export * from "./tonPaymentIntent";
+export * from "./tonUndelegateIntent";
+export * from "./transferTokenIntent";
+export * from "./unstakeIntent";
+export * from "./unsupportedTokenRecipientEntryItem";
+export * from "./walletRecoveryIntent";
+export * from "./withdrawIntent";