@bitgo/public-types 5.51.0 → 5.53.0

package/dist/src/schema/wallet/freeze.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+export declare const TokenTransferRecipientParams: t.IntersectionC<[t.TypeC<{
+    tokenType: t.StringC;
+    tokenQuantity: t.StringC;
+}>, t.PartialC<{
+    tokenContractAddress: t.StringC;
+    tokenName: t.StringC;
+    tokenId: t.StringC;
+    decimalPlaces: t.NumberC;
+}>]>;
+export type TokenTransferRecipientParams = t.TypeOf<typeof TokenTransferRecipientParams>;

package/dist/src/schema/wallet/freeze.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferRecipientParams = void 0;
+const t = __importStar(require("io-ts"));
+exports.TokenTransferRecipientParams = t.intersection([
+    t.type({
+        tokenType: t.string,
+        tokenQuantity: t.string,
+    }),
+    t.partial({
+        tokenContractAddress: t.string,
+        tokenName: t.string,
+        tokenId: t.string,
+        decimalPlaces: t.number,
+    }),
+]);
+//# sourceMappingURL=freeze.js.map

package/dist/src/schema/wallet/freeze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeze.js","sourceRoot":"","sources":["../../../../src/schema/wallet/freeze.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2B;AAKd,QAAA,4BAA4B,GAAG,CAAC,CAAC,YAAY,CAAC;IACzD,CAAC,CAAC,IAAI,CAAC;QACL,SAAS,EAAE,CAAC,CAAC,MAAM;QACnB,aAAa,EAAE,CAAC,CAAC,MAAM;KACxB,CAAC;IACF,CAAC,CAAC,OAAO,CAAC;QACR,oBAAoB,EAAE,CAAC,CAAC,MAAM;QAC9B,SAAS,EAAE,CAAC,CAAC,MAAM;QACnB,OAAO,EAAE,CAAC,CAAC,MAAM;QACjB,aAAa,EAAE,CAAC,CAAC,MAAM;KACxB,CAAC;CACH,CAAC,CAAC"}

package/dist/src/schema/wallet/index.d.ts

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

package/dist/src/schema/wallet/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./wallet"), exports);
 __exportStar(require("./multisigTypeVersion"), exports);
 __exportStar(require("./walletTypes"), exports);
 __exportStar(require("./address"), exports);
