@circle-fin/app-kit 1.17.0 → 1.18.0

package/index.cjs

@@ -4748,6 +4748,15 @@ let activeRedactor = defaultMessageRedactor;
             recoverability: 'RETRYABLE'
         }
     ],
+    // DEPOSIT_INTENT_INVALID: the Veda deposit intent is missing, expired, or
+    // not signed by the depositing wallet.
+    [
+        380418,
+        {
+            errorDef: EarnError.SIGNATURE_REJECTED,
+            recoverability: 'FATAL'
+        }
+    ],
     // Bridge (380_5XX)
     [
         380500,
@@ -6356,14 +6365,14 @@ exports.BorrowChain = void 0;
         symbol: 'USDC',
         // Arc uses native USDC with 18 decimals for gas payments (EVM standard).
         // Note: The ERC-20 USDC contract at usdcAddress uses 6 decimals.
-        // See: https://docs.arc.network/arc/references/contract-addresses
+        // See: https://docs.arc.io/arc/references/contract-addresses
         decimals: 18
     },
     chainId: 5042002,
     isTestnet: true,
     explorerUrl: 'https://testnet.arcscan.app/tx/{hash}',
     rpcEndpoints: [
-        'https://rpc.testnet.arc.network/'
+        'https://rpc.testnet.arc.io'
     ],
     eurcAddress: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
     usdcAddress: '0x3600000000000000000000000000000000000000',
@@ -14681,7 +14690,7 @@ function resolveOptions(options) {
 }
 
 var name$5 = "@circle-fin/bridge-kit";
-var version$6 = "1.15.3";
+var version$6 = "1.16.0";
 var pkg$6 = {
 	name: name$5,
 	version: version$6};
@@ -16403,6 +16412,53 @@ const EURC_MAINNET_TOKEN_ID = '0x6ca9e29fa53becc29becaf4a90b9ca7a995ad4d2234880d
     }
 };
 
