@bitgo/public-types 6.28.0 → 6.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo/public-types",
-  "version": "6.28.0",
+  "version": "6.30.0",
   "description": "Collection of types exposed externally as part of the BitGo public API",
   "license": "UNLICENSED",
   "author": "",

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

@@ -2,16 +2,15 @@ import * as t from "io-ts";
 import { BaseIntent } from "./baseIntent";
 
 /**
- * @title BaseGoStakeIntent
- *
- * @description base interface for Go staking intents.
- *
- * @param {string} goStakingRequestId - The unique identifier for the Go staking request.
+ * Base interface for GO wallet staking intents that require a GO staking
+ * request identifier (e.g. admin/internal go-unstake flows such as Sui).
  *
+ * @title BaseGoStakeIntent
  */
 export const BaseGoStakeIntent = t.intersection([
   BaseIntent,
   t.type({
+    /** Internal coordination identifier for the GO staking request. */
     goStakingRequestId: t.string,
   }),
 ]);

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

@@ -0,0 +1,40 @@
+import * as t from "io-ts";
+import { BaseIntent } from "./baseIntent";
+import { intentTypes } from "./intentType";
+
+/**
+ * @title Canton Participant Onboarding Request Intent
+ *
+ * Intent for BitGo to create a ParticipantOnboardingRequest on the Canton ledger.
+ * Submits a CreateCommand for `Dtc.Registry.V1.Service.Participant:ParticipantOnboardingRequest`.
+ * DTCC (not BitGo) accepts the request — BitGo only submits the initial create.
+ *
+ * @param {String} intentType - The type of intent (always set to cantonParticipantOnboardingRequest)
+ * @param {string} operator - DTCC operator party ID
+ * @param {string} provider - DTCC provider party ID (typically same as operator on testnet)
+ * @param {string} compliance - DTCC compliance party ID
+ * @param {string} registrar - DTCC registrar party ID
+ * @param {string} clientOnboarder - DTCC client onboarder party ID
+ * @param {string} [expirationIso] - Optional ISO 8601 expiration timestamp; IMS defaults to 7 days if not provided
+ * @param {string} [comment] - Optional human-readable comment
+ */
+export const CantonParticipantOnboardingRequestIntent = t.intersection([
+  BaseIntent,
+  t.type({
+    intentType: intentTypes.cantonParticipantOnboardingRequest,
+    // DTCC party IDs — passed from UI → WP → IMS; NOT hardcoded in IMS (vary per environment)
+    operator: t.string,
+    provider: t.string, // typically same value as operator on testnet
+    compliance: t.string,
+    registrar: t.string,
+    clientOnboarder: t.string,
+  }),
+  t.partial({
+    expirationIso: t.string, // IMS defaults to 7 days if not provided
+    comment: t.string,
+  }),
+]);
+
+export type CantonParticipantOnboardingRequestIntent = t.TypeOf<
+  typeof CantonParticipantOnboardingRequestIntent
+>;

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

@@ -6,7 +6,9 @@ import { TokenEnablement } from "./tokenEnablement";
 export const EnableTokenIntent = t.intersection([
   BaseIntent,
   t.type({
+    /** Must be "enableToken". */
     intentType: intentTypes.enableToken,
+    /** One or more token entries specifying which tokens to enable. */
     enableTokens: t.array(TokenEnablement),
   }),
 ]);

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

@@ -1,20 +1,21 @@
 import * as t from "io-ts";
 import { RecipientEntry } from "./recipientEntry";
 import { intentTypes } from "./intentType";
-import { BaseGoStakeIntent } from "./baseGoStakeIntent";
+import { BaseIntent } from "./baseIntent";
 
 /**
- * @title GoUnstakeIntent
- *
- * @description interface for Go unstake intents.
- *
- * @param {RecipientEntry[]} recipients - An array of recipient entries, for the address and amount.
+ * Base intent for GO wallet unstaking operations. Chain-specific go-unstake
+ * intents (e.g. Sol, Sui) compose this and declare `goStakingRequestId`
+ * according to their own requirements (optional for Sol, required for Sui).
  *
+ * @title GoUnstakeIntent
  */
 export const GoUnstakeIntent = t.intersection([
-  BaseGoStakeIntent,
+  BaseIntent,
   t.type({
+    /** Must be "goUnstake". */
     intentType: intentTypes.goUnstake,
+    /** The recipients to send unstaked funds to. */
     recipients: t.array(RecipientEntry),
   }),
 ]);

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

