@bitgo/public-types 2.33.5 → 2.35.0

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

@@ -0,0 +1,97 @@
+import * as t from "io-ts";
+import { AdaConsolidateIntent } from "./adaConsolidateIntent";
+import { AdaPaymentIntent } from "./adaPaymentIntent";
+import { AdaStakeIntent } from "./adaStakeIntent";
+import { AtomPaymentIntent } from "./atomPaymentIntent";
+import { AtomStakeIntent } from "./atomStakeIntent";
+import { AtomUnstakeIntent } from "./atomUnstakeIntent";
+import { AtomWithdrawIntent } from "./atomWithdrawIntent";
+import { BscDelegateIntent } from "./bscDelegateIntent";
+import { BscUnDelegateIntent } from "./bscUndelegateIntent";
+import { BscWithdrawIntent } from "./bscWithdrawIntent";
+import { CosmosPaymentIntent } from "./cosmosPaymentIntent";
+import { CosmosStakeIntent } from "./cosmosStakeIntent";
+import { CosmosSwitchValidatorIntent } from "./cosmosSwitchValidatorIntent";
+import { CosmosUnstakeIntent } from "./cosmosUnstakeIntent";
+import { CosmosWithdrawIntent } from "./cosmosWithdrawIntent";
+import { DotCreateAccountIntent } from "./dotCreateAccountIntent";
+import { DotPaymentIntent } from "./dotPaymentIntent";
+import { DotStakingIntent } from "./dotStakingIntent";
+import { DotUnstakingIntent } from "./dotUnstakingIntent";
+import { DotWithdrawStakeIntent } from "./dotWithdrawStakeIntent";
+import { EthAccelerationIntent } from "./ethAccelerationIntent";
+import { EthFillNonceIntent } from "./ethFillNonceIntent";
+import { EthPaymentIntent } from "./ethPaymentIntent";
+import { EthStakingIntent } from "./ethStakingIntent";
+import { LightningPaymentIntent } from "./lightningPaymentIntent";
+import { MmiSignMessageIntent } from "./mmiSignMessageIntent";
+import { NearStakeIntent } from "./nearStakeIntent";
+import { NearUnstakeIntent } from "./nearUnstakeIntent";
+import { NearWithdrawIntent } from "./nearWithdrawIntent";
+import { SolAuthorizeIntent } from "./solAuthorizeIntent";
+import { SolClaimIntent } from "./solClaimIntent";
+import { SolCreateAssociatedTokenAccountIntent } from "./solCreateAssociatedTokenAccountIntent";
+import { SolDeactivateIntent } from "./solDeactivateIntent";
+import { SolDelegateIntent } from "./solDelegateIntent";
+import { SolStakeIntent } from "./solStakeIntent";
+import { SolUnstakeIntent } from "./solUnstakeIntent";
+import { SuiCustomTxIntent } from "./suiCustomTxIntent";
+import { SuiStakingIntent } from "./suiStakingIntent";
+import { SuiUnstakingIntent } from "./suiUnstakingIntent";
+import { TonDelegateIntent } from "./tonDelegateIntent";
+import { TonPaymentIntent } from "./tonPaymentIntent";
+import { TonUndelegateIntent } from "./tonUndelegateIntent";
+import { WalletRecoveryIntent } from "./walletRecoveryIntent";
+
+export const TransactionIntent = t.union([
+  AdaConsolidateIntent,
+  AdaPaymentIntent,
+  AdaPaymentIntent,
+  AdaStakeIntent,
+  AtomPaymentIntent,
+  AtomStakeIntent,
+  AtomUnstakeIntent,
+  AtomWithdrawIntent,
+  BscDelegateIntent,
+  BscUnDelegateIntent,
+  BscWithdrawIntent,
+  CosmosPaymentIntent,
+  CosmosStakeIntent,
+  CosmosSwitchValidatorIntent,
+  CosmosUnstakeIntent,
+  CosmosWithdrawIntent,
+  DotCreateAccountIntent,
+  DotPaymentIntent,
+  DotStakingIntent,
+  DotUnstakingIntent,
+  DotWithdrawStakeIntent,
+  EthAccelerationIntent,
+  EthFillNonceIntent,
+  EthPaymentIntent,
+  EthStakingIntent,
+  LightningPaymentIntent,
+  MmiSignMessageIntent,
+  NearStakeIntent,
+  NearUnstakeIntent,
+  NearWithdrawIntent,
+  SolAuthorizeIntent,
+  SolClaimIntent,
+  SolCreateAssociatedTokenAccountIntent,
+  SolDeactivateIntent,
+  SolDelegateIntent,
+  SolStakeIntent,
+  SolUnstakeIntent,
+  SuiCustomTxIntent,
+  SuiStakingIntent,
+  SuiUnstakingIntent,
+  TonDelegateIntent,
+  TonPaymentIntent,
+  TonUndelegateIntent,
+  WalletRecoveryIntent,
+  /**
+   * Catch all for past intents that have not been converted to codecs
+   */
+  t.unknown,
+]);
+
+export type TransactionIntent = t.TypeOf<typeof TransactionIntent>;

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