+/**
+ * Map a CCTPx bytes32 token id back to its known display symbol.
+ *
+ * The inverse of the provider's internal symbol -> id resolution: a bridge
+ * resolves a symbol such as `'cirBTC'` to its canonical bytes32 id and reports
+ * that id on `result.token`, dropping the symbol. This helper recovers the
+ * symbol for display. It is scoped to {@link KNOWN_TOKEN_SYMBOLS} — the same
+ * known set the forward resolution covers — and is keyed by network, because a
+ * symbol names a separate registration on each network, whose ids are
+ * unrelated.
+ *
+ * The lookup is best-effort by design: an arbitrary registry token, a
+ * non-canonical bridge of a known symbol, or any unrecognized id has no known
+ * symbol and yields `undefined`. The id is matched case-insensitively (bytes32
+ * ids have no checksum casing).
+ *
+ * @param id - The bytes32 token id to decode (e.g. a `result.token` value).
+ * @param network - The network the id belongs to (`'testnet'` or `'mainnet'`);
+ *   derive it from the source chain, e.g. `chain.isTestnet ? 'testnet' :
+ *   'mainnet'`.
+ * @returns The matching {@link KnownTokenSymbol}, or `undefined` when `id` is
+ *   not one of the known canonical ids for `network`.
+ * @throws A `KitError` (`INPUT_VALIDATION_FAILED`, FATAL) when `id` is not a
+ *   string or `network` is not a recognized network.
+ *
+ * @example
+ * ```typescript
+ * import { resolveToKnownTokenSymbol } from '@circle-fin/provider-cctpx'
+ *
+ * const result = await provider.bridge(params) // params.token === 'cirBTC'
+ * const network = result.source.chain.isTestnet ? 'testnet' : 'mainnet'
+ *
+ * resolveToKnownTokenSymbol(result.token, network) // 'cirBTC'
+ * resolveToKnownTokenSymbol('0xdeadbeef…', network) // undefined (not known)
+ * ```
+ */ function resolveToKnownTokenSymbol(id, network) {
+    if (typeof id !== 'string') {
+        throw createValidationFailedError$1('id', id, 'must be a string');
+    }
+    if (network !== 'testnet' && network !== 'mainnet') {
+        throw createValidationFailedError$1('network', network, "must be 'testnet' or 'mainnet'");
+    }
+    const row = KNOWN_TOKEN_IDS_BY_NETWORK[network];
+    const target = id.toLowerCase();
+    return KNOWN_TOKEN_SYMBOLS.find((symbol)=>row[symbol].toLowerCase() === target);
+}
+
 /**
  * Default clock implementation.
  *
@@ -23626,6 +23682,24 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
     }
 };
 
+/**
+ * Check whether a forwarded burn to the given destination asks Circle's
+ * Forwarding Service to set up the recipient's token account before minting.
+ *
+ * Must return `true` exactly for the destinations where
+ * {@link getForwarderHookData} emits the `createAta` frame, so the forwarding
+ * fee quote includes the setup rent whenever the burn requests it.
+ *
+ * @internal
+ * @param chainType - The destination blockchain type.
+ * @returns `true` for Solana destinations, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * requiresRecipientSetup('solana') // true
+ * requiresRecipientSetup('evm') // false
+ * ```
+ */ const requiresRecipientSetup = (chainType)=>chainType === 'solana';
 /**
  * Build the forwarding `hookData` for a forwarded (Orbit-relayed) CCTP v2 burn,
  * tailored to the destination chain.
@@ -23976,10 +24050,12 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  * @param sourceDomain - The source domain
  * @param destinationDomain - The destination domain
  * @param isTestnet - Whether the request is for a testnet chain
+ * @param includeRecipientSetup - Whether the quote includes recipient account setup rent
  * @returns The complete API URL with forward=true query parameter
- */ function buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet) {
+ */ function buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet, includeRecipientSetup) {
     const baseUrl = isTestnet ? IRIS_API_SANDBOX_BASE_URL$1 : IRIS_API_BASE_URL$1;
-    return `${baseUrl}/v2/burn/USDC/fees/${sourceDomain.toString()}/${destinationDomain.toString()}?forward=true`;
+    const recipientSetupQuery = includeRecipientSetup ? '&includeRecipientSetup=true' : '';
+    return `${baseUrl}/v2/burn/USDC/fees/${sourceDomain.toString()}/${destinationDomain.toString()}?forward=true${recipientSetupQuery}`;
 }
 /**
  * Fetches the forwarding fee for a USDC transfer operation with retry and timeout handling.
@@ -23996,6 +24072,10 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  *
  * The high fee tier is always used to provide buffer for destination gas fluctuations.
  *
+ * Pass `includeRecipientSetup: true` when the burn asks the Forwarding Service to create
+ * the recipient's token account (Solana destinations). The quote then includes the
+ * account rent, which the quote without this flag leaves out.
+ *
  * Implements timeout and retry logic to handle network issues and temporary API failures.
  * Each HTTP request is given a maximum of 2 seconds before it is aborted.
  * We retry up to 10 times, waiting 200ms between attempts.
@@ -24004,6 +24084,8 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  * @param destinationDomain - The destination domain
  * @param isTestnet - Whether the request is for a testnet chain
  * @param finalityThreshold - The finality threshold to select the fee tier (1000 for FAST, 2000 for SLOW)
+ * @param includeRecipientSetup - Whether to include recipient account setup rent in the
+ *   quote. Defaults to `false`.
  * @returns The high-tier forwarding fee in USDC minor units (6 decimals)
  * @throws Error if the input domains are invalid, the API request fails, returns invalid data, or network errors occur
  *
@@ -24015,8 +24097,11 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
  *
  * // SLOW transfer - use 2000ms finality threshold
  * const slowForwardingFee = await fetchForwardingFee(0, 6, false, 2000)
+ *
+ * // Ethereum -> Solana: include the recipient token account rent
+ * const solanaForwardingFee = await fetchForwardingFee(0, 5, false, 1000, true)
  * ```
- */ async function fetchForwardingFee(sourceDomain, destinationDomain, isTestnet, finalityThreshold) {
+ */ async function fetchForwardingFee(sourceDomain, destinationDomain, isTestnet, finalityThreshold, includeRecipientSetup = false) {
     // Validate source domain
     if (!Number.isInteger(sourceDomain) || sourceDomain < 0) {
         throw new KitError({
@@ -24044,7 +24129,7 @@ const FAST_TIER_FINALITY_THRESHOLD = 1000;
         });
     }
     // Fetch the fee tiers from the API with forward=true
-    const url = buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet);
+    const url = buildForwardingFeeUrl(sourceDomain, destinationDomain, isTestnet, includeRecipientSetup);
     const response = await pollApiGet(url, isForwardingFeeResponse, DEFAULT_CONFIG$4);
     // Validate that we have at least one fee tier
     if (response.length === 0) {
@@ -26380,7 +26465,7 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$5 = "1.14.2";
+var version$5 = "1.14.3";
 var pkg$5 = {
 	version: version$5};
 
@@ -27299,9 +27384,34 @@ function assertCCTPV2Config(config) {
             tokenAddress: source.chain.usdcAddress,
             operationContext: sourceOperationContext
         });
+        await this.assertAmountCoversRecipientSetupFee(params);
         return bridge$1(params, this);
     }
     /**
+   * Reject a forwarded transfer to Solana whose amount does not exceed the fee.
+   *
+   * CCTP v2 reverts a burn whose `maxFee` is not less than its amount, and the Solana
+   * forwarding fee includes the recipient token account rent. Checking before the
+   * approval avoids sending a transaction that can never be followed by a burn.
+   * Skipped when the caller provides `config.maxFee`.
+   *
+   * @param params - The validated CCTP v2 bridge parameters.
+   * @returns A promise that resolves when the amount covers the fee.
+   * @throws {KitError} INPUT_INVALID_AMOUNT (FATAL) when the fee is greater than or equal
+   *   to the amount.
+   */ async assertAmountCoversRecipientSetupFee(params) {
+        const { destination, amount, config } = params;
+        if (destination.useForwarder !== true || config.maxFee !== undefined || !requiresRecipientSetup(destination.chain.type)) {
+            return;
+        }
+        const { providerFee, forwarderFee } = await this.getMaxFee(params);
+        const maxFee = providerFee + forwarderFee;
+        if (maxFee >= BigInt(amount)) {
+            // Amounts and fees are in USDC minor units (6 decimals)
+            throw createInvalidAmountError(formatUnits(amount, 6), `Amount must be greater than the ${formatUnits(String(maxFee), 6)} USDC fee for forwarded transfers to ${destination.chain.name}, which includes creating the recipient's token account`);
+        }
+    }
+    /**
    * Retry a failed or incomplete CCTP v2 bridge operation.
    *
    * Analyzes the bridge result to determine where to continue and executes
@@ -28018,6 +28128,9 @@ function assertCCTPV2Config(config) {
    * | FAST           | true         | No              | maxFee = calculatedBurnFee + forwardingFee |
    * | FAST           | true         | Yes             | maxFee = config.maxFee |
    *
+   * For forwarded burns to Solana, the forwarding fee includes the rent for creating the
+   * recipient's token account. A caller-provided `maxFee` must cover it too.
+   *
    * @param params - The bridge parameters object containing:
    *   - `source`: The source wallet context with chain definition and adapter
    *   - `destination`: The destination wallet context with chain definition and adapter
@@ -28056,6 +28169,7 @@ function assertCCTPV2Config(config) {
         }
         // Get the min finality threshold based on the transfer speed
         const minFinalityThreshold = CCTPv2MinFinalityThreshold[transferSpeed];
+        const includeRecipientSetup = requiresRecipientSetup(destination.chain.type);
         // SLOW transfer without forwarder: no fee
         if (transferSpeed === exports.TransferSpeed.SLOW && !useForwarder) {
             return {
@@ -28065,7 +28179,7 @@ function assertCCTPV2Config(config) {
         }
         // SLOW transfer with forwarder: only forwarding fee
         if (transferSpeed === exports.TransferSpeed.SLOW && useForwarder) {
-            const forwarderFee = await fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold);
+            const forwarderFee = await fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold, includeRecipientSetup);
             return {
                 providerFee: 0n,
                 forwarderFee
@@ -28075,7 +28189,7 @@ function assertCCTPV2Config(config) {
         // Fetch fees in parallel when forwarder is enabled
         const [scaledBps, forwarderFee] = await Promise.all([
             fetchUsdcFastBurnFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet),
-            useForwarder ? fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold) : Promise.resolve(0n)
+            useForwarder ? fetchForwardingFee(source.chain.cctp.domain, destination.chain.cctp.domain, source.chain.isTestnet, minFinalityThreshold, includeRecipientSetup) : Promise.resolve(0n)
         ]);
         // Calculate fee proportional to the transfer amount
         const amountInMinorUnits = BigInt(amount);
@@ -28625,6 +28739,21 @@ function assertCCTPV2Config(config) {
         'bridge_forward'
     ]
 ];
+/**
+ * Provider step names whose `txHash` is the source-chain transaction that
+ * moves funds into the bridge protocol.
+ *
+ * @remarks
+ * The success event carries this hash so the backend can join it to the
+ * on-chain CCTP / CCTPx event for the same transfer. `burn` is the CCTP v2
+ * step (including batched and source-fee flows); `transfer` is the CCTPx
+ * `CrossChainTokenService` step.
+ *
+ * @internal
+ */ const BRIDGE_SOURCE_TX_STEP_NAMES = [
+    'burn',
+    'transfer'
+];
 
 /**
  * Base URL for Circle's Quote API (hosted in Iris) on mainnet/production.
@@ -29720,6 +29849,85 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
     }
     return undefined;
 }
+/**
+ * Pick the source-chain transaction hash from a bridge result.
+ *
+ * Walk the steps from the end and return the hash of the most recent
+ * successful source step (`burn` for CCTP v2, `transfer` for CCTPx). Walking
+ * backwards selects the attempt that landed when a retry appended a new
+ * source step after a failed one.
+ *
+ * @param steps - All steps from the bridge result.
+ * @returns The source transaction hash, or `undefined` if no source step recorded one.
+ *
+ * @internal
+ */ function pickSourceTxHash(steps) {
+    for(let i = steps.length - 1; i >= 0; i--){
+        const step = steps[i];
+        if (step?.txHash != null && step.state === 'success' && BRIDGE_SOURCE_TX_STEP_NAMES.includes(step.name)) {
+            return step.txHash;
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolve the token value reported in telemetry.
+ *
+ * CCTPx reports `result.token` as a bytes32 token id, while the backend's
+ * canonical tables key tokens by symbol. Map the canonical id of a known CCTPx
+ * token back to its symbol and pass any other value (USDC, or a registry token
+ * without a known symbol) through unchanged. Registry symbols are not used
+ * because they are not unique across CCTPx tokens. Never throws.
+ *
+ * @param token - The token from a bridge result.
+ * @param sourceChain - The result's source chain; selects testnet or mainnet ids.
+ * @returns The known symbol, or `token` unchanged.
+ *
+ * @internal
+ */ function toTelemetryToken(token, sourceChain) {
+    try {
+        const network = sourceChain.isTestnet ? 'testnet' : 'mainnet';
+        return resolveToKnownTokenSymbol(token, network) ?? token;
+    } catch  {
+        return token;
+    }
+}
+/**
+ * Emit the `bridge_bridge` success event for a completed transfer.
+ *
+ * No-ops unless `result.state` is `'success'`. Failed results are already
+ * reported by error telemetry. Never throws: a malformed result (for example
+ * from a custom provider) is reported as a telemetry drop warning and the
+ * caller's result is returned unchanged.
+ *
+ * @param result - The human-readable bridge result returned to the caller.
+ * @param config - Analytics telemetry identity, gated by `disableAnalytics`.
+ *
+ * @internal
+ */ function emitBridgeSuccessTelemetry(result, config) {
+    if (config.disabled || result.state !== 'success') {
+        return;
+    }
+    try {
+        const txHash = pickSourceTxHash(result.steps);
+        // `JSON.stringify` turns a non-finite number into `null`, which the logs
+        // endpoint's strict schema rejects along with the whole event.
+        const amountIn = Number.parseFloat(result.amount);
+        emitSuccessTelemetry(BRIDGE_EVENT_TYPES.BRIDGE, config, {
+            sourceChain: result.source.chain.chain,
+            destinationChain: result.destination.chain.chain,
+            tokenIn: toTelemetryToken(result.token, result.source.chain),
+            ...Number.isFinite(amountIn) && {
+                amountIn
+            },
+            ...txHash != null && {
+                txHash
+            }
+        });
+    } catch (telemetryError) {
+        warnTelemetryDrop(BRIDGE_EVENT_TYPES.BRIDGE, telemetryError);
+    }
+}
 /**
  * BridgeKit caller component for retry and estimate operations.
  */ const BRIDGE_KIT_CALLER = {
@@ -29850,6 +30058,10 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
     /** Whether error telemetry is disabled. */ disableErrorReporting;
     /** Per-kit telemetry identity for shared helpers. */ telemetryConfig;
     /**
+   * Per-kit telemetry identity for success events. Gated by `disableAnalytics`
+   * independently of `disableErrorReporting`.
+   */ analyticsTelemetryConfig;
+    /**
    * Create a new BridgeKit instance.
    *
    * @param config - The configuration containing the CCTPv2 provider
@@ -29876,6 +30088,11 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
             sdkVersion: pkg$6.version,
             disabled: this.disableErrorReporting
         };
+        this.analyticsTelemetryConfig = {
+            sdkName: SDK_NAME$4,
+            sdkVersion: pkg$6.version,
+            disabled: config.disableAnalytics === true
+        };
         for (const provider of this.providers){
             provider.registerDispatcher(this.actionDispatcher);
         }
@@ -29889,7 +30106,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
         this.actionDispatcher.off(actionOrWildCard, handler);
     }
     async bridge(params) {
-        return withErrorTelemetry(async ()=>{
+        const bridgeResult = await withErrorTelemetry(async ()=>{
             // First validate the parameters
             assertBridgeParams(params, bridgeParamsWithChainIdentifierSchema);
             // Then resolve chain definitions (includes adapter chain support validation)
@@ -29926,7 +30143,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
                 emitResultStepErrorTelemetry(failedStep, BRIDGE_STEP_EVENT_MAP, BRIDGE_EVENT_TYPES.BRIDGE, this.telemetryConfig, {
                     sourceChain: resolveChainName(params.from.chain),
                     destinationChain: resolveChainName(params.to.chain),
-                    tokenIn: params.token,
+                    tokenIn: toTelemetryToken(result.token, result.source.chain),
                     ...txHash != null && {
                         txHash
                     }
@@ -29938,6 +30155,8 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
             destinationChain: resolveChainName(params.to.chain),
             tokenIn: params.token
         });
+        emitBridgeSuccessTelemetry(bridgeResult, this.analyticsTelemetryConfig);
+        return bridgeResult;
     }
     /**
    * Retry a failed or incomplete cross-chain USDC bridge operation.
@@ -30008,7 +30227,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
    * )
    * ```
    */ async retry(result, context, invocationMeta) {
-        return withErrorTelemetry(async ()=>{
+        const retriedResult = await withErrorTelemetry(async ()=>{
             // Cast the providers list to the wide view here. The tuple
             // type on `this.providers` retains concrete provider types
             // (CCTPv2 narrows `TToken` to `'USDC'`); calling `.retry`
@@ -30036,7 +30255,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
                 emitResultStepErrorTelemetry(failedStep, BRIDGE_STEP_EVENT_MAP, BRIDGE_EVENT_TYPES.RETRY, this.telemetryConfig, {
                     sourceChain: result.source.chain.chain,
                     destinationChain: result.destination.chain.chain,
-                    tokenIn: result.token,
+                    tokenIn: toTelemetryToken(result.token, result.source.chain),
                     ...txHash != null && {
                         txHash
                     }
@@ -30050,8 +30269,16 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
         }, BRIDGE_EVENT_TYPES.RETRY, this.telemetryConfig, {
             sourceChain: result.source.chain.chain,
             destinationChain: result.destination.chain.chain,
-            tokenIn: result.token
+            tokenIn: toTelemetryToken(result.token, result.source.chain)
         });
+        // A retry that completes the transfer is the transfer's only success
+        // event, so it reports the same `bridge_bridge` type as `bridge()`. An
+        // input that already succeeded was reported by the call that completed it
+        // (CCTP v2 returns such a result unchanged), so it is not reported again.
+        if (result.state !== 'success') {
+            emitBridgeSuccessTelemetry(retriedResult, this.analyticsTelemetryConfig);
+        }
+        return retriedResult;
     }
     async estimate(params) {
         return withErrorTelemetry(async ()=>{
@@ -30600,7 +30827,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
 registerKit(`${pkg$6.name}/${pkg$6.version}`);
 
 var name$4 = "@circle-fin/swap-kit";
-var version$4 = "1.8.0";
+var version$4 = "1.8.1";
 var pkg$4 = {
 	name: name$4,
 	version: version$4};
@@ -46834,6 +47061,9 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
         ...context.disableErrorReporting != null && {
             disableErrorReporting: context.disableErrorReporting
         },
+        ...context.disableAnalytics != null && {
+            disableAnalytics: context.disableAnalytics
+        },
         ...context.headers != null && {
             headers: context.headers
         }
@@ -46954,7 +47184,7 @@ registerKit(`${pkg$4.name}/${pkg$4.version}`);
 };
 
 var name$3 = "@circle-fin/earn-kit";
-var version$3 = "1.9.0";
+var version$3 = "1.10.0";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -47061,6 +47291,61 @@ const EARN_BRIDGE_USDC_ERC3009_DOMAINS = {
  *
  * @internal
  */ const EARN_BRIDGE_MAX_VALIDITY_SECONDS = 86_400n;
+/**
+ * Static fields of the EIP-712 domain for the `DepositIntent` typed-data
+ * intent. `chainId` is excluded here — it must come from the deposit's
+ * actual chain (see {@link buildDepositIntentTypedData}), since a mismatched
+ * `chainId` in the domain separator would make every intent signature
+ * invalid.
+ *
+ * `verifyingContract` is intentionally omitted — the intent is verified
+ * off-chain by the Earn Service, not by a deployed contract.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_DOMAIN = {
+    name: 'Circle EarnKit',
+    version: '1'
+};
+/**
+ * EIP-712 type definition for the `DepositIntent` struct.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_TYPES = {
+    DepositIntent: [
+        {
+            name: 'wallet',
+            type: 'address'
+        },
+        {
+            name: 'vault',
+            type: 'address'
+        },
+        {
+            name: 'amount',
+            type: 'uint256'
+        },
+        {
+            name: 'deadline',
+            type: 'uint256'
+        }
+    ]
+};
+/**
+ * Lifetime of a `DepositIntent` signature, in seconds.
+ *
+ * The Earn Service rejects a deadline more than 300 seconds ahead of its own
+ * clock. 240 seconds leaves room for clock skew between the client and the
+ * service while still covering the deposit request that follows the
+ * signature.
+ *
+ * @internal
+ */ const DEPOSIT_INTENT_TTL_SECONDS = 240;
+/**
+ * Protocol value the Earn Service reports for Veda vaults. A deposit into a
+ * Veda vault needs a signed `DepositIntent`.
+ *
+ * @internal
+ */ const VEDA_PROTOCOL = 'veda';
 /**
  * Display symbol for vault share tokens.
  *
@@ -49936,7 +50221,7 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
 }
 
 var name$2 = "@circle-fin/provider-earn-service";
-var version$2 = "1.7.2";
+var version$2 = "1.8.0";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -50288,8 +50573,9 @@ function toPositionInfo(data) {
  * Build signed deposit instructions via the Earn Service API.
  *
  * Call `POST /v1/earnKit/deposit` with the vault address, amount,
- * wallet address, and chain. Return EIP-712 signed execution
- * parameters for on-chain submission.
+ * wallet address, and chain, plus the signed `DepositIntent` when one is
+ * given. Return EIP-712 signed execution parameters for on-chain
+ * submission.
  *
  * @param params - Deposit parameters
  * @returns Signed execution parameters for the deposit
@@ -50303,7 +50589,8 @@ function toPositionInfo(data) {
         vaultAddress: params.vaultAddress,
         amount: params.amount,
         address: params.address,
-        chain: params.chain
+        chain: params.chain,
+        ...params.intent
     };
     try {
         const response = await pollApiPost(url.toString(), requestBody, isDepositResponse, pollingConfig);
@@ -50315,6 +50602,232 @@ function toPositionInfo(data) {
     }
 }
 
+/**
+ * Build the version-1 EarnKit `DepositIntent` EIP-712 typed data.
+ *
+ * The signed struct binds the depositing `wallet`, the target `vault`, the
+ * deposit `amount` in the asset's smallest unit, and a signature `deadline`.
+ * The Earn Service rebuilds the same struct from the deposit request and
+ * rejects the deposit unless `wallet` signed it. The domain intentionally
+ * omits `verifyingContract` because the service verifies the signature
+ * off-chain.
+ *
+ * `domain.chainId` comes from the deposit's chain rather than a constant: the
+ * domain separator must match what the service rebuilds, and a wrong
+ * `chainId` would make every intent signature invalid.
+ *
+ * This function returns the fully-typed {@link DepositIntentTypedData} with
+ * no assertion. {@link resolveDepositIntent} casts it to the adapter's
+ * generic `EIP712Domain` shape only where it calls `adapter.signTypedData`,
+ * since that shared interface always requires `verifyingContract`. The
+ * adapter's runtime `eip712DomainSchema` treats `verifyingContract` as
+ * optional, so the cast is safe at runtime. BorrowKit's
+ * `buildWebhookRegistrationTypedData` works around the same gap.
+ *
+ * @param params - Wallet, vault, base-unit amount, deadline, and chain id.
+ * @returns EIP-712 typed data ready to be cast for `adapter.signTypedData`.
+ *
+ * @example
+ * ```typescript
+ * const typedData = buildDepositIntentTypedData({
+ *   wallet: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   vault: '0x00000000000000000000000000000000000000a1',
+ *   amount: 100_000_000n,
+ *   deadline: 1_700_000_000n,
+ *   chainId: 5_042_002,
+ * })
+ * ```
+ *
+ * @internal
+ */ function buildDepositIntentTypedData(params) {
+    return {
+        domain: {
+            ...DEPOSIT_INTENT_DOMAIN,
+            chainId: params.chainId
+        },
+        types: DEPOSIT_INTENT_TYPES,
+        primaryType: 'DepositIntent',
+        message: {
+            wallet: params.wallet,
+            vault: params.vault,
+            amount: params.amount,
+            deadline: params.deadline
+        }
+    };
+}
+/**
+ * Earn Service error code for a missing, expired, or wrongly signed
+ * `DepositIntent` (`DEPOSIT_INTENT_INVALID`).
+ */ const DEPOSIT_INTENT_INVALID_CODE = 380418;
+/**
+ * Sign a `DepositIntent` when the target vault needs one.
+ *
+ * A Veda vault mints shares straight to the depositing wallet, so the Earn
+ * Service only builds a Veda deposit for a wallet that signed a
+ * `DepositIntent` for the same vault and amount. The vault lookup exists only
+ * to find out whether the vault is a Veda vault (and its asset decimals, to
+ * sign the amount). Other vaults ignore the intent, so this returns no intent
+ * for them and the wallet sees no extra signature prompt. A vault the service
+ * does not return is also treated as not needing an intent; the deposit call
+ * then reports why.
+ *
+ * A failed vault lookup does not stop the deposit: this returns the lookup
+ * error with no intent, so a non-Veda deposit works as before. A Veda deposit
+ * then gets `DEPOSIT_INTENT_INVALID` from the service, and
+ * {@link resolveDepositError} reports the lookup error instead. The lookup
+ * fails either by throwing or by returning the vault in its `errors` list (for
+ * example `VAULT_REFRESH_BUSY`); both are kept the same way.
+ *
+ * @param params - Adapter, resolved chain, wallet, vault, human-readable
+ *   amount, and service config.
+ * @returns The signed intent when the vault needs one, and the lookup error
+ *   when the vault lookup failed.
+ * @throws {@link KitError} `InputError.VALIDATION_FAILED` when the vault needs
+ *   an intent but the chain is not EVM, the adapter cannot sign typed data, or
+ *   the amount has more decimal places than the vault asset.
+ *
+ * @example
+ * ```typescript
+ * const { intent } = await resolveDepositIntent({
+ *   adapter,
+ *   chain: ArcTestnet,
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   vaultAddress: '0x00000000000000000000000000000000000000a1',
+ *   amount: '100',
+ *   config,
+ * })
+ * // intent -> { intentSignature: '0x…', intentDeadline: 1700000240 }
+ * ```
+ *
+ * @internal
+ */ async function resolveDepositIntent(params) {
+    let lookup;
+    try {
+        lookup = await fetchVaults({
+            // `resolveAdapterContext` already rejected chains the Earn Service does
+            // not support, so the chain is an Earn chain here.
+            vaults: [
+                {
+                    chain: params.chain,
+                    vaultAddress: params.vaultAddress
+                }
+            ],
+            config: params.config
+        });
+    } catch (lookupError) {
+        return {
+            lookupError
+        };
+    }
+    const vaultError = lookup.errors.find((candidate)=>isSameAddress(candidate.vaultAddress, params.vaultAddress));
+    if (vaultError !== undefined) {
+        // Same handling as a thrown lookup error, mapped with the Earn Service
+        // error table so it keeps its recoverability (VAULT_REFRESH_BUSY retries).
+        return {
+            lookupError: parseEarnApiError({
+                responseBody: {
+                    code: vaultError.code,
+                    message: vaultError.message
+                }
+            }, {
+                operation: 'getVaults'
+            })
+        };
+    }
+    const vault = lookup.vaults.find((candidate)=>isSameAddress(candidate.address, params.vaultAddress));
+    if (vault?.protocol.toLowerCase() !== VEDA_PROTOCOL) {
+        return {};
+    }
+    if (params.chain.type !== 'evm') {
+        throw createValidationFailedError$1('from.chain', params.chain.chain, 'Veda vault deposits need an EVM chain to sign the deposit intent');
+    }
+    if (!canSignTypedData(params.adapter)) {
+        throw createValidationFailedError$1('from.adapter', params.adapter, 'adapter must support signTypedData for Veda vault deposits');
+    }
+    const wallet = assertHexAddress('from.address', params.address, 'Depositor address must be a 0x-prefixed 20-byte hex address.');
+    const assetDecimals = vault.liquidityProfile.totalDeposits.decimals;
+    // Amount.parse truncates extra digits, but the service rejects them. Fail
+    // before the wallet prompt instead of asking to sign a deposit that cannot
+    // go through.
+    assertDecimalPlaces('amount', params.amount, assetDecimals, `amount must have at most ${String(assetDecimals)} decimal places for the vault asset`);
+    const deadline = Math.floor(Date.now() / 1000) + DEPOSIT_INTENT_TTL_SECONDS;
+    const typedData = buildDepositIntentTypedData({
+        wallet,
+        vault: params.vaultAddress,
+        amount: Amount.parse(params.amount, {
+            decimals: assetDecimals
+        }).raw,
+        deadline: BigInt(deadline),
+        chainId: params.chain.chainId
+    });
+    // `typedData.domain` intentionally omits `verifyingContract` (the Earn
+    // Service verifies off-chain), but the shared `signTypedData` signature
+    // requires the standard `EIP712Domain` shape. The adapter's runtime
+    // `eip712DomainSchema` treats `verifyingContract` as optional, so this cast
+    // is safe at runtime.
+    const intentSignature = await params.adapter.signTypedData(typedData, {
+        chain: params.chain,
+        address: wallet
+    });
+    return {
+        intent: {
+            intentSignature,
+            intentDeadline: deadline
+        }
+    };
+}
+/**
+ * Pick the error to report for a failed deposit request.
+ *
+ * When the vault lookup failed, the SDK sent the deposit without an intent.
+ * If the service then answers `DEPOSIT_INTENT_INVALID`, the vault is a Veda
+ * vault and the real cause is the failed lookup, not a bad signature. Report
+ * the lookup error, which keeps its own recoverability (often retryable),
+ * instead of a fatal signature rejection.
+ *
+ * When the SDK did send an intent and the service still answers
+ * `DEPOSIT_INTENT_INVALID`, the error stays a fatal signature rejection, but
+ * its message adds that the intent may have expired: the deadline starts
+ * before the wallet prompt, so a slow signer can submit an expired intent.
+ * Calling `deposit()` again signs a new one. Every other error is reported as
+ * is.
+ *
+ * @param resolution - The result of {@link resolveDepositIntent}.
+ * @param error - The error from the deposit request.
+ * @returns The error to throw.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   return await fetchDeposit({ ...params, intent: resolution.intent })
+ * } catch (error) {
+ *   throw resolveDepositError(resolution, error)
+ * }
+ * ```
+ *
+ * @internal
+ */ function resolveDepositError(resolution, error) {
+    if (resolution.lookupError !== undefined && isKitError(error) && isEarnServiceCode(error.cause?.trace, DEPOSIT_INTENT_INVALID_CODE)) {
+        return resolution.lookupError;
+    }
+    if (resolution.intent !== undefined && isKitError(error) && isEarnServiceCode(error.cause?.trace, DEPOSIT_INTENT_INVALID_CODE)) {
+        return new KitError({
+            code: error.code,
+            name: error.name,
+            type: error.type,
+            recoverability: error.recoverability,
+            message: `${error.message} The deposit intent may have expired before the deposit was submitted (it is valid for ${String(DEPOSIT_INTENT_TTL_SECONDS)} seconds from when the SDK asks the wallet to sign). Call deposit() again to sign a new intent.`,
+            ...error.cause !== undefined && {
+                cause: error.cause
+            }
+        });
+    }
+    return error;
+}
+function isEarnServiceCode(trace, code) {
+    return typeof trace === 'object' && trace !== null && 'earnServiceCode' in trace && trace.earnServiceCode === code;
+}
+
 /**
  * Build cross-chain deposit instructions via the bridge API.
  *
@@ -51553,13 +52066,31 @@ function finishElapsedWait(lastStatus, lastError) {
             const adapterContractAddress = requireAdapterContract(chain);
             const { adapter } = params.from;
             const vaultAddress = assertHexAddress('vaultAddress', params.vaultAddress, 'Vault address must be a 0x-prefixed 20-byte hex address.');
-            const { execId, executionParams, signature } = await this.runPhase(ctx, 'deposit', 'fetchParams', async ()=>fetchDeposit({
+            const { execId, executionParams, signature } = await this.runPhase(ctx, 'deposit', 'fetchParams', async ()=>{
+                // Veda vaults mint shares straight to `address`, so the service
+                // needs proof that `address` asked for this deposit. Sign it here,
+                // inside fetchParams, so a rejected prompt fails this phase.
+                const resolution = await resolveDepositIntent({
+                    adapter,
+                    chain,
+                    address,
                     vaultAddress,
                     amount: params.amount,
-                    address,
-                    chain: apiChain,
                     config
-                }), ()=>undefined);
+                });
+                try {
+                    return await fetchDeposit({
+                        vaultAddress,
+                        amount: params.amount,
+                        address,
+                        chain: apiChain,
+                        intent: resolution.intent,
+                        config
+                    });
+                } catch (error) {
+                    throw resolveDepositError(resolution, error);
+                }
+            }, ()=>undefined);
             validateExecutionDeadline$1(executionParams);
             const transactionReportContext = {
                 execId,
@@ -54566,7 +55097,7 @@ registerKit(`${pkg$3.name}/${pkg$3.version}`);
 };
 
 var name$1 = "@circle-fin/borrow-kit";
-var version$1 = "1.1.0";
+var version$1 = "1.1.1";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -67475,7 +68006,7 @@ async function deposit$2(context, params) {
 }
 
 var name = "@circle-fin/unified-balance-kit";
-var version = "1.8.1";
+var version = "1.8.2";
 var pkg = {
 	name: name,
 	version: version};