@@ -46,6 +46,7 @@ export * from "./cantonTransferRejectIntent";
 export * from "./cantonEndInvestorOnboardingOfferIntent";
 export * from "./cantonEndInvestorOnboardingAcceptIntent";
 export * from "./cantonEndInvestorOnboardingRejectIntent";
+export * from "./cantonParticipantOnboardingRequestIntent";
 export * from "./claimIntent";
 export * from "./consolidateTokenIntent";
 export * from "./coredaoClaimIntent";

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

@@ -126,6 +126,7 @@ import { CantonTransferRejectIntent } from "./cantonTransferRejectIntent";
 import { CantonEndInvestorOnboardingOfferIntent } from "./cantonEndInvestorOnboardingOfferIntent";
 import { CantonEndInvestorOnboardingAcceptIntent } from "./cantonEndInvestorOnboardingAcceptIntent";
 import { CantonEndInvestorOnboardingRejectIntent } from "./cantonEndInvestorOnboardingRejectIntent";
+import { CantonParticipantOnboardingRequestIntent } from "./cantonParticipantOnboardingRequestIntent";
 import { TonWhalesDelegateIntent } from "./tonWhalesDelegateIntent";
 import { TonWhalesUndelegateIntent } from "./tonWhalesUndelegateIntent";
 import { TrxClaimRewardsIntent } from "./trxClaimRewardsIntent";
@@ -175,6 +176,7 @@ export const TransactionIntent = t.union([
   CantonEndInvestorOnboardingOfferIntent,
   CantonEndInvestorOnboardingAcceptIntent,
   CantonEndInvestorOnboardingRejectIntent,
+  CantonParticipantOnboardingRequestIntent,
   ClaimIntent,
   CosmosContractCallIntent,
   CosmosPaymentIntent,

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

@@ -71,6 +71,9 @@ export const intentTypes = {
   cantonEndInvestorOnboardingReject: t.literal(
     "cantonEndInvestorOnboardingReject",
   ),
+  cantonParticipantOnboardingRequest: t.literal(
+    "cantonParticipantOnboardingRequest",
+  ),
   /**
    * Deposit assets into a DeFi protocol vault (e.g. Concrete USD1 → ctUSD1cx).
    */

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

@@ -4,20 +4,31 @@ import { BaseIntent } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Transfer the withdrawal and lockup authority of a SOL stake account to new public keys on Solana. The transactionMessage must be a pre-signed serialized transaction validated by the platform against all provided address fields. Spending policy is not evaluated for this intent. Requires the solStakingAuthorize enterprise feature flag.
+ *
  * @title SOL Authorize Intent
  */
 export const SolAuthorizeIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "authorize". */
     intentType: intentTypes.authorize,
+    /** The pre-signed serialized transaction message, validated by the platform against the provided address fields. */
     transactionMessage: t.string,
+    /** The on-chain stake account whose authority is being transferred. */
     stakeAccount: t.string,
+    /** The current withdrawal authority public key. */
     oldWithdrawPublicKey: t.string,
+    /** The new withdrawal authority public key. */
     newWithdrawPublicKey: t.string,
+    /** The lockup authority public key. */
     lockupPublicKey: t.string,
+    /** The durable nonce account used for this transaction. */
     nonceAccount: t.string,
+    /** The authority of the nonce account. */
     nonceAuthority: t.string,
+    /** The recent blockhash used in the transaction message. */
     blockhash: t.string,
   }),
 ]);

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

@@ -19,6 +19,7 @@ import { AccountBaseBuildOptions } from "./accountBaseBuildOptions";
 export const SolBuildOptions = t.intersection([
   AccountBaseBuildOptions,
   t.type({
+    /** Memo string for the transaction. The key must be present; pass an empty string (or omit the value) if unused. */
     memo: optionalString,
   }),
 ]);

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

@@ -4,6 +4,8 @@ import { WithdrawIntent } from "./withdrawIntent";
 import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