@@ -0,0 +1,36 @@
+import * as t from "io-ts";
+
+export const intentTypes = {
+  payment: t.literal("payment"),
+  transferToken: t.literal("transferToken"),
+  consolidate: t.literal("consolidate"),
+  consolidateToken: t.literal("consolidateToken"),
+  fanout: t.literal("fanout"),
+  stake: t.literal("stake"),
+  unstake: t.literal("unstake"),
+  delegate: t.literal("delegate"),
+  undelegate: t.literal("undelegate"),
+  switchValidator: t.literal("switchValidator"),
+  claim: t.literal("claim"),
+  stakeClaimRewards: t.literal("stakeClaimRewards"),
+  pledge: t.literal("pledge"),
+  vote: t.literal("vote"),
+  createAccount: t.literal("createAccount"),
+  updateAccount: t.literal("updateAccount"),
+  addTrustLine: t.literal("addTrustLine"),
+  removeTrustLine: t.literal("removeTrustLine"),
+  signMessage: t.literal("signMessage"),
+  signTypedStructuredData: t.literal("signTypedStructuredData"),
+  enableToken: t.literal("enableToken"),
+  authorize: t.literal("authorize"),
+  acceleration: t.literal("acceleration"),
+  fillNonce: t.literal("fillNonce"),
+  walletRecovery: t.literal("walletRecovery"),
+  contractCall: t.literal("contractCall"),
+  deactivate: t.literal("deactivate"),
+  customTx: t.literal("customTx"),
+};
+
+export const IntentType = t.keyof(intentTypes);
+
+export type IntentType = t.TypeOf<typeof IntentType>;

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

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+export const LightningPaymentIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intentType: intentTypes.payment,
+    invoice: t.string,
+    signedInvoice: t.string,
+  }),
+]);
+
+export type LightningPaymentIntent = t.TypeOf<typeof LightningPaymentIntent>;

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

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

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { StakeIntent } from "./stakeIntent";
+import { RecipientEntry } from "./recipientEntry";
+
+export const NearStakeIntent = t.intersection([
+  StakeIntent,
+  t.type({
+    recipients: t.array(RecipientEntry),
+  }),
+]);
+
+export type NearStakeIntent = t.TypeOf<typeof NearStakeIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { RecipientEntry } from "./recipientEntry";
+import { UnstakeIntent } from "./unstakeIntent";
+
+export const NearUnstakeIntent = t.intersection([
+  UnstakeIntent,
+  t.type({
+    recipients: t.array(RecipientEntry),
+  }),
+]);
+
+export type NearUnstakeIntent = t.TypeOf<typeof NearUnstakeIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { RecipientEntry } from "./recipientEntry";
+import { WithdrawIntent } from "./withdrawIntent";
+
+export const NearWithdrawIntent = t.intersection([
+  WithdrawIntent,
+  t.type({
+    recipients: t.array(RecipientEntry),
+  }),
+]);
+
+export type NearWithdrawIntent = t.TypeOf<typeof NearWithdrawIntent>;

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

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+import { RecipientEntry } from "./recipientEntry";
+
+export const PaymentIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intent: intentTypes.payment,
+    recipients: t.array(RecipientEntry),
+  }),
+]);
+
+export type PaymentIntent = t.TypeOf<typeof PaymentIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { optionalString } from "../../../utils";
+import { Address } from "./address";
+import { Amount } from "./amount";
+
+export const RecipientEntry = t.type({
+  address: Address,
+  amount: Amount,
+  data: optionalString,
+});
+
+export type RecipientEntry = t.TypeOf<typeof RecipientEntry>;

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

