@circle-fin/app-kit 1.17.0 → 1.18.0

package/earn.mjs

@@ -2439,6 +2439,15 @@ class KitError extends Error {
             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,
@@ -3352,14 +3361,14 @@ var BorrowChain;
         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',
@@ -9554,7 +9563,7 @@ const swapTokenEnumSchema = z.enum([
 }
 
 var name$4 = "@circle-fin/bridge-kit";
-var version$4 = "1.15.3";
+var version$4 = "1.16.0";
 var pkg$4 = {
 	name: name$4,
 	version: version$4};
@@ -11350,7 +11359,7 @@ const validateQuoteItemSchema = z.object({
 registerKit(`${pkg$4.name}/${pkg$4.version}`);
 
 var name$3 = "@circle-fin/swap-kit";
-var version$3 = "1.8.0";
+var version$3 = "1.8.1";
 var pkg$3 = {
 	name: name$3,
 	version: version$3};
@@ -14611,6 +14620,47 @@ const abiParameterSchema = z.object({
  */ function hasSignTypedData(adapter) {
     return typeof adapter === 'object' && adapter !== null && 'signTypedData' in adapter && typeof adapter.signTypedData === 'function';
 }
+/**
+ * Type guard to check if an adapter can actually produce an EIP-712
+ * typed-data signature.
+ *
+ * @remarks
+ * Strengthens {@link hasSignTypedData}: having a `signTypedData` method
+ * does not guarantee it can succeed. Adapters whose signer is delegated
+ * (e.g. through a signing strategy backed by a smart contract account)
+ * expose the method but reject typed-data payloads at runtime. Such
+ * adapters report their real capability through an optional
+ * `supportsSignTypedData()` method, which this guard consults when
+ * present. Adapters without the capability method are assumed able to
+ * sign, preserving the previous duck-typing behavior.
+ *
+ * @param adapter - The adapter to check
+ * @returns True if calling `signTypedData` can be expected to succeed
+ *
+ * @example
+ * ```typescript
+ * import { canSignTypedData } from '@core/adapter-evm'
+ *
+ * if (canSignTypedData(adapter)) {
+ *   const signature = await adapter.signTypedData(typedData, context)
+ * } else {
+ *   // take an on-chain approval path instead of a permit signature
+ * }
+ * ```
+ */ function canSignTypedData(adapter) {
+    if (!hasSignTypedData(adapter)) {
+        return false;
+    }
+    if (typeof adapter.supportsSignTypedData === 'function') {
+        // The value is `boolean` per the interface, but a plain-JS adapter may
+        // return anything; treat it as untrusted and coerce to a strict
+        // boolean. Comparing an `unknown` (not a `boolean`) also keeps the
+        // lint autofix from stripping this as a redundant `=== true`.
+        const supported = adapter.supportsSignTypedData();
+        return supported === true;
+    }
+    return true;
+}
 
 /** Inputs for {@link checkErc3009ValidityWindow}. */ /**
  * Check an ERC-3009 authorization validity window.
@@ -15457,7 +15507,7 @@ new Set(Object.values(Blockchain));
 registerKit(`${pkg$3.name}/${pkg$3.version}`);
 
 var name$2 = "@circle-fin/earn-kit";
-var version$2 = "1.9.0";
+var version$2 = "1.10.0";
 var pkg$2 = {
 	name: name$2,
 	version: version$2};
@@ -15564,6 +15614,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.
  *
@@ -18401,7 +18506,7 @@ const bridgeDepositPrepareReviewSchema = z.object({
 }
 
 var name$1 = "@circle-fin/provider-earn-service";
-var version$1 = "1.7.2";
+var version$1 = "1.8.0";
 var pkg$1 = {
 	name: name$1,
 	version: version$1};
@@ -18753,8 +18858,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
@@ -18768,7 +18874,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);
@@ -18780,6 +18887,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('from.chain', params.chain.chain, 'Veda vault deposits need an EVM chain to sign the deposit intent');
+    }
+    if (!canSignTypedData(params.adapter)) {
+        throw createValidationFailedError('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.
  *
@@ -20008,13 +20341,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(executionParams);
             const transactionReportContext = {
                 execId,
@@ -23021,7 +23372,7 @@ registerKit(`${pkg$2.name}/${pkg$2.version}`);
 };
 
 var name = "@circle-fin/borrow-kit";
-var version = "1.1.0";
+var version = "1.1.1";
 var pkg = {
 	name: name,
 	version: version};