+ * Withdraw the balance from a deactivated SOL stake account back to the wallet on Solana. The stake account must have been deactivated (unstaked) before claiming. Spending policy is not evaluated for this intent.
+ *
  * @title SOL Claim Intent
  */
 export const SolClaimIntent = t.intersection([
@@ -11,6 +13,7 @@ export const SolClaimIntent = t.intersection([
   SolBuildOptions,
   BaseIntentWithAmount,
   t.type({
+    /** The on-chain stake account address to withdraw from. */
     stakingAddress: t.string,
   }),
 ]);

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

@@ -117,6 +117,8 @@ const solCloseAssociatedTokenAccountRecipients = t.brand(
 );
 
 /**
+ * Close one or more zero-balance SPL Associated Token Accounts (ATAs) on Solana and recover their rent lamports to the wallet root address. All ATAs must have a zero token balance (consolidate tokens first), share the same on-chain owner, and be owned by this wallet. Maximum 27 distinct ATAs per transaction. Spending policy is not evaluated for this intent.
+ *
  * @title SOL Close Associated Token Account Intent
  *
  * After `decode`, prefer annotating or threading values as the exported
@@ -129,7 +131,9 @@ export const SolCloseAssociatedTokenAccountIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "closeAssociatedTokenAccount". */
     intentType: intentTypes.closeAssociatedTokenAccount,
+    /** One or more zero-balance ATAs to close. Each entry must have amount.value === "0", must not carry tokenName or tokenData, and all entries must share the same on-chain owner. Maximum 27 ATAs per transaction. */
     recipients: solCloseAssociatedTokenAccountRecipients,
   }),
 ]);

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

@@ -2,6 +2,8 @@ import * as t from "io-ts";
 import { AccountBaseConsolidateIntent } from "./accountBaseConsolidateIntent";
 
 /**
+ * Sweep native SOL and SPL token balances from a receive address into the wallet's root address on Solana. The platform automatically calculates transferable amounts, reserving rent-exempt minimums and transaction fees.
+ *
  * @title SOL Consolidate Intent
  */
 export const SolConsolidateIntent = AccountBaseConsolidateIntent;

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

@@ -3,6 +3,8 @@ import { SolBuildOptions } from "./solBuildOptions";
 import { EnableTokenIntent } from "./enableTokenIntent";
 
 /**
+ * Initialize one or more Associated Token Accounts (ATAs) on Solana so the wallet can receive SPL tokens. All entries in enableTokens must target the same wallet address. Spending policy is not evaluated for this intent.
+ *
  * @title SOL Create Associated Token Account Intent
  */
 export const SolCreateAssociatedTokenAccountIntent = t.intersection([

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

@@ -4,23 +4,33 @@ import { BaseIntent } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Submit a custom Solana transaction using raw legacy program instructions. Use this intent for legacy (non-versioned) transactions; for versioned transactions (address lookup tables, v0 messages) use the customTx intent with solVersionedTransactionData instead. Wallets without the enableSolCustomTx flag require a second admin approval before the transaction is processed.
+ *
  * @title SOL Custom Transaction Intent
  */
 export const SolCustomTxIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "customTx". For legacy (non-versioned) transactions only; use SolVersionedCustomTxIntent for versioned transactions. */
     intentType: intentTypes.customTx,
+    /** Array of raw Solana program instructions to include in the transaction. Use for legacy (non-versioned) transactions only. */
     solInstructions: t.array(
       t.type({
+        /** The program ID to invoke. */
         programId: t.string,
+        /** Account keys referenced by this instruction. */
         keys: t.array(
           t.type({
+            /** The account public key. */
             pubkey: t.string,
+            /** Whether this account is a signer. */
             isSigner: t.boolean,
+            /** Whether this account is writable. */
             isWritable: t.boolean,
           }),
         ),
+        /** Instruction data encoded as base58 or hex. */
         data: t.string,
       }),
     ),

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

@@ -5,14 +5,21 @@ import { intentTypes } from "./intentType";
 import { optionalString, optionalStringArray } from "../../../utils";
 
 /**
+ * Deactivate one or more SOL stake accounts on Solana to begin the cooldown period before funds can be claimed. No value is transferred. Provide either stakingAddress (single account) or stakingAddresses (batch). After cooldown completes, use the claim intent to withdraw. Spending policy is not evaluated for this intent. Requires the solStakingAuthorize enterprise feature flag.
+ *
  * @title SOL Deactivate Intent
  */
 export const SolDeactivateIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "deactivate". */
     intentType: intentTypes.deactivate,
+  }),
+  t.partial({
+    /** Batch of stake account addresses to deactivate. Provide either this or stakingAddress. */
     stakingAddresses: optionalStringArray,
+    /** A single stake account address to deactivate. Provide either this or stakingAddresses. */
     stakingAddress: optionalString,
   }),
 ]);

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