@@ -0,0 +1,23 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+import { optionalString } from "../../../utils";
+
+export const SignMessageIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intentType: intentTypes.signMessage,
+    /**
+     * A plain text message
+     * @example for EVM: test message
+     */
+    messageRaw: t.string,
+    /**
+     * An encoded string
+     * @example for EVM: \x19Ethereum Signed Message:\n12test message
+     */
+    messageEncoded: optionalString,
+  }),
+]);
+
+export type SignMessageIntent = t.TypeOf<typeof SignMessageIntent>;

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

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+export const SolAuthorizeIntent = t.intersection([
+  BaseIntent,
+  SolBuildOptions,
+  t.type({
+    intentType: intentTypes.authorize,
+    transactionMessage: t.string,
+    stakeAccount: t.string,
+    oldWithdrawPublicKey: t.string,
+    newWithdrawPublicKey: t.string,
+    lockupPublicKey: t.string,
+    nonceAccount: t.string,
+    nonceAuthority: t.string,
+    blockhash: t.string,
+  }),
+]);
+
+export type SolAuthorizeIntent = t.TypeOf<typeof SolAuthorizeIntent>;

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

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

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

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

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { EnableTokenIntent } from "./enableTokenIntent";
+
+export const SolCreateAssociatedTokenAccountIntent = t.intersection([
+  EnableTokenIntent,
+  SolBuildOptions,
+]);
+
+export type SolCreateAssociatedTokenAccountIntent = t.TypeOf<
+  typeof SolCreateAssociatedTokenAccountIntent
+>;

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+import { optionalString, optionalStringArray } from "../../../utils";
+
+export const SolDeactivateIntent = t.intersection([
+  BaseIntent,
+  SolBuildOptions,
+  t.type({
+    intentType: intentTypes.deactivate,
+    stakingAddresses: optionalStringArray,
+    stakingAddress: optionalString,
+  }),
+]);
+
+export type SolDeactivateIntent = t.TypeOf<typeof SolDeactivateIntent>;

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

@@ -0,0 +1,18 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+import { optionalString, optionalStringArray } from "../../../utils";
+
+export const SolDelegateIntent = t.intersection([
+  BaseIntent,
+  SolBuildOptions,
+  t.type({
+    intentType: intentTypes.delegate,
+    validatorAddress: t.string,
+    stakingAddresses: optionalStringArray,
+    stakingAddress: optionalString,
+  }),
+]);
+
+export type SolDelegateIntent = t.TypeOf<typeof SolDelegateIntent>;

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

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

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

