@circle-fin/app-kit 1.12.0 → 1.12.1

package/swap.mjs

@@ -8755,6 +8755,7 @@ const swapTokenEnumSchema = z.enum([
         [Blockchain.Arbitrum_Sepolia]: '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d',
         [Blockchain.Avalanche_Fuji]: '0x5425890298aed601595a70AB815c96711a31Bc65',
         [Blockchain.Base_Sepolia]: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+        [Blockchain.Celo_Alfajores_Testnet]: '0x2F25deB3848C207fc8E0c34035B3Ba7fC157602B',
         [Blockchain.Codex_Testnet]: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f',
         [Blockchain.Cronos_Testnet]: '0xEb33dc5fac03833e132593659e1dE7256aB59794',
         [Blockchain.Edge_Testnet]: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B',
@@ -10122,6 +10123,44 @@ var pkg$2 = {
     }
 });
 
+/**
+ * Canonical list of actions that do not prepare or submit transactions.
+ *
+ * @internal
+ */ const READ_ACTION_KEYS = [
+    'token.allowance',
+    'token.balanceOf',
+    'token.name',
+    'native.balanceOf',
+    'usdc.allowance',
+    'usdc.balanceOf',
+    'usdc.name',
+    'gateway.v1.isDelegate',
+    'gateway.v1.withdrawingBalance',
+    'gateway.v1.withdrawalBlock',
+    'gateway.v1.signBurnIntents'
+];
+const READ_ACTION_KEY_SET = new Set(READ_ACTION_KEYS);
+/**
+ * Check whether a runtime value identifies a read action.
+ *
+ * @param action - The value to classify.
+ * @returns Whether the value is a registered read-action key.
+ *
+ * @example
+ * ```typescript
+ * import { isReadActionKey } from '@core/adapter'
+ *
+ * if (isReadActionKey(value)) {
+ *   await adapter.readAction(value, params, context)
+ * }
+ * ```
+ *
+ * @internal
+ */ function isReadActionKey(action) {
+    return typeof action === 'string' && READ_ACTION_KEY_SET.has(action);
+}
+
 /**
  * Resolves an operation context into concrete chain and address values.
  *
@@ -10201,6 +10240,141 @@ var pkg$2 = {
     };
 }
 
+/**
+ * Create the standard error for a missing or non-read action.
+ *
+ * @param action - The unsupported action value.
+ * @returns A fatal unsupported-action error.
+ *
+ * @internal
+ */ function createUnsupportedReadActionError(action) {
+    return new KitError({
+        ...InputError.UNSUPPORTED_ACTION,
+        recoverability: 'FATAL',
+        message: `Read action "${String(action)}" is not registered in this adapter.`
+    });
+}
+/**
+ * Execute a read through the adapter's dedicated read seam when available.
+ *
+ * @remarks
+ * Fall back to the legacy `prepareAction().execute()` contract so providers
+ * remain runtime-compatible with adapter versions released before `readAction`.
+ * Consumers must upgrade their adapter package for reads to bypass custom
+ * `prepareAction` wrappers.
+ *
+ * @typeParam TAdapterCapabilities - The adapter capabilities type.
+ * @typeParam TActionKey - The read action key.
+ * @param adapter - The adapter that owns the read action.
+ * @param action - The read action to execute.
+ * @param params - The parameters for the read action.
+ * @param ctx - The operation context.
+ * @returns The raw read-action result.
+ * @throws {KitError} When `action` is not a supported read-action key.
+ *
+ * @example
+ * ```typescript
+ * import { executeAdapterReadAction } from '@core/adapter'
+ * import { Ethereum } from '@core/chains'
+ *
+ * const allowance = await executeAdapterReadAction(
+ *   adapter,
+ *   'token.allowance',
+ *   { tokenAddress, delegate },
+ *   { chain: Ethereum },
+ * )
+ * ```
+ *
+ * @internal
+ */ async function executeAdapterReadAction(adapter, action, params, ctx) {
+    if (!isReadActionKey(action)) {
+        throw createUnsupportedReadActionError(action);
+    }
+    const runtimeAdapter = adapter;
+    if (typeof runtimeAdapter.readAction === 'function') {
+        return runtimeAdapter.readAction(action, params, ctx);
+    }
+    let request;
+    try {
+        request = await adapter.prepareAction(action, params, ctx);
+    } catch (error) {
+        if (error instanceof Error && error.message === `Action ${action} is not supported`) {
+            throw createUnsupportedReadActionError(action);
+        }
+        throw error;
+    }
+    return request.execute();
+}
+/**
+ * Read and parse a token allowance while supporting older adapter versions.
+ *
+ * @remarks
+ * Prefer the adapter's dedicated read seam and fall back to the legacy
+ * `prepareAction().execute()` contract when the runtime adapter predates it.
+ *
+ * @typeParam TAdapterCapabilities - The adapter capabilities type.
+ * @param adapter - The adapter that owns the allowance action.
+ * @param params - The token and delegate whose allowance is being read.
+ * @param ctx - The operation context.
+ * @returns The non-negative allowance in token base units.
+ * @throws {KitError} When the action is unsupported or its response is malformed.
+ *
+ * @example
+ * ```typescript
+ * import { readTokenAllowance } from '@core/adapter'
+ * import { Ethereum } from '@core/chains'
+ *
+ * const allowance = await readTokenAllowance(
+ *   adapter,
+ *   { tokenAddress, delegate },
+ *   { chain: Ethereum },
+ * )
+ * ```
+ *
+ * @internal
+ */ async function readTokenAllowance(adapter, params, ctx) {
+    return parseAllowanceResponse(await executeAdapterReadAction(adapter, 'token.allowance', params, ctx));
+}
+/**
+ * Parse a raw token allowance response into base units.
+ *
+ * @param allowanceRaw - The adapter response, optionally wrapped as an Amount output.
+ * @returns The non-negative allowance as a bigint, or zero for a missing value.
+ * @throws {KitError} When the response cannot represent a non-negative bigint.
+ *
+ * @example
+ * ```typescript
+ * import { parseAllowanceResponse } from '@core/adapter'
+ *
+ * const allowance = parseAllowanceResponse({ amount: { raw: 1000000n } })
+ * ```
+ */ function parseAllowanceResponse(allowanceRaw) {
+    let value = allowanceRaw;
+    if (typeof value === 'object' && value !== null && 'amount' in value) {
+        const amount = value.amount;
+        if (typeof amount === 'object' && amount !== null && 'raw' in amount) {
+            value = amount.raw;
+        }
+    }
+    if (value === undefined || value === null) {
+        return 0n;
+    }
+    let allowance;
+    if (typeof value === 'bigint') {
+        allowance = value;
+    } else if (typeof value === 'string') {
+        try {
+            allowance = BigInt(value);
+        } catch  {
+            allowance = undefined;
+        }
+    }
+    if (allowance === undefined || allowance < 0n) {
+        throw createValidationFailedError$1('token.allowance', value, 'token.allowance response must be a non-negative bigint-compatible string or bigint');
+    }
+    return allowance;
+}
+
 /**
  * Schema for validating hexadecimal strings with '0x' prefix.
  *
@@ -10978,7 +11152,7 @@ var TransferSpeed;
 registerKit(`${pkg$2.name}/${pkg$2.version}`);
 
 var name$1 = "@circle-fin/swap-kit";
-var version$1 = "1.5.1";
+var version$1 = "1.5.2";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -15298,14 +15472,13 @@ const TOKEN_REGISTRY$2 = createTokenRegistry();
         return;
     }
     // For non-native tokens (SPL tokens, ERC-20 tokens), check the token balance
-    const balancePrepared = await adapter.prepareAction('token.balanceOf', {
+    const balance = await executeAdapterReadAction(adapter, 'token.balanceOf', {
         tokenAddress: tokenInAddress,
         walletAddress
     }, context);
-    const balance = await balancePrepared.execute();
     // Compare balances
     const requiredAmount = BigInt(amount);
-    const currentBalance = BigInt(balance);
+    const currentBalance = BigInt(String(balance));
     if (currentBalance < requiredAmount) {
         throw new KitError({
             ...BalanceError.INSUFFICIENT_TOKEN,
@@ -16466,11 +16639,10 @@ async function fetchSameChainStatusSnapshot({ isCrossChainSwap, txHash, chain, a
    * @throws Error if the adapter fails to prepare or execute approval transactions
    * @throws Error if transaction confirmation fails or times out
    */ async handleUsdtApproval(adapter, chain, executionCtx, adapterContractAddress, resolvedContext, executedTransactions) {
-        const allowanceRequest = await adapter.prepareAction('token.allowance', {
+        const current = await readTokenAllowance(adapter, {
             tokenAddress: executionCtx.tokenInAddress,
             delegate: adapterContractAddress
         }, resolvedContext);
-        const current = BigInt(await allowanceRequest.execute());
         const required = BigInt(executionCtx.amount);
         if (current >= required) {
             // Sufficient allowance - proceed to swap
@@ -21244,7 +21416,7 @@ registerKit(`${pkg$1.name}/${pkg$1.version}`);
 };
 
 var name = "@circle-fin/earn-kit";
-var version = "1.5.0";
+var version = "1.5.1";
 var pkg = {
 	name: name,
 	version: version};

package/unifiedBalance.cjs

@@ -664,6 +664,11 @@ class KitError extends Error {
         name: 'INPUT_UNSUPPORTED_TOKEN',
         type: 'INPUT'
     },
+    /** Action not supported by this adapter / ecosystem */ UNSUPPORTED_ACTION: {
+        code: 1008,
+        name: 'INPUT_UNSUPPORTED_ACTION',
+        type: 'INPUT'
+    },
     /** No route satisfies the slippage or minimum-output constraint */ SLIPPAGE_CONSTRAINT_NOT_MET: {
         code: 1009,
         name: 'INPUT_SLIPPAGE_CONSTRAINT_NOT_MET',
@@ -7995,6 +8000,7 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum_Sepolia]: '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d',
         [Blockchain.Avalanche_Fuji]: '0x5425890298aed601595a70AB815c96711a31Bc65',
         [Blockchain.Base_Sepolia]: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+        [Blockchain.Celo_Alfajores_Testnet]: '0x2F25deB3848C207fc8E0c34035B3Ba7fC157602B',
         [Blockchain.Codex_Testnet]: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f',
         [Blockchain.Cronos_Testnet]: '0xEb33dc5fac03833e132593659e1dE7256aB59794',
         [Blockchain.Edge_Testnet]: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B',
@@ -8887,7 +8893,7 @@ function parseOrThrow(value, schema, context) {
 }
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.4.0";
+var version = "1.4.1";
 var pkg = {
 	name: name,
 	version: version};
@@ -9170,6 +9176,110 @@ var pkg = {
  * ```
  */ const USDC_DECIMALS$1 = 6;
 
+/**
+ * Canonical list of actions that do not prepare or submit transactions.
+ *
+ * @internal
+ */ const READ_ACTION_KEYS = [
+    'token.allowance',
+    'token.balanceOf',
+    'token.name',
+    'native.balanceOf',
+    'usdc.allowance',
+    'usdc.balanceOf',
+    'usdc.name',
+    'gateway.v1.isDelegate',
+    'gateway.v1.withdrawingBalance',
+    'gateway.v1.withdrawalBlock',
+    'gateway.v1.signBurnIntents'
+];
+const READ_ACTION_KEY_SET = new Set(READ_ACTION_KEYS);
+/**
+ * Check whether a runtime value identifies a read action.
+ *
+ * @param action - The value to classify.
+ * @returns Whether the value is a registered read-action key.
+ *
+ * @example
+ * ```typescript
+ * import { isReadActionKey } from '@core/adapter'
+ *
+ * if (isReadActionKey(value)) {
+ *   await adapter.readAction(value, params, context)
+ * }
+ * ```
+ *
+ * @internal
+ */ function isReadActionKey(action) {
+    return typeof action === 'string' && READ_ACTION_KEY_SET.has(action);
+}
+
+/**
+ * Create the standard error for a missing or non-read action.
+ *
+ * @param action - The unsupported action value.
+ * @returns A fatal unsupported-action error.
+ *
+ * @internal
+ */ function createUnsupportedReadActionError(action) {
+    return new KitError({
+        ...InputError.UNSUPPORTED_ACTION,
+        recoverability: 'FATAL',
+        message: `Read action "${String(action)}" is not registered in this adapter.`
+    });
+}
+/**
+ * Execute a read through the adapter's dedicated read seam when available.
+ *
+ * @remarks
+ * Fall back to the legacy `prepareAction().execute()` contract so providers
+ * remain runtime-compatible with adapter versions released before `readAction`.
+ * Consumers must upgrade their adapter package for reads to bypass custom
+ * `prepareAction` wrappers.
+ *
+ * @typeParam TAdapterCapabilities - The adapter capabilities type.
+ * @typeParam TActionKey - The read action key.
+ * @param adapter - The adapter that owns the read action.
+ * @param action - The read action to execute.
+ * @param params - The parameters for the read action.
+ * @param ctx - The operation context.
+ * @returns The raw read-action result.
+ * @throws {KitError} When `action` is not a supported read-action key.
+ *
+ * @example
+ * ```typescript
+ * import { executeAdapterReadAction } from '@core/adapter'
+ * import { Ethereum } from '@core/chains'
+ *
+ * const allowance = await executeAdapterReadAction(
+ *   adapter,
+ *   'token.allowance',
+ *   { tokenAddress, delegate },
+ *   { chain: Ethereum },
+ * )
+ * ```
+ *
+ * @internal
+ */ async function executeAdapterReadAction(adapter, action, params, ctx) {
+    if (!isReadActionKey(action)) {
+        throw createUnsupportedReadActionError(action);
+    }
+    const runtimeAdapter = adapter;
+    if (typeof runtimeAdapter.readAction === 'function') {
+        return runtimeAdapter.readAction(action, params, ctx);
+    }
+    let request;
+    try {
+        request = await adapter.prepareAction(action, params, ctx);
+    } catch (error) {
+        if (error instanceof Error && error.message === `Action ${action} is not supported`) {
+            throw createUnsupportedReadActionError(action);
+        }
+        throw error;
+    }
+    return request.execute();
+}
+
 /**
  * Schema for validating hexadecimal strings with '0x' prefix.
  *
@@ -9379,16 +9489,15 @@ var pkg = {
  * ```
  */ const validateBalanceForTransaction = async (params)=>{
     const { amount, adapter, token, tokenAddress, operationContext } = params;
-    const balancePrepared = await adapter.prepareAction('usdc.balanceOf', {
+    const balance = await executeAdapterReadAction(adapter, 'usdc.balanceOf', {
         walletAddress: operationContext.address
     }, operationContext);
-    const balance = await balancePrepared.execute();
-    if (BigInt(balance) < BigInt(amount)) {
+    if (BigInt(String(balance)) < BigInt(amount)) {
         // Extract chain name from operationContext
         const chainName = extractChainInfo(operationContext.chain).name;
         // Create KitError with rich context in trace
         throw createInsufficientTokenBalanceError(chainName, token, {
-            balance: balance.toString(),
+            balance: String(balance),
             amount,
             tokenAddress,
             walletAddress: operationContext.address
@@ -18382,8 +18491,7 @@ function assertNotSelfDelegation(chain, signerAddress, delegateAddress, action)
         chain
     };
     // Step 1: Quick check at latest block (no HTTP call)
-    const latestRequest = await adapter.prepareAction('gateway.v1.isDelegate', baseActionParams, operationContext);
-    const latestResult = await latestRequest.execute();
+    const latestResult = await executeAdapterReadAction(adapter, 'gateway.v1.isDelegate', baseActionParams, operationContext);
     if (String(latestResult).toLowerCase() !== 'true') {
         return 'none';
     }
@@ -18392,13 +18500,12 @@ function assertNotSelfDelegation(chain, signerAddress, delegateAddress, action)
         // Solana uses confirmed vs finalized commitment as a proxy for
         // Gateway finality. This is conservative — can only over-report
         // 'pending', never falsely report 'ready'.
-        const finalizedRequest = await adapter.prepareAction('gateway.v1.isDelegate', {
-            ...baseActionParams,
-            commitment: 'finalized'
-        }, operationContext);
         let finalizedResult;
         try {
-            finalizedResult = await finalizedRequest.execute();
+            finalizedResult = await executeAdapterReadAction(adapter, 'gateway.v1.isDelegate', {
+                ...baseActionParams,
+                commitment: 'finalized'
+            }, operationContext);
         } catch (error) {
             if (isBlockRangeError(error)) {
                 return 'pending';
@@ -18409,10 +18516,6 @@ function assertNotSelfDelegation(chain, signerAddress, delegateAddress, action)
     }
     // EVM: use processedHeight from /v1/info
     const processedHeight = await getProcessedHeight(chain.isTestnet, chain.gateway.domain);
-    const finalizedRequest = await adapter.prepareAction('gateway.v1.isDelegate', {
-        ...baseActionParams,
-        blockNumber: processedHeight
-    }, operationContext);
     // If the RPC node lags Gateway's indexer view, the historical read at
     // processedHeight may throw a block-range error. This is safe to treat
     // as 'pending' because processedHeight comes from Gateway's /v1/info
@@ -18421,7 +18524,10 @@ function assertNotSelfDelegation(chain, signerAddress, delegateAddress, action)
     // Re-throw structural errors to avoid masking real bugs.
     let finalizedResult;
     try {
-        finalizedResult = await finalizedRequest.execute();
+        finalizedResult = await executeAdapterReadAction(adapter, 'gateway.v1.isDelegate', {
+            ...baseActionParams,
+            blockNumber: processedHeight
+        }, operationContext);
     } catch (error) {
         if (isBlockRangeError(error)) {
             return 'pending';
@@ -18482,8 +18588,8 @@ function parseAmountSafe(amount) {
         chain
     };
     const [withdrawingRaw, withdrawalBlockRaw] = await Promise.all([
-        adapter.prepareAction('gateway.v1.withdrawingBalance', readParams, operationContext).then(async (req)=>req.execute()),
-        adapter.prepareAction('gateway.v1.withdrawalBlock', readParams, operationContext).then(async (req)=>req.execute())
+        executeAdapterReadAction(adapter, 'gateway.v1.withdrawingBalance', readParams, operationContext),
+        executeAdapterReadAction(adapter, 'gateway.v1.withdrawalBlock', readParams, operationContext)
     ]);
     const withdrawingValue = safeBigInt(String(withdrawingRaw), 'withdrawingBalance');
     const withdrawalBlockValue = safeBigInt(String(withdrawalBlockRaw), 'withdrawalBlock');
@@ -18523,12 +18629,11 @@ function parseAmountSafe(amount) {
     const tokenAddress = getTokenAddress(chain, params.token);
     // Read the pending balance before withdrawing — the contract resets it to 0
     // after withdraw() executes, so this is the only way to capture the amount.
-    const withdrawingBalanceReq = await adapter.prepareAction('gateway.v1.withdrawingBalance', {
+    const withdrawingRaw = await executeAdapterReadAction(adapter, 'gateway.v1.withdrawingBalance', {
         token: tokenAddress,
         depositor: signerAddress,
         chain
     }, operationContext);
-    const withdrawingRaw = await withdrawingBalanceReq.execute();
     const withdrawingValue = safeBigInt(String(withdrawingRaw), 'withdrawingBalance');
     if (withdrawingValue === 0n) {
         throw new KitError({

package/unifiedBalance.d.cts

@@ -2604,6 +2604,18 @@ interface TokenActionMap {
          */
         walletAddress?: string | undefined;
     };
+    /**
+     * Get the on-chain name of the token contract.
+     *
+     * This is a read-only operation. For USDC the value is also the EIP-712
+     * domain name, which permit and authorize signing flows need.
+     */
+    name: ActionParameters & {
+        /**
+         * The contract address of the token.
+         */
+        tokenAddress: string;
+    };
 }
 
 /**
@@ -3433,6 +3445,30 @@ declare class ActionRegistry {
     executeAction<TActionKey extends ActionKeys>(action: TActionKey, params: ActionPayload<TActionKey>, context: ResolvedOperationContext): Promise<PreparedChainRequest>;
 }
 
+/**
+ * Canonical list of actions that do not prepare or submit transactions.
+ *
+ * @internal
+ */
+declare const READ_ACTION_KEYS: readonly ["token.allowance", "token.balanceOf", "token.name", "native.balanceOf", "usdc.allowance", "usdc.balanceOf", "usdc.name", "gateway.v1.isDelegate", "gateway.v1.withdrawingBalance", "gateway.v1.withdrawalBlock", "gateway.v1.signBurnIntents"];
+/**
+ * Action keys that execute without preparing or submitting a transaction.
+ *
+ * @remarks
+ * Derive this type from the canonical runtime list so compile-time and runtime
+ * classification cannot drift. `gateway.v1.signBurnIntents` is included
+ * because the action system models off-chain signing as a read action: it does
+ * not prepare a chain request.
+ *
+ * @example
+ * ```typescript
+ * import type { ReadActionKey } from '@core/adapter'
+ *
+ * const action: ReadActionKey = 'token.allowance'
+ * ```
+ */
+type ReadActionKey = (typeof READ_ACTION_KEYS)[number];
+
 /**
  * Defines the capabilities of an adapter, including address handling patterns and supported chains.
  *
@@ -3601,6 +3637,69 @@ declare abstract class Adapter<TAdapterCapabilities extends AdapterCapabilities
      * ```
      */
     prepareAction<TActionKey extends ActionKeys>(action: TActionKey, params: ActionPayload<TActionKey>, ctx: OperationContext<TAdapterCapabilities>): Promise<PreparedChainRequest>;
+    /**
+     * Execute a non-transaction action without routing through transaction preparation.
+     *
+     * @remarks
+     * Use this seam for balance, allowance, contract-state, and other actions
+     * classified as reads. It never calls {@link Adapter.prepareAction}, so
+     * transaction authorization wrappers only observe actions that can produce a
+     * signable chain request.
+     *
+     * @typeParam TActionKey - The read action key.
+     * @param action - The read action to execute.
+     * @param params - The parameters for the read action.
+     * @param ctx - The operation context.
+     * @returns The raw action response.
+     * @throws {KitError} When the key is not a read action or no handler is registered.
+     * @throws Error When the operation context or action handler fails.
+     *
+     * @example
+     * ```typescript
+     * import { Ethereum } from '@core/chains'
+     *
+     * const balance = await adapter.readAction(
+     *   'token.balanceOf',
+     *   { tokenAddress, walletAddress },
+     *   { chain: Ethereum },
+     * )
+     * ```
+     *
+     * @internal
+     */
+    readAction<TActionKey extends ReadActionKey>(action: TActionKey, params: ActionPayload<TActionKey>, ctx: OperationContext<TAdapterCapabilities>): Promise<unknown>;
+    /**
+     * Read the current token allowance a delegate holds over an owner's tokens.
+     *
+     * @remarks
+     * Perform a network read through {@link Adapter.readAction}. This method
+     * never routes through {@link Adapter.prepareAction}. On chains without an
+     * allowance model, such as Solana, return the maximum uint256 value.
+     *
+     * @param params - The token to query and the delegate whose allowance is being read.
+     * @param ctx - Operation context with compile-time validated address requirements.
+     * @returns A promise resolving to the current allowance in the token's base units.
+     * @throws {KitError} When the adapter does not register a `token.allowance` handler.
+     * @throws Error When the operation context or action handler fails.
+     *
+     * @example
+     * ```typescript
+     * import type { Adapter } from '@core/adapter'
+     * import { Ethereum } from '@core/chains'
+     *
+     * declare const adapter: Adapter
+     *
+     * const allowance = await adapter.getTokenAllowance(
+     *   {
+     *     tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+     *     delegate: '0x1111111111111111111111111111111111111111',
+     *   },
+     *   { chain: Ethereum },
+     * )
+     * console.log(allowance) // 1000000n
+     * ```
+     */
+    getTokenAllowance(params: ActionPayload<'token.allowance'>, ctx: OperationContext<TAdapterCapabilities>): Promise<bigint>;
     /**
      * Prepares a transaction for future gas estimation and execution.
      *
@@ -3787,6 +3886,37 @@ declare abstract class Adapter<TAdapterCapabilities extends AdapterCapabilities
     abstract getTokenDecimals(tokenAddress: string, chain: ChainDefinition): Promise<number>;
 }
 
+/**
+ * Simplified error information structure for logging and events.
+ *
+ * @remarks
+ * This lightweight type is used for error reporting in events, logs, and
+ * observability systems. It provides essential error context without the
+ * full ErrorDetails structure. Used across retry mechanisms, adapters,
+ * and other subsystems that need to record error information.
+ *
+ * @example
+ * ```typescript
+ * import { ErrorInfo } from '@core/errors'
+ *
+ * const info: ErrorInfo = {
+ *   name: 'NETWORK_TIMEOUT',
+ *   message: 'Request timed out after 5000ms',
+ *   code: 3002
+ * }
+ * ```
+ */
+interface ErrorInfo {
+    /** Error name (e.g., 'TypeError', 'KitError', 'NETWORK_TIMEOUT'). */
+    name: string;
+    /** Error message describing what went wrong. */
+    message: string;
+    /** Optional error code if the error has one (e.g., KitError codes). */
+    code?: number;
+    /** Error category (e.g., INPUT, RPC, ONCHAIN, BALANCE, NETWORK, UNKNOWN). Only set for KitError instances. */
+    type?: string;
+}
+
 /**
  * A type-safe event emitter for managing action-based event subscriptions.
  *
@@ -4027,37 +4157,6 @@ declare module './types' {
     }
 }
 
-/**
- * Simplified error information structure for logging and events.
- *
- * @remarks
- * This lightweight type is used for error reporting in events, logs, and
- * observability systems. It provides essential error context without the
- * full ErrorDetails structure. Used across retry mechanisms, adapters,
- * and other subsystems that need to record error information.
- *
- * @example
- * ```typescript
- * import { ErrorInfo } from '@core/errors'
- *
- * const info: ErrorInfo = {
- *   name: 'NETWORK_TIMEOUT',
- *   message: 'Request timed out after 5000ms',
- *   code: 3002
- * }
- * ```
- */
-interface ErrorInfo {
-    /** Error name (e.g., 'TypeError', 'KitError', 'NETWORK_TIMEOUT'). */
-    name: string;
-    /** Error message describing what went wrong. */
-    message: string;
-    /** Optional error code if the error has one (e.g., KitError codes). */
-    code?: number;
-    /** Error category (e.g., INPUT, RPC, ONCHAIN, BALANCE, NETWORK, UNKNOWN). Only set for KitError instances. */
-    type?: string;
-}
-
 /**
  * Runtime array of token identifiers supported by the Gateway v1 provider.
  *