+__exportStar(require("./freeze"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/schema/wallet/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/schema/wallet/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,wDAAsC;AACtC,gDAA8B;AAC9B,4CAA0B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/schema/wallet/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,wDAAsC;AACtC,gDAA8B;AAC9B,4CAA0B;AAC1B,2CAAyB"}

package/dist/src/utils/getAssetsFromIntent.d.ts

@@ -0,0 +1 @@
+export declare function getAssetsFromIntent(intent: unknown): string[];

package/dist/src/utils/getAssetsFromIntent.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetsFromIntent = getAssetsFromIntent;
+const Either_1 = require("fp-ts/lib/Either");
+const baseIntent_1 = require("../schema/transactionRequest/intents/baseIntent");
+function getAssetsFromIntent(intent) {
+    if (!intent || typeof intent !== "object") {
+        return [];
+    }
+    const assetStrings = new Set();
+    const recipientsDecoded = baseIntent_1.BaseIntentWithRecipients.decode(intent);
+    if ((0, Either_1.isRight)(recipientsDecoded)) {
+        const data = recipientsDecoded.right;
+        for (const recipient of data.recipients) {
+            if (recipient.amount?.symbol) {
+                assetStrings.add(recipient.amount.symbol);
+            }
+        }
+    }
+    const tokenDataDecoded = baseIntent_1.BaseIntentWithTokenData.decode(intent);
+    if ((0, Either_1.isRight)(tokenDataDecoded)) {
+        const data = tokenDataDecoded.right;
+        for (const recipient of data.recipients) {
+            if (recipient.tokenData?.tokenName) {
+                assetStrings.add(recipient.tokenData.tokenName);
+            }
+        }
+    }
+    const tokenNameDecoded = baseIntent_1.BaseIntentWithTokenName.decode(intent);
+    if ((0, Either_1.isRight)(tokenNameDecoded)) {
+        const data = tokenNameDecoded.right;
+        if (data.tokenName) {
+            assetStrings.add(data.tokenName);
+        }
+    }
+    const amountDecoded = baseIntent_1.BaseIntentWithAmount.decode(intent);
+    if ((0, Either_1.isRight)(amountDecoded)) {
+        const data = amountDecoded.right;
+        if (data.amount?.symbol) {
+            assetStrings.add(data.amount.symbol);
+        }
+    }
+    return Array.from(assetStrings).sort();
+}
+//# sourceMappingURL=getAssetsFromIntent.js.map

package/dist/src/utils/getAssetsFromIntent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getAssetsFromIntent.js","sourceRoot":"","sources":["../../../src/utils/getAssetsFromIntent.ts"],"names":[],"mappings":";;AAwBA,kDAwDC;AAhFD,6CAA2C;AAC3C,gFAKyD;AAkBzD,SAAgB,mBAAmB,CAAC,MAAe;IACjD,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC1C,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;IAKvC,MAAM,iBAAiB,GAAG,qCAAwB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAClE,IAAI,IAAA,gBAAO,EAAC,iBAAiB,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,iBAAiB,CAAC,KAAK,CAAC;QACrC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;gBAC7B,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;IACH,CAAC;IAKD,MAAM,gBAAgB,GAAG,oCAAuB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAChE,IAAI,IAAA,gBAAO,EAAC,gBAAgB,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC;QACpC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,IAAI,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC;gBACnC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;IACH,CAAC;IAKD,MAAM,gBAAgB,GAAG,oCAAuB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAChE,IAAI,IAAA,gBAAO,EAAC,gBAAgB,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC;QACpC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAKD,MAAM,aAAa,GAAG,iCAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1D,IAAI,IAAA,gBAAO,EAAC,aAAa,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC;QACjC,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;YACxB,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,IAAI,EAAE,CAAC;AACzC,CAAC"}

package/dist/src/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from "./optional";
 export * from "./primitives";
 export * from "./arrayFromSingle";
 export * from "./minMaxArray";
+export * from "./getAssetsFromIntent";

package/dist/src/utils/index.js

@@ -18,4 +18,5 @@ __exportStar(require("./optional"), exports);
 __exportStar(require("./primitives"), exports);
 __exportStar(require("./arrayFromSingle"), exports);
 __exportStar(require("./minMaxArray"), exports);
+__exportStar(require("./getAssetsFromIntent"), exports);
 //# sourceMappingURL=index.js.map

package/dist/src/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,+CAA6B;AAC7B,oDAAkC;AAClC,gDAA8B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6CAA2B;AAC3B,+CAA6B;AAC7B,oDAAkC;AAClC,gDAA8B;AAC9B,wDAAsC"}

package/package.json

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

package/src/schema/transactionRequest/intents/README.md

@@ -1,16 +1,165 @@
 # Transaction Intents
 
-This directory contains the intents for the transaction request schema.
+This directory contains the intents for the transaction request schema. Intents represent different types of blockchain operations (payments, staking, token transfers, etc.) with structured, validated data.
 
-## Adding a new Intent
+## Base Intent Patterns
 
-Once you have created your new intent codec, ensure to export it in `src/schema/transactionRequest/intents/intent.ts`
-and to regenerate the index.ts file.
+To ensure consistency and enable automatic asset extraction, we provide reusable base intent patterns in `baseIntent.ts`:
 
-## Regenerate index.ts
+### `BaseIntentWithRecipients`
 
-Use the following bash commands from the root of the project to regenerate the index.ts file in this directory. T
-This will export all the intents in this directory.
+Use for intents that send funds to one or more recipients with standard amounts.
+
+**When to use**: Payment intents, consolidation intents
+**Provides**: `recipients: Array<RecipientEntry>` with `amount.symbol` extraction
+**Example**: `PaymentIntent`, `AdaPaymentIntent`, `EthPaymentIntent`
+
+```typescript
+export const MyPaymentIntent = t.intersection([
+  BaseIntent,
+  BaseIntentWithRecipients, // ← Provides recipients array
+  t.type({
+    intentType: intentTypes.payment,
+    // ... your specific fields
+  }),
+]);
+```
+
+### `BaseIntentWithTokenRecipients`
+
+Use for intents that transfer tokens to recipients.
+
+**When to use**: Token transfer intents, token consolidation intents
+**Provides**: `recipients: Array<TokenRecipientEntry>` with `tokenData.tokenName` extraction
+**Example**: `TransferTokenIntent`, `EthTransferTokenIntent`
+
+```typescript
+export const MyTokenIntent = t.intersection([
+  BaseIntent,
+  BaseIntentWithTokenRecipients, // ← Provides token recipients
+  t.type({
+    intentType: intentTypes.transferToken,
+    // ... your specific fields
+  }),
+]);
+```
+
+### `BaseIntentWithTokenName`
+
+Use for intents that reference a token by name directly (not in recipients).
+
+**When to use**: Token approval intents, token configuration intents
+**Provides**: `tokenName: string` field with automatic extraction
+**Example**: `TokenApprovalIntent`
+
+```typescript
+export const MyTokenApprovalIntent = t.intersection([
+  BaseIntent,
+  BaseIntentWithTokenName, // ← Provides tokenName field
+  t.type({
+    intentType: intentTypes.tokenApproval,
+    // ... your specific fields
+  }),
+]);
+```
+
+### `BaseIntentWithAmount`
+
+Use for intents with a direct amount field (not in a recipients array).
+
+**When to use**: Staking, unstaking, delegation, withdrawal, claim rewards intents
+**Provides**: `amount: Amount` field with `symbol` extraction
+**Example**: `AtomStakeIntent`, `SolStakeIntent`, `BscDelegateIntent`
+
+```typescript
+export const MyStakeIntent = t.intersection([
+  StakeIntent,
+  BaseIntentWithAmount, // ← Provides amount field
+  t.type({
+    validatorAddress: t.string,
+    // ... your specific fields
+  }),
+]);
+```
+
+## Adding a New Intent
+
+When adding a new intent type, follow these steps:
+
+### 1. Create Your Intent Schema
+
+Create a new file in this directory (e.g., `myChainStakeIntent.ts`):
+
+```typescript
+import * as t from "io-ts";
+import { StakeIntent } from "./stakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
+
+export const MyChainStakeIntent = t.intersection([
+  StakeIntent,
+  BaseIntentWithAmount, // ← Use appropriate base pattern!
+  t.type({
+    validatorAddress: t.string,
+    // ... other required fields
+  }),
+]);
+
+export type MyChainStakeIntent = t.TypeOf<typeof MyChainStakeIntent>;
+```
+
+**Important**: Choose the appropriate base pattern(s) based on what asset data your intent contains:
+
+- Has `recipients` with amounts? Use `BaseIntentWithRecipients`
+- Has `recipients` with token data? Use `BaseIntentWithTokenRecipients`
+- Has a direct `tokenName` field? Use `BaseIntentWithTokenName`
+- Has a direct `amount` field? Use `BaseIntentWithAmount`
+- No asset data? Just use `BaseIntent`
+
+### 2. Export in TransactionIntent Union
+
+Add your intent to the union in `intent.ts`:
+
+```typescript
+export const TransactionIntent = t.union([
+  // ... existing intents
+  MyChainStakeIntent, // ← Add yours here
+]);
+```
+
+### 3. Add Test Coverage
+
+**CRITICAL**: Add test data to `test/utils/getAssetsFromIntent.test.ts` in the `INTENT_TEST_REGISTRY`:
+
+```typescript
+const INTENT_TEST_REGISTRY = new Map<string, IntentTestCase>([
+  // ... existing entries
+  [
+    "MyChainStakeIntent",
+    {
+      codec: MyChainStakeIntent,
+      data: {
+        intentType: "stake",
+        stakingRequestId: "test123",
+        validatorAddress: "validator_addr",
+        amount: { value: "1000000", symbol: "mychain" },
+      },
+      expectedAssets: ["mychain"], // ← What assets should be extracted
+    },
+  ],
+]);
+```
+
+**Why this is critical**: We have automatic CI protection that reads the `TransactionIntent` union at runtime and verifies:
+
+- Every intent has an entry in `INTENT_TEST_REGISTRY`
+- The test data decodes successfully against your schema
+- Asset extraction works correctly
+
+**If you don't add test coverage, the CI build will fail!** This ensures the `getAssetsFromIntent` utility remains future-proof.
+
+### 4. Regenerate index.ts
+
+Export all intents by regenerating the index file:
 
 ```bash
 # Delete the existing index.ts file if it exists
@@ -18,7 +167,7 @@ if [ -f src/schema/transactionRequest/intents/index.ts ]; then
   rm src/schema/transactionRequest/intents/index.ts
 fi
 
-# Loop through each .ts file in the directory and append export statements to index.ts, excluding index.ts itself
+# Loop through each .ts file and append export statements to index.ts
 for file in src/schema/transactionRequest/intents/*.ts; do
   filename=$(basename -- "$file")
   filenameWithoutExt="${filename%.*}"
@@ -27,3 +176,26 @@ for file in src/schema/transactionRequest/intents/*.ts; do
   fi
 done
 ```
+
+## Asset Extraction
+
+The `getAssetsFromIntent` utility automatically extracts asset identifiers from any intent object. It uses the base intent patterns to identify and extract:
+
+- **Symbol names** (e.g., 'eth', 'btc', 'ada') from `amount.symbol` fields
+- **Token names** (e.g., 'USDC', 'DAI') from `tokenName` or `tokenData.tokenName` fields
+
+**What counts as an "asset"?**
+
+- ✅ `symbol` - The currency/coin identifier
+- ✅ `tokenName` - The token identifier
+- ❌ `tokenType`, `tokenContractAddress`, `tokenId` - Technical implementation details
+
+By composing your intent with the appropriate base patterns, asset extraction works automatically—no additional code needed!
+
+## Best Practices
+
+1. **Always use base patterns** instead of manually defining common fields like `amount: Amount` or `recipients: t.array(RecipientEntry)`
+2. **Add test coverage immediately** when creating a new intent—don't wait for CI to fail
+3. **Use minimal test data** in the registry—just enough to satisfy the schema and demonstrate asset extraction
+4. **Keep intent schemas DRY** by leveraging existing base types (`StakeIntent`, `UnstakeIntent`, etc.)
+5. **Document your intent** with JSDoc comments explaining its purpose and required fields

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

@@ -1,15 +1,15 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { StakeIntent } from "./stakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title Apt Stake Intent
  */
 export const AptStakeIntent = t.intersection([
   StakeIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
 ]);
 

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

@@ -1,15 +1,15 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { UnstakeIntent } from "./unstakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title Apt Unstake Intent
  */
 export const AptUnstakeIntent = t.intersection([
   UnstakeIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
 ]);
 

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

@@ -1,15 +1,15 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { WithdrawIntent } from "./withdrawIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title Apt Withdraw Stake Intent
  */
 export const AptWithdrawStakeIntent = t.intersection([
   WithdrawIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
 ]);
 

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

@@ -1,17 +1,17 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { RecipientEntry } from "./recipientEntry";
 import { Optional } from "../../../utils";
 import { StakeIntent } from "./stakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title Atom Stake Intent
  */
 export const AtomStakeIntent = t.intersection([
   StakeIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
   t.partial({
     recipients: Optional(t.array(RecipientEntry)),

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

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { UnstakeIntent } from "./unstakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 import { RecipientEntry } from "./recipientEntry";
 import { Optional } from "../../../utils";
 
@@ -9,9 +9,9 @@ import { Optional } from "../../../utils";
  */
 export const AtomUnstakeIntent = t.intersection([
   UnstakeIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
   t.partial({
     recipients: Optional(t.array(RecipientEntry)),

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

@@ -1,15 +1,15 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { WithdrawIntent } from "./withdrawIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 
 /**
  * @title Atom Withdraw Intent
  */
 export const AtomWithdrawIntent = t.intersection([
   WithdrawIntent,
+  BaseIntentWithAmount,
   t.type({
     validatorAddress: t.string,
-    amount: Amount,
   }),
 ]);
 

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

@@ -1,6 +1,9 @@
 import * as t from "io-ts";
 import { IntentType } from "./intentType";
 import { Optional, optionalString } from "../../../utils";
+import { RecipientEntry } from "./recipientEntry";
+import { TokenRecipientEntry } from "./tokenRecipientEntry";
+import { Amount } from "./amount";
 
 /**
  * @title Intent
@@ -29,3 +32,116 @@ export const BaseIntentWithoutNonce = t.intersection([
 ]);
 
 export type BaseIntentWithoutNonce = t.TypeOf<typeof BaseIntentWithoutNonce>;
+
+/**
+ * ============================================================================
+ * REUSABLE SCHEMA FRAGMENTS FOR ASSET-CONTAINING INTENTS
+ * ============================================================================
+ *
+ * These schemas define reusable building blocks that concrete intent schemas
+ * can compose with. They serve multiple purposes:
+ *
+ * 1. **Schema Reuse**: Concrete intents can intersect with these fragments
+ * 2. **Pattern Matching**: getAssetsFromIntent utility matches against these
+ * 3. **Type Safety**: Ensures consistency across all asset-containing intents
+ * 4. **Documentation**: Clearly shows which intents handle which asset types
+ *
+ * By using the actual RecipientEntry and TokenRecipientEntry types, we ensure
+ * these patterns exactly match the structures used in concrete intents.
+ */
+
+/**
+ * Schema fragment for intents with standard recipients (payment-like intents)
+ *
+ * This fragment defines a recipients array using RecipientEntry, which contains
+ * address and amount (with value and symbol) fields.
+ *
+ * Used by:
+ * - PaymentIntent (and all variants: AdaPaymentIntent, EthPaymentIntent, etc.)
+ * - ConsolidateIntent variants (when they include recipients)
+ *
+ * Asset extraction: Extracts `symbol` from each recipient's amount
+ */
+export const BaseIntentWithRecipients = t.type({
+  recipients: t.array(RecipientEntry),
+});
+
+export type BaseIntentWithRecipients = t.TypeOf<
+  typeof BaseIntentWithRecipients
+>;
+
+/**
+ * Schema fragment for intents with token recipients
+ *
+ * This fragment defines a recipients array using TokenRecipientEntry, which
+ * extends RecipientEntry with optional tokenData containing token-specific info.
+ *
+ * Used by:
+ * - TransferTokenIntent (and variants: EthTransferTokenIntent, etc.)
+ * - ConsolidateTokenIntent (and variants: EthConsolidateTokenIntent, etc.)
+ *
+ * Asset extraction: Extracts tokenName only (the actual asset identifier)
+ * Note: tokenType, tokenContractAddress, tokenId are technical fields, not assets
+ * Note: This also matches BaseIntentWithRecipients since TokenRecipientEntry extends RecipientEntry
+ */
+export const BaseIntentWithTokenRecipients = t.type({
+  recipients: t.array(TokenRecipientEntry),
+});
+
+export type BaseIntentWithTokenRecipients = t.TypeOf<
+  typeof BaseIntentWithTokenRecipients
+>;
+
+/**
+ * Pattern for matching token data in recipients
+ * Used to extract tokenName (the asset identifier) from token-related intents
+ */
+export const BaseIntentWithTokenData = t.type({
+  recipients: t.array(
+    t.partial({
+      tokenData: t.partial({
+        tokenName: t.string,
+      }),
+    }),
+  ),
+});
+
+export type BaseIntentWithTokenData = t.TypeOf<typeof BaseIntentWithTokenData>;
+
+/**
+ * Schema fragment for intents with direct tokenName field
+ *
+ * This fragment defines a tokenName field directly on the intent object
+ * (not nested in recipients).
+ *
+ * Used by:
+ * - TokenApprovalIntent
+ *
+ * Asset extraction: Extracts tokenName
+ */
+export const BaseIntentWithTokenName = t.type({
+  tokenName: t.string,
+});
+
+export type BaseIntentWithTokenName = t.TypeOf<typeof BaseIntentWithTokenName>;
+
+/**
+ * Schema fragment for intents with direct amount field
+ *
+ * This fragment defines an amount field directly on the intent object
+ * (not nested in recipients). Common in staking, claiming, and delegation intents.
+ *
+ * Used by:
+ * - StakeIntent variants (AtomStakeIntent, SolStakeIntent, etc.)
+ * - UnstakeIntent variants (AtomUnstakeIntent, etc.)
+ * - DelegateIntent variants (BscDelegateIntent, TonDelegateIntent, etc.)
+ * - ClaimRewardsIntent variants (AdaStakeClaimRewardsIntent, etc.)
+ * - WithdrawIntent variants (AtomWithdrawIntent, CosmosWithdrawIntent, etc.)
+ *
+ * Asset extraction: Extracts symbol from the amount field
+ */
+export const BaseIntentWithAmount = t.type({
+  amount: Amount,
+});
+
+export type BaseIntentWithAmount = t.TypeOf<typeof BaseIntentWithAmount>;

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

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { BaseStakeIntent } from "./baseStakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
@@ -8,10 +8,10 @@ import { intentTypes } from "./intentType";
  */
 export const BscDelegateIntent = t.intersection([
   BaseStakeIntent,
+  BaseIntentWithAmount,
   t.type({
     intentType: intentTypes.delegate,
     validatorAddress: t.string,
-    amount: Amount,
   }),
   t.partial({
     // Add optional properties here

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

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
-import { Amount } from "./amount";
 import { BaseStakeIntent } from "./baseStakeIntent";
+import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
@@ -8,10 +8,10 @@ import { intentTypes } from "./intentType";
  */
 export const BscUnDelegateIntent = t.intersection([
   BaseStakeIntent,
+  BaseIntentWithAmount,
   t.type({
     intentType: intentTypes.undelegate,
     validatorAddress: t.string,
-    amount: Amount,
   }),
   t.partial({
     // Add optional properties here

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

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
 import { BaseStakeIntentWithCalldata } from "./baseStakeIntentWithCalldata";
-import { Amount } from "./amount";
+import { BaseIntentWithAmount } from "./baseIntent";
 import { intentTypes } from "./intentType";
 
 /**
@@ -14,10 +14,10 @@ import { intentTypes } from "./intentType";
  */
 export const CoreDaoDelegateIntent = t.intersection([
   BaseStakeIntentWithCalldata,
+  BaseIntentWithAmount,
   t.type({
     intentType: intentTypes.delegate,
     validatorAddress: t.string,
-    amount: Amount,
   }),
 ]);