@@ -0,0 +1,15 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { StakeIntent } from "./stakeIntent";
+import { Amount } from "./amount";
+
+export const SolStakeIntent = t.intersection([
+  StakeIntent,
+  SolBuildOptions,
+  t.type({
+    validatorAddress: t.string,
+    amount: Amount,
+  }),
+]);
+
+export type SolStakeIntent = t.TypeOf<typeof SolStakeIntent>;

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+import { SolBuildOptions } from "./solBuildOptions";
+import { Amount } from "./amount";
+import { UnstakeIntent } from "./unstakeIntent";
+import { Optional } from "../../../utils";
+
+export const SolUnstakeIntent = t.intersection([
+  UnstakeIntent,
+  SolBuildOptions,
+  t.type({
+    stakingAddress: t.string,
+    amount: Optional(Amount),
+    remainingStakingAmount: Optional(Amount),
+  }),
+]);
+
+export type SolUnstakeIntent = t.TypeOf<typeof SolUnstakeIntent>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { intentTypes } from "./intentType";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { Amount } from "./amount";
+
+export const StakeClaimRewardsIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.stakeClaimRewards,
+    amount: Amount,
+  }),
+]);

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { BaseStakeIntent } from "./baseStakeIntent";
+import { intentTypes } from "./intentType";
+
+export const StakeIntent = t.intersection([
+  BaseStakeIntent,
+  t.type({
+    intentType: intentTypes.stake,
+  }),
+]);
+
+export type StakeIntent = t.TypeOf<typeof StakeIntent>;

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

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

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

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { optionalString } from "../../../utils";
+import { SuiFeeOptions } from "./suiFeeOptions";
+
+export const SuiBuildOptions = t.intersection([
+  BaseIntent,
+  t.type({
+    feeOptions: SuiFeeOptions,
+    lockedAmount: optionalString,
+  }),
+]);
+
+export type SuiBuildOptions = t.TypeOf<typeof SuiBuildOptions>;

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

@@ -0,0 +1,15 @@
+import * as t from "io-ts";
+import { SuiBuildOptions } from "./suiBuildOptions";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+export const SuiCustomTxIntent = t.intersection([
+  BaseIntent,
+  SuiBuildOptions,
+  t.type({
+    intentType: intentTypes.customTx,
+    rawTx: t.string,
+  }),
+]);
+
+export type SuiCustomTxIntent = t.TypeOf<typeof SuiCustomTxIntent>;

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

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+
+export const SuiFeeOptions = t.type({
+  gasLimit: t.number,
+});
+
+export type SuiFeeOptions = t.TypeOf<typeof SuiFeeOptions>;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+import { StakeIntent } from "./stakeIntent";
+import { Optional, optionalString } from "../../../utils";
+import { Amount } from "./amount";
+import { RecipientEntry } from "./recipientEntry";
+
+export const SuiStakingIntent = t.intersection([
+  StakeIntent,
+  t.type({
+    validatorAddress: optionalString,
+    amount: Optional(Amount),
+    recipients: Optional(t.array(RecipientEntry)),
+  }),
+]);
+
+export type SuiStakingIntent = t.TypeOf<typeof SuiStakingIntent>;

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

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

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

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+
+export const SupportedTokenRecipientEntryItem = t.type({
+  tokenName: t.string,
+});
+
+export type SupportedTokenRecipientEntryItem = t.TypeOf<
+  typeof SupportedTokenRecipientEntryItem
+>;

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { TokenRecipientEntryItem } from "./tokenRecipientEntryItem";
+import { SupportedTokenRecipientEntryItem } from "./supportedTokenRecipientEntryItem";
+import { UnsupportedTokenRecipientEntryItem } from "./unsupportedTokenRecipientEntryItem";
+
+export const TokenData = t.intersection([
+  TokenRecipientEntryItem,
+  SupportedTokenRecipientEntryItem,
+  UnsupportedTokenRecipientEntryItem,
+]);
+
+export type TokenData = t.TypeOf<typeof TokenData>;

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

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

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

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+import { RecipientEntry } from "./recipientEntry";
+import { TokenData } from "./tokenData";
+
+export const TokenRecipientEntry = t.intersection([
+  RecipientEntry,
+  t.type({
+    tokenData: TokenData,
+  }),
+]);
+
+export type TokenRecipientEntry = t.TypeOf<typeof TokenRecipientEntry>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+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),
+  }),
+]);
+
+export type TransferTokenIntent = t.TypeOf<typeof TransferTokenIntent>;