@@ -5,15 +5,23 @@ import { intentTypes } from "./intentType";
 import { optionalString, optionalStringArray } from "../../../utils";
 
 /**
+ * Delegate one or more deactivated SOL stake accounts to a validator on Solana. No value is transferred; this intent re-activates an existing stake account under a new or the same validator. Provide either stakingAddress (single account) or stakingAddresses (batch). Spending policy is not evaluated for this intent. Requires the solStakingAuthorize enterprise feature flag.
+ *
  * @title SOL Delegate Intent
  */
 export const SolDelegateIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "delegate". */
     intentType: intentTypes.delegate,
+    /** The validator vote account address to delegate to. */
     validatorAddress: t.string,
+  }),
+  t.partial({
+    /** Batch of stake account addresses to delegate. Provide either this or stakingAddress. */
     stakingAddresses: optionalStringArray,
+    /** A single stake account address to delegate. Provide either this or stakingAddresses. */
     stakingAddress: optionalString,
   }),
 ]);

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

@@ -1,16 +1,20 @@
 import * as t from "io-ts";
 import { SolBuildOptions } from "./solBuildOptions";
 import { GoUnstakeIntent } from "./goUnstakeIntent";
+import { optionalString } from "../../../utils";
 
 /**
- * @title SolGoUnstakeIntent
- *
- * @description Unstake intent for GO wallets for the Solana blockchain.
+ * Unstake SOL via the GO wallet program on Solana and transfer the proceeds to the specified recipients. This intent uses the same transfer path as the payment intent.
  *
+ * @title SOL Go Unstake Intent
  */
 export const SolGoUnstakeIntent = t.intersection([
   GoUnstakeIntent,
   SolBuildOptions,
+  t.partial({
+    /** Internal coordination identifier for the GO staking request. Accepted by the schema but only processed on admin/internal routes — external API consumers should omit this field. */
+    goStakingRequestId: optionalString,
+  }),
 ]);
 
 export type SolGoUnstakeIntent = t.TypeOf<typeof SolGoUnstakeIntent>;

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

@@ -2,6 +2,11 @@ import * as t from "io-ts";
 import { PaymentIntent } from "./paymentIntent";
 import { SolBuildOptions } from "./solBuildOptions";
 
+/**
+ * Transfer native SOL or SPL tokens to one or more recipients on Solana. For token transfers, the recipient amount symbol must use the "sol:tokenName" format (e.g. "sol:usdc"). Native SOL recipients must not be Associated Token Account (ATA) addresses.
+ *
+ * @title SOL Payment Intent
+ */
 export const SolPaymentIntent = t.intersection([
   PaymentIntent,
   SolBuildOptions,

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

@@ -6,6 +6,8 @@ import { Optional } from "../../../utils";
 import { SolStakingType } from "./solStakingType";
 
 /**
+ * Stake SOL to a validator on Solana by creating a new stake account. The platform generates an ephemeral keypair for the stake account and whitelists it on the wallet. Requires the enterprise to have staking permissions. Supports native, Marinade liquid, and Jito staking via the stakingType field.
+ *
  * @title SOL Stake Intent
  */
 export const SolStakeIntent = t.intersection([
@@ -13,14 +15,13 @@ export const SolStakeIntent = t.intersection([
   SolBuildOptions,
   BaseIntentWithAmount,
   t.type({
+    /** The validator vote account address to stake SOL with. */
     validatorAddress: t.string,
     /**
      * @deprecated Use `stakingType` instead.
      */
     isMarinade: Optional(t.boolean),
-    /**
-     * @todo Remove Optional once staking-service is updated.
-     */
+    /** The staking provider type. Accepted values: "NATIVE", "MARINADE", "JITO". Supersedes the deprecated isMarinade field. */
     stakingType: Optional(SolStakingType),
   }),
 ]);

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

@@ -7,25 +7,29 @@ import { RecipientEntry } from "./recipientEntry";
 import { SolStakingType } from "./solStakingType";
 
 /**
+ * Begin deactivating a SOL stake account on Solana. For native staking, the stake account enters a cooldown period before funds can be claimed. For partial unstakes, provide both amount and remainingStakingAmount to split the stake account. Supports native, Marinade liquid, and Jito staking via the stakingType field. Requires the enterprise to have staking permissions.
+ *
  * @title SOL Unstake Intent
  */
 export const SolUnstakeIntent = t.intersection([
   UnstakeIntent,
   SolBuildOptions,
   t.type({
+    /** The stake account address to deactivate. */
     stakingAddress: t.string,
   }),
   t.partial({
+    /** For partial unstake: the amount to remove from the stake account. Must be provided together with remainingStakingAmount. */
     amount: Optional(Amount),
+    /** For partial unstake: the amount to keep in the existing stake account after the split. Must be provided together with amount. */
     remainingStakingAmount: Optional(Amount),
     /**
      * @deprecated Use `stakingType` instead.
      */
     isMarinade: Optional(t.boolean),
-    /**
-     * @todo Remove Optional once staking-service is updated.
-     */
+    /** The staking provider type. Accepted values: "NATIVE", "MARINADE", "JITO". Supersedes the deprecated isMarinade field. */
     stakingType: Optional(SolStakingType),
+    /** Required for Marinade unstaking: the recipient address to receive the unstaked SOL. */
     recipients: Optional(t.array(RecipientEntry)),
   }),
 ]);

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

@@ -4,37 +4,55 @@ import { BaseIntent } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
+ * Submit a custom Solana versioned (v0) transaction with optional address lookup tables. Use this intent for versioned transactions; for legacy instruction-based transactions use the customTx intent with solInstructions instead. When recentBlockhash is provided, the platform uses it directly without fetching a durable nonce. Wallets without the enableSolCustomTx flag require a second admin approval before the transaction is processed.
+ *
  * @title SOL Versioned Custom Transaction Intent
  */
 export const SolVersionedCustomTxIntent = t.intersection([
   BaseIntent,
   SolBuildOptions,
   t.type({
+    /** Must be "customTx". Presence of solVersionedTransactionData distinguishes this from legacy SolCustomTxIntent at runtime. */
     intentType: intentTypes.customTx,
+    /** Versioned transaction data in Solana v0 message format. Presence of this field indicates a versioned transaction. */
     solVersionedTransactionData: t.intersection([
       t.type({
+        /** The program instructions for this versioned transaction. */
         versionedInstructions: t.array(
           t.type({
+            /** Index into the staticAccountKeys array identifying the program to invoke. */
             programIdIndex: t.number,
+            /** Indexes into the combined account keys (static + lookup) for this instruction. */
             accountKeyIndexes: t.array(t.number),
+            /** Instruction data encoded as base58 or hex. */
             data: t.string,
           }),
         ),
+        /** Address lookup tables to extend the number of accounts beyond the static limit. Required when using account lookup tables in a v0 transaction. */
         addressLookupTables: t.array(
           t.type({
+            /** The on-chain address of the lookup table account. */
             accountKey: t.string,
+            /** Indexes of writable accounts in the lookup table. */
             writableIndexes: t.array(t.number),
+            /** Indexes of read-only accounts in the lookup table. */
             readonlyIndexes: t.array(t.number),
           }),
         ),
+        /** The static account keys referenced by this transaction. */
         staticAccountKeys: t.array(t.string),
+        /** Solana message header specifying the number of required signers and read-only accounts. */
         messageHeader: t.type({
+          /** Number of signatures required for this transaction. */
           numRequiredSignatures: t.number,
+          /** Number of read-only accounts that require signatures. */
           numReadonlySignedAccounts: t.number,
+          /** Number of read-only accounts that do not require signatures. */
           numReadonlyUnsignedAccounts: t.number,
         }),
       }),
       t.partial({
+        /** Optional recent blockhash; when provided the platform uses it instead of fetching a durable nonce. */
         recentBlockhash: t.string,
       }),
     ]),

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

@@ -1,15 +1,18 @@
 import * as t from "io-ts";
 import { SuiBuildOptions } from "./suiBuildOptions";
 import { GoUnstakeIntent } from "./goUnstakeIntent";
+import { BaseGoStakeIntent } from "./baseGoStakeIntent";
 
 /**
  * @title SuiGoUnstakeIntent
  *
- * @description Unstake intent for GO wallets for the Solana blockchain.
+ * @description Unstake intent for GO wallets for the Sui blockchain.
  *
  */
 export const SuiGoUnstakeIntent = t.intersection([
   GoUnstakeIntent,
+  // Sui go-unstake is an admin/internal flow that requires goStakingRequestId.
+  BaseGoStakeIntent,
   SuiBuildOptions,
 ]);
 

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

@@ -5,6 +5,7 @@ import { intentTypes } from "./intentType";
 export const UnstakeIntent = t.intersection([
   BaseStakeIntent,
   t.type({
+    /** Must be "unstake". */
     intentType: intentTypes.unstake,
   }),
 ]);

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

@@ -7,6 +7,7 @@ import { Optional } from "../../../utils";
 export const WithdrawIntent = t.intersection([
   BaseStakeIntent,
   t.type({
+    /** Must be "claim". */
     intentType: intentTypes.claim,
   }),
   t.partial({