@circle-fin/app-kit 1.15.3 → 1.17.0

package/estimateBridge.cjs

@@ -1367,6 +1367,34 @@ let activeRedactor = defaultMessageRedactor;
     return redactErrorMessage(String(error));
 }
 
+/**
+ * Render an object value for an error message without letting the rendering
+ * itself throw.
+ *
+ * `JSON.stringify` rejects `BigInt` and circular structures, and a rejected
+ * value is exactly the kind of thing a validation error is built from: an
+ * on-chain read or a receipt log carries `bigint` fields, so serializing one
+ * naively replaces the intended error with a `TypeError`.
+ *
+ * @param value - The value to render.
+ * @returns A JSON string with `bigint` fields stringified, or
+ *   `'[unserializable object]'` if serialization still fails.
+ * @throws Never; serialization failures are caught and rendered as a fallback string.
+ * @example
+ * ```typescript
+ * import { describeObjectValue } from '@core/errors'
+ *
+ * describeObjectValue({ amount: 1n })
+ * // '{"amount":"1"}'
+ * ```
+ */ function describeObjectValue(value) {
+    try {
+        return JSON.stringify(value, (_key, entry)=>typeof entry === 'bigint' ? entry.toString() : entry);
+    } catch  {
+        return '[unserializable object]';
+    }
+}
+
 /**
  * Creates error for network type mismatch between source and destination.
  *
@@ -1629,7 +1657,7 @@ let activeRedactor = defaultMessageRedactor;
  * // Message: "Validation failed for 'chainId': 999 - Unsupported chain ID"
  *
  * throw createValidationFailedError('config', { invalid: true }, 'Missing required properties')
- * // Message: "Validation failed for 'config': [object Object] - Missing required properties"
+ * // Message: "Validation failed for 'config': {"invalid":true} - Missing required properties"
  * ```
  */ function createValidationFailedError$1(field, value, reason) {
     // Convert value to string for display, handling different types appropriately
@@ -1637,7 +1665,7 @@ let activeRedactor = defaultMessageRedactor;
     if (typeof value === 'string') {
         valueString = `'${value}'`;
     } else if (typeof value === 'object' && value !== null) {
-        valueString = JSON.stringify(value);
+        valueString = describeObjectValue(value);
     } else {
         valueString = String(value);
     }
@@ -2494,22 +2522,73 @@ let activeRedactor = defaultMessageRedactor;
     '0x9147d463': 'Final balance is less than the initial balance',
     '0xf4b3b1bc': 'Native token transfer to the beneficiary failed'
 };
+/**
+ * Matches revert data: a 4-byte selector followed by whole ABI-encoded bytes.
+ */ const REVERT_DATA_PATTERN = /^0x[0-9a-f]{8}(?:[0-9a-f]{2})*$/i;
+/**
+ * Returns the revert data held by one error in a `cause` chain.
+ *
+ * Browser wallets (EIP-1193) wrap the node's error, so the revert data sits
+ * one level down as `data.data`. viem's `getContractError` reads it the same
+ * way, then keeps it on `ContractFunctionRevertedError.raw` and drops the
+ * node's error from the chain.
+ *
+ * @param link - One error in the `cause` chain
+ * @returns The `raw` or `data` string, or undefined if there is none
+ */ function getRevertData(link) {
+    if ('raw' in link && typeof link.raw === 'string' && REVERT_DATA_PATTERN.test(link.raw)) {
+        return link.raw;
+    }
+    if (!('data' in link)) {
+        return undefined;
+    }
+    const { data } = link;
+    if (typeof data === 'string') {
+        return data;
+    }
+    if (data !== null && typeof data === 'object' && 'data' in data && typeof data.data === 'string') {
+        return data.data;
+    }
+    return undefined;
+}
+/**
+ * Finds the first revert data on the error or in its `cause` chain that
+ * `accept` takes.
+ *
+ * viem keeps the node's revert data on an inner `RpcRequestError`, not on
+ * the error it throws. The `seen` set stops a self-referencing `cause` chain.
+ *
+ * @param error - The error object
+ * @param accept - Returns true for the data shape the caller wants
+ * @returns The data as written on the error, or undefined if not found
+ */ function findRevertData(error, accept) {
+    const seen = new Set();
+    let current = error;
+    while(current !== null && typeof current === 'object' && !seen.has(current)){
+        seen.add(current);
+        const data = getRevertData(current);
+        if (data !== undefined && accept(data)) {
+            return data;
+        }
+        current = 'cause' in current ? current.cause : undefined;
+    }
+    return undefined;
+}
 /**
  * Attempts to extract an error selector from an error object or message.
  *
  * Checks multiple sources in priority order:
- * 1. `error.data` field
+ * 1. `raw` or `data` field (or nested `data.data`) on the error or anywhere
+ *    in its `cause` chain
  * 2. Message pattern: "custom error 0x8baa579f"
  *
  * @param msg - The error message
  * @param error - The error object (optional)
  * @returns The 4 bytes selector , or undefined if not found
  */ function extractErrorSelector(msg, error) {
-    // Check error.data field
-    if (error !== null && typeof error === 'object' && 'data' in error) {
-        if (typeof error.data === 'string' && /^0x[0-9a-f]{8}$/i.test(error.data)) {
-            return error.data.toLowerCase();
-        }
+    const data = findRevertData(error, (value)=>/^0x[0-9a-f]{8}$/i.test(value));
+    if (data !== undefined) {
+        return data.toLowerCase();
     }
     // Check for "custom error 0x8baa579f" in the message
     const match = /custom error (0x[0-9a-f]{8})\b/i.exec(msg);
@@ -3135,6 +3214,105 @@ let activeRedactor = defaultMessageRedactor;
     return chain;
 }
 
+/**
+ * Extracts the HTTP status code from an error message.
+ *
+ * Attempts to parse HTTP status codes from common error message formats,
+ * such as "HTTP 404" or "Status: 500".
+ *
+ * Shared by `parseApiError` and the backend-error-code parsers that route on
+ * status when no backend code is available, so all of them recognise the same
+ * message shapes.
+ *
+ * @param msg - The error message to extract from
+ * @returns The extracted HTTP status code, or null if not found
+ *
+ * @example
+ * ```typescript
+ * const code = extractHttpStatusCode('HTTP 404')
+ * // Returns: 404
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const code = extractHttpStatusCode('Status: 500 Internal Server Error')
+ * // Returns: 500
+ * ```
+ *
+ * @internal
+ */ function extractHttpStatusCode(msg) {
+    // Pattern: "HTTP 404" or "HTTP 404 - some message" or "Status: 404"
+    const patterns = [
+        /HTTP (\d{3})/i,
+        /Status:\s*(\d{3})/i,
+        /^(\d{3}) -/
+    ];
+    for (const pattern of patterns){
+        const match = pattern.exec(msg);
+        const codeStr = match?.at(1);
+        if (codeStr !== undefined) {
+            const code = Number.parseInt(codeStr, 10);
+            // Validate it's a valid HTTP status code
+            if (code >= 100 && code < 600) {
+                return code;
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * Type guard that narrows an unknown error to one carrying a non-null
+ * object `responseBody` property (attached by `makeApiRequest`).
+ *
+ * Shared by backend-error-code parsers (`parseEarnApiError`,
+ * `parseBorrowApiError`) so the narrowing logic lives in one place.
+ *
+ * @param error - The raw error from the HTTP layer
+ * @returns `true` when `error.responseBody` is a non-null object
+ * @internal
+ */ function hasResponseBody(error) {
+    return typeof error === 'object' && error !== null && 'responseBody' in error && typeof error['responseBody'] === 'object' && error['responseBody'] !== null;
+}
+/**
+ * Narrow an unknown value to a non-null object.
+ *
+ * @param value - The value to check
+ * @returns `true` when `value` is a non-null object
+ * @internal
+ */ function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Read the machine-readable error fields (`code`, `message`,
+ * `externalMessage`) that a Circle service attaches to an HTTP error body.
+ *
+ * `platform-common-go` serializes app-thrown errors under a nested envelope —
+ * `{ response: { status: { code, message, externalMessage } } }` — for every
+ * HTTP status, so this returns that inner `response.status` object when
+ * present. It otherwise falls back to the top-level body so a flattened shape
+ * (e.g. the stablecoin-kits-proxy) is still read. Callers read
+ * `code` / `message` / `externalMessage` off the returned object uniformly.
+ *
+ * @param error - The raw error from the HTTP layer
+ * @returns The error-status fields, or `undefined` when the error carries no
+ *   response body
+ * @internal
+ */ function extractResponseBody$1(error) {
+    if (!hasResponseBody(error)) {
+        return undefined;
+    }
+    const body = error.responseBody;
+    const response = body['response'];
+    if (isRecord(response)) {
+        const status = response['status'];
+        if (isRecord(status)) {
+            return status;
+        }
+    }
+    return body;
+}
+
 /**
  * Proxy-specific structured error codes carried in `responseBody.code`.
  *
@@ -3435,29 +3613,22 @@ let activeRedactor = defaultMessageRedactor;
     });
 }
 /**
- * Type guard that narrows an unknown error to one carrying a non-null
- * object `responseBody` property (attached by `makeApiRequest`).
+ * Extract the machine-readable error fields that `makeApiRequest` attaches to
+ * HTTP error instances.
  *
- * @param error - The raw error from the HTTP layer
- * @returns `true` when `error.responseBody` is a non-null object
- * @internal
- */ function hasResponseBody(error) {
-    return typeof error === 'object' && error !== null && 'responseBody' in error && typeof error['responseBody'] === 'object' && error['responseBody'] !== null;
-}
-/**
- * Extract the `responseBody` property that `makeApiRequest` attaches to
- * HTTP error instances when the server returns a JSON body.
+ * Delegates to the shared extractor so this fall-through path reads the same
+ * shape as the backend-code parsers: it unwraps the nested
+ * `{ response: { status } }` envelope when present, otherwise returns the
+ * top-level body. Routing both halves through one extractor keeps an
+ * unmapped-code error from losing the server's `externalMessage`.
  *
  * @param error - The raw error from the HTTP layer
- * @returns The parsed body cast to {@link ApiErrorResponseBody}, or undefined
+ * @returns The parsed body as {@link ApiErrorResponseBody}, or undefined
  * @throws Never. Returns `undefined` when the error does not carry a valid
  *   `responseBody`.
  * @internal
  */ function extractResponseBody(error) {
-    if (!hasResponseBody(error)) {
-        return undefined;
-    }
-    return error.responseBody;
+    return extractResponseBody$1(error);
 }
 /**
  * Extract a field name from an {@link ApiFieldError}.
@@ -3566,46 +3737,6 @@ let activeRedactor = defaultMessageRedactor;
     }
     return topMessage ?? fieldDetail;
 }
-/**
- * Extracts the HTTP status code from an error message.
- *
- * Attempts to parse HTTP status codes from common error message formats,
- * such as "HTTP 404" or "Status: 500".
- *
- * @param msg - The error message to extract from
- * @returns The extracted HTTP status code, or null if not found
- *
- * @example
- * ```typescript
- * const code = extractHttpStatusCode('HTTP 404')
- * // Returns: 404
- * ```
- *
- * @example
- * ```typescript
- * const code = extractHttpStatusCode('Status: 500 Internal Server Error')
- * // Returns: 500
- * ```
- */ function extractHttpStatusCode(msg) {
-    // Pattern: "HTTP 404" or "HTTP 404 - some message" or "Status: 404"
-    const patterns = [
-        /HTTP (\d{3})/i,
-        /Status:\s*(\d{3})/i,
-        /^(\d{3}) -/
-    ];
-    for (const pattern of patterns){
-        const match = pattern.exec(msg);
-        const codeStr = match?.at(1);
-        if (codeStr !== undefined) {
-            const code = Number.parseInt(codeStr, 10);
-            // Validate it's a valid HTTP status code
-            if (code >= 100 && code < 600) {
-                return code;
-            }
-        }
-    }
-    return null;
-}
 
 /**
  * @packageDocumentation
@@ -3730,6 +3861,8 @@ var SwapChain;
     SwapChain["HyperEVM"] = "HyperEVM";
     SwapChain["Monad"] = "Monad";
     SwapChain["Arc"] = "Arc";
+    SwapChain["Cronos"] = "Cronos";
+    SwapChain["Morph"] = "Morph";
     // Testnet chains with swap support
     SwapChain["Arc_Testnet"] = "Arc_Testnet";
 })(SwapChain || (SwapChain = {}));
@@ -3861,6 +3994,11 @@ var EarnChain;
     "Arc",
     "Arc_Testnet"
 ];
+var BorrowChain;
+(function(BorrowChain) {
+    BorrowChain["Arc"] = "Arc";
+    BorrowChain["Arc_Testnet"] = "Arc_Testnet";
+})(BorrowChain || (BorrowChain = {}));
 
 /**
  * Helper function to define a chain with proper TypeScript typing.
@@ -4203,6 +4341,29 @@ var EarnChain;
  * on EVM-compatible testnet chains. Use this address for testnet adapter
  * integrations (e.g., Arc Testnet).
  */ const ADAPTER_CONTRACT_EVM_TESTNET = '0xBBD70b01a1CAbc96d5b7b129Ae1AAabdf50dd40b';
+/**
+ * The sender-preserving batching contract on Arc (`Multicall3From`).
+ *
+ * This predeploy batches calls like the ubiquitous Multicall3, but routes each
+ * subcall through Arc's `CallFrom` precompile
+ * (`0x1800000000000000000000000000000000000003`), which executes on behalf of
+ * the transaction's original sender. Every target therefore sees the calling
+ * EOA as `msg.sender`, which is what makes a plain, un-upgraded EOA capable of
+ * an atomic batch on Arc.
+ *
+ * Deployed at the same address on Arc Testnet and Arc Mainnet.
+ *
+ * @see https://docs.arc.io/arc/concepts/batched-transactions
+ */ const BATCHER_CONTRACT_ARC_TESTNET = '0x522fAf9A91c41c443c66765030741e4AaCe147D0';
+/**
+ * The sender-preserving batching contract on Arc Mainnet (`Multicall3From`).
+ *
+ * See {@link BATCHER_CONTRACT_ARC_TESTNET} for how this contract works.
+ * Requires Arc's Zero7 hardfork, which activates the `CallFrom` precompile
+ * this contract depends on.
+ *
+ * @see https://docs.arc.io/arc/concepts/batched-transactions
+ */ const BATCHER_CONTRACT_ARC_MAINNET = '0x522fAf9A91c41c443c66765030741e4AaCe147D0';
 /**
  * The GatewayWallet contract address for EVM mainnet networks.
  *
@@ -4342,7 +4503,10 @@ var EarnChain;
     },
     kitContracts: {
         bridge: BRIDGE_CONTRACT_EVM_MAINNET,
-        adapter: ADAPTER_CONTRACT_EVM_MAINNET
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET,
+        // Arc is the only chain with a sender-preserving batcher, because it
+        // takes a precompile rather than an ordinary contract to build one.
+        senderPreservingBatcher: BATCHER_CONTRACT_ARC_MAINNET
     },
     gateway: {
         domain: 26,
@@ -4413,7 +4577,10 @@ var EarnChain;
     },
     kitContracts: {
         bridge: BRIDGE_CONTRACT_EVM_TESTNET,
-        adapter: ADAPTER_CONTRACT_EVM_TESTNET
+        adapter: ADAPTER_CONTRACT_EVM_TESTNET,
+        // Arc is the only chain with a sender-preserving batcher, because it
+        // takes a precompile rather than an ordinary contract to build one.
+        senderPreservingBatcher: BATCHER_CONTRACT_ARC_TESTNET
     },
     gateway: {
         domain: 26,
@@ -5028,7 +5195,8 @@ var EarnChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -5897,7 +6065,8 @@ var EarnChain;
         }
     },
     kitContracts: {
-        bridge: BRIDGE_CONTRACT_EVM_MAINNET
+        bridge: BRIDGE_CONTRACT_EVM_MAINNET,
+        adapter: ADAPTER_CONTRACT_EVM_MAINNET
     }
 });
 
@@ -8083,7 +8252,8 @@ var Chains = {
     cctpx: zod.z.any().optional(),
     kitContracts: zod.z.object({
         bridge: zod.z.string().optional(),
-        adapter: zod.z.string().optional()
+        adapter: zod.z.string().optional(),
+        senderPreservingBatcher: zod.z.string().optional()
     }).optional(),
     gateway: gatewayConfigSchema.optional()
 });
@@ -8194,8 +8364,8 @@ var Chains = {
  * Zod schema for validating swap-specific chain identifiers.
  *
  * Validates chains based on:
- * - CCTPv2 support (adapter contract deployed)
- * - Mainnet only (no testnets)
+ * - Membership in the SwapChain enum
+ * - Mainnet or explicitly allowlisted testnet
  * - At least one supported token available
  *
  */ const swapChainIdentifierSchema = zod.z.union([
@@ -8279,6 +8449,38 @@ var Chains = {
             message: `"${chain.chain}" is not a supported earn chain. ` + `Supported chains: ${Object.values(EarnChain).join(', ')}`
         }))
 ]);
+/**
+ * Zod schema for validating Borrow-specific chain identifiers.
+ *
+ * Validate that the provided chain is supported for Borrow Kit's loan
+ * operations. Unlike {@link earnChainIdentifierSchema}, this includes Arc
+ * mainnet as well as Arc Testnet.
+ *
+ * Accept a BorrowChain enum value, a matching string literal, or a
+ * ChainDefinition for a supported chain.
+ *
+ * @example
+ * ```typescript
+ * import { borrowChainIdentifierSchema } from '@core/chains'
+ * import { Arc, BorrowChain } from '@core/chains'
+ *
+ * // Valid
+ * borrowChainIdentifierSchema.parse(BorrowChain.Arc)
+ * borrowChainIdentifierSchema.parse('Arc')
+ * borrowChainIdentifierSchema.parse(Arc)
+ *
+ * // Invalid (throws ZodError)
+ * borrowChainIdentifierSchema.parse('Solana')
+ * ```
+ */ const borrowChainIdentifierSchema = zod.z.union([
+    zod.z.string().refine((val)=>val in BorrowChain, (val)=>({
+            message: `"${val}" is not a supported borrow chain. ` + `Supported chains: ${Object.values(BorrowChain).join(', ')}`
+        })),
+    zod.z.nativeEnum(BorrowChain),
+    chainDefinitionSchema$2.refine((chain)=>chain.chain in BorrowChain, (chain)=>({
+            message: `"${chain.chain}" is not a supported borrow chain. ` + `Supported chains: ${Object.values(BorrowChain).join(', ')}`
+        }))
+]);
 // Widened views so `.includes()` accepts arbitrary strings under strict TS.
 const EARN_BRIDGE_SOURCE_CHAIN_VALUES = EARN_BRIDGE_SOURCE_BLOCKCHAINS;
 const EARN_BRIDGE_DESTINATION_CHAIN_VALUES = EARN_BRIDGE_DESTINATION_BLOCKCHAINS;
@@ -8489,8 +8691,13 @@ const swapTokenEnumSchema = zod.z.enum([
  */ function resolveChainName(value) {
     if (value == null) return undefined;
     if (typeof value === 'string') return value;
-    if (typeof value === 'object' && 'chain' in value && typeof value.chain === 'string') {
-        return value.chain;
+    try {
+        if (typeof value === 'object' && 'chain' in value) {
+            const chain = value.chain;
+            if (typeof chain === 'string') return chain;
+        }
+    } catch  {
+        return undefined;
     }
     return undefined;
 }
@@ -8637,7 +8844,7 @@ const swapTokenEnumSchema = zod.z.enum([
  *
  * A chain supports swaps if ALL conditions are met:
  * 1. Is a member of the {@link SwapChain} enum
- * 2. Has CCTPv2 support (adapter contract deployed)
+ * 2. Has an Adapter contract configured directly or through CCTP v2
  *
  * Testnets are allowed only when explicitly listed in the
  * {@link SwapChain} enum (e.g., Arc_Testnet).
@@ -8658,14 +8865,14 @@ const swapTokenEnumSchema = zod.z.enum([
  * @remarks
  * Chains automatically become swap-enabled when:
  * - Added to the {@link SwapChain} enum
- * - Adapter contract is deployed (CCTPv2)
+ * - An Adapter contract is deployed and configured
  *
  * No code changes needed when new chains are added!
  */ function isSwapSupportedChain(chain) {
     if (!(chain.chain in SwapChain)) {
         return false;
     }
-    if (!isCCTPV2Supported(chain)) {
+    if (!isCCTPV2Supported(chain) && !hasCustomContractSupport(chain, 'adapter')) {
         return false;
     }
     return true;
@@ -8676,7 +8883,7 @@ const swapTokenEnumSchema = zod.z.enum([
  *
  * Dynamically filter chain definitions to include only those that:
  * - Are members of the {@link SwapChain} enum
- * - Have CCTPv2 support
+ * - Have an Adapter contract configured directly or through CCTP v2
  *
  * This function is pure and accepts chains as parameter to avoid
  * circular dependencies.
@@ -9198,6 +9405,7 @@ const swapTokenEnumSchema = zod.z.enum([
  * - Retries on rate limiting (429)
  * - Does not retry on client errors (4xx, except 429)
  * - Does not retry on validation failures
+ * - Does not retry when `config.isTerminalError` marks the error terminal
  *
  * Each HTTP request is given a configurable timeout before it is aborted.
  * Between retry attempts the wait depends on the `backoff` strategy. The
@@ -9277,7 +9485,10 @@ const swapTokenEnumSchema = zod.z.enum([
             return await makeApiRequest(url, method, isValidType, effectiveConfig, body);
         } catch (err) {
             const error = err instanceof Error ? err : new Error(String(err));
-            if (!isRetryableError(error)) {
+            // A caller-supplied predicate can mark an error terminal (e.g. a
+            // deterministic 404) so it is surfaced immediately instead of burning
+            // the retry budget on a non-transient answer.
+            if (effectiveConfig.isTerminalError?.(error) === true || !isRetryableError(error)) {
                 throw error;
             }
             lastError = error;
@@ -9361,7 +9572,24 @@ const swapTokenEnumSchema = zod.z.enum([
  * // After this call, TypeScript knows params is of type BridgeParams
  * ```
  */ function validate(value, schema, context) {
-    const result = schema.safeParse(value);
+    let result;
+    try {
+        result = schema.safeParse(value);
+    } catch (error) {
+        throw new KitError({
+            ...InputError.VALIDATION_FAILED,
+            recoverability: 'FATAL',
+            message: `Invalid ${context}: reading a property threw`,
+            cause: {
+                trace: {
+                    validationErrors: [
+                        'Reading a property of the value threw'
+                    ],
+                    originalError: error
+                }
+            }
+        });
+    }
     if (!result.success) {
         throw createValidationErrorFromZod(result.error, context);
     }
@@ -10089,11 +10317,13 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
         [Blockchain.Avalanche]: '0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7',
         [Blockchain.Celo]: '0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e',
+        [Blockchain.Cronos]: '0x66e428c3f67a68878562e79A0234c1F83c208770',
         [Blockchain.Ethereum]: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
         [Blockchain.HyperEVM]: '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb',
         [Blockchain.Ink]: '0x0200C29006150606B650577BBE7B6248F58470c1',
         [Blockchain.Linea]: '0xA219439258ca9da29E9Cc4cE5596924745e12B93',
         [Blockchain.Monad]: '0xe7cd86e13AC4309349F30B3435a9d337750fC82D',
+        [Blockchain.Morph]: '0xe7cd86e13AC4309349F30B3435a9d337750fC82D',
         [Blockchain.NEAR]: 'usdt.tether-token.near',
         [Blockchain.Optimism]: '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58',
         [Blockchain.Polkadot_Asset_Hub]: '1984',
@@ -10152,6 +10382,7 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
         [Blockchain.Avalanche]: '0xd586E7F844cEa2F87f50152665BCbc2C279D8d70',
         [Blockchain.Base]: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+        [Blockchain.Cronos]: '0xF2001B145b43032AAF5Ee2884e456CCd805F677D',
         [Blockchain.Ethereum]: '0x6B175474E89094C44Da98b954EedeAC495271d0F',
         [Blockchain.Linea]: '0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5',
         [Blockchain.Optimism]: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
@@ -10214,7 +10445,9 @@ function parseOrThrow(value, schema, context) {
         [Blockchain.Arbitrum]: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
         [Blockchain.Avalanche]: '0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB',
         [Blockchain.Base]: '0x4200000000000000000000000000000000000006',
+        [Blockchain.Cronos]: '0xe44Fd7fCb2b1581822D0c862B68222998a0c299a',
         [Blockchain.Ethereum]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+        [Blockchain.Morph]: '0x5300000000000000000000000000000000000011',
         [Blockchain.Optimism]: '0x4200000000000000000000000000000000000006',
         [Blockchain.Polygon]: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619',
         [Blockchain.Solana]: '7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs'
@@ -10233,6 +10466,7 @@ function parseOrThrow(value, schema, context) {
     locators: {
         [Blockchain.Ethereum]: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
         [Blockchain.Arbitrum]: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        [Blockchain.Cronos]: '0x062E66477Faf219F25D27dCED647BF57C3107d52',
         [Blockchain.Avalanche]: '0x50b7545627a5162F82A992c33b87aDc75187B218'
     }
 };
@@ -12062,11 +12296,11 @@ function resolveOptions(options) {
     void emitAnalyticsLog(buildPayload(config, stepEntry?.[1] ?? fallbackEventType, errorDetails, context));
 }
 
-var name$2 = "@circle-fin/bridge-kit";
-var version$3 = "1.15.1";
-var pkg$3 = {
-	name: name$2,
-	version: version$3};
+var name$3 = "@circle-fin/bridge-kit";
+var version$4 = "1.15.3";
+var pkg$4 = {
+	name: name$3,
+	version: version$4};
 
 const assertCustomFeePolicySymbol = Symbol('assertCustomFeePolicy');
 /**
@@ -12635,6 +12869,12 @@ const READ_ACTION_KEY_SET = new Set(READ_ACTION_KEYS);
     /** EIP-2612 standard permit */ PermitType[PermitType["EIP2612"] = 1] = "EIP2612";
 })(PermitType || (PermitType = {}));
 
+var BorrowPermitType;
+(function(BorrowPermitType) {
+    /** Tokens must be approved separately. */ BorrowPermitType[BorrowPermitType["NONE"] = 0] = "NONE";
+    /** EIP-2612 permit calldata accompanies the token input. */ BorrowPermitType[BorrowPermitType["EIP2612"] = 1] = "EIP2612";
+})(BorrowPermitType || (BorrowPermitType = {}));
+
 /**
  * Abstract base class for bridging providers that implement cross-chain bridging protocols.
  *
@@ -14622,7 +14862,11 @@ function createNoopLogger() {
     tokenId: bytes32Hex,
     domainId: nonNegativeInteger,
     tokenAddress: zod.z.string(),
-    tokenManagerAddress: zod.z.string()
+    tokenManagerAddress: zod.z.string(),
+    // Operator-controlled per-chain kill switch (CCTPE-3979). Optional for
+    // back-compat with older IRIS versions that do not surface it. Downstream
+    // consumers in `findCCTPXDeployment` treat a missing value as `true`.
+    enabled: zod.z.boolean().optional()
 });
 /**
  * Schema for one token entry in the token registry response.
@@ -15106,17 +15350,23 @@ function createNoopLogger() {
 /**
  * Find a token's deployment on the given CCTP domain.
  *
+ * A deployment row with `enabled === false` is treated as missing: an IRIS
+ * operator has flipped the per-chain kill switch (CCTPE-3979), so the SDK must
+ * not route through it even though the row still exists in the registry. A
+ * missing or `true` `enabled` value remains routable — the field is optional on
+ * older IRIS versions and absence is read as "allowed".
+ *
  * @param token - The registry token whose deployments are searched.
  * @param domain - The CCTP domain id to match.
  * @returns The matching {@link CCTPXTokenDeployment}, or `undefined` when the
- *   token has no deployment on that domain.
+ *   token has no deployment on that domain or the deployment is disabled.
  *
  * @example
  * ```typescript
  * const deployment = findCCTPXDeployment(token, 0)
  * ```
  */ function findCCTPXDeployment(token, domain) {
-    return token.deployments.find((deployment)=>deployment.domainId === domain);
+    return token.deployments.find((deployment)=>deployment.domainId === domain && deployment.enabled !== false);
 }
 
 /**
@@ -15218,6 +15468,24 @@ function createNoopLogger() {
                     }
                 }
             })
+    ],
+    // The token is not deployed on one of the route chains, or an operator has
+    // flipped the per-chain `enabled` kill switch on the IRIS deployment row.
+    // Either way the route is permanently unavailable until the operator intervenes;
+    // a retry at the same source/destination will keep returning this error.
+    [
+        'TOKEN_NOT_SUPPORTED_ON_ROUTE',
+        ({ sourceDomain, destinationDomain })=>new KitError({
+                ...InputError.UNSUPPORTED_ROUTE,
+                recoverability: 'FATAL',
+                message: 'CCTPx fee quote rejected the route: the token is not supported on ' + 'the source or destination chain (missing deployment or operator-disabled).',
+                cause: {
+                    trace: {
+                        sourceDomain,
+                        destinationDomain
+                    }
+                }
+            })
     ]
 ]);
 /**
@@ -19758,7 +20026,7 @@ const defaultSleep = async (ms)=>new Promise((resolve)=>setTimeout(resolve, ms))
  * Must always contain both adapter and chain explicitly.
  *
  * Optionally includes address for developer-controlled adapters.
- */ const adapterContextSchema$3 = zod.z.object({
+ */ const adapterContextSchema$4 = zod.z.object({
     adapter: adapterSchema,
     chain: bridgeChainIdentifierSchema,
     address: zod.z.string().optional()
@@ -19767,14 +20035,14 @@ const defaultSleep = async (ms)=>new Promise((resolve)=>setTimeout(resolve, ms))
  * Schema for validating BridgeDestinationWithAddress objects.
  * Contains an explicit recipientAddress along with adapter and chain.
  * The address format is validated based on the chain type (EVM or Solana).
- */ const bridgeDestinationWithAddressSchema = adapterContextSchema$3.extend({
+ */ const bridgeDestinationWithAddressSchema = adapterContextSchema$4.extend({
     recipientAddress: zod.z.string().min(1, 'Recipient address is required'),
     useForwarder: zod.z.boolean().optional()
 }).superRefine(createRecipientAddressValidator());
 /**
  * Schema for validating AdapterContext with optional useForwarder.
  * Extends adapterContextSchema with the useForwarder flag.
- */ const adapterContextWithForwarderSchema = adapterContextSchema$3.extend({
+ */ const adapterContextWithForwarderSchema = adapterContextSchema$4.extend({
     useForwarder: zod.z.boolean().optional()
 });
 /**
@@ -19849,7 +20117,7 @@ const defaultSleep = async (ms)=>new Promise((resolve)=>setTimeout(resolve, ms))
  * }
  * ```
  */ const bridgeParamsWithChainIdentifierSchema = zod.z.object({
-    from: adapterContextSchema$3.strict(),
+    from: adapterContextSchema$4.strict(),
     to: bridgeDestinationSchema,
     amount: zod.z.string().min(1, 'Required').pipe(createDecimalStringValidator({
         allowZero: false,
@@ -20009,7 +20277,7 @@ const defaultSleep = async (ms)=>new Promise((resolve)=>setTimeout(resolve, ms))
     const bridgeKitCaller = {
         type: 'kit',
         name: 'BridgeKit',
-        version: pkg$3.version
+        version: pkg$4.version
     };
     // Create default runtime and tokens for invocation context resolution
     const defaults = {
@@ -23228,16 +23496,16 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$2 = "1.14.0";
-var pkg$2 = {
-	version: version$2};
+var version$3 = "1.14.2";
+var pkg$3 = {
+	version: version$3};
 
 /**
  * Provider caller component for bridge operations.
  */ const BRIDGE_CALLER = {
     type: 'provider',
     name: 'CCTPV2BridgingProvider.bridge',
-    version: pkg$2.version
+    version: pkg$3.version
 };
 /**
  * Resolve invocation context for bridge operations.
@@ -23610,7 +23878,7 @@ var pkg$2 = {
  */ const RETRY_CALLER = {
     type: 'provider',
     name: 'CCTPV2BridgingProvider.retry',
-    version: pkg$2.version
+    version: pkg$3.version
 };
 /**
  * Resolve invocation context for retry operations.
@@ -25537,7 +25805,7 @@ function assertCCTPV2Config(config) {
  * Decimal string in token minor units, constrained to be strictly positive.
  *
  * @internal
- */ const positiveAmountSchema = zod.z.string().regex(/^\d+$/, 'must be a non-negative integer string')// Re-check the digit shape here: zod still runs this refinement when the
+ */ const positiveAmountSchema$1 = zod.z.string().regex(/^\d+$/, 'must be a non-negative integer string')// Re-check the digit shape here: zod still runs this refinement when the
 // regex check above fails ("dirty"), so guard BigInt() against throwing on a
 // non-numeric value before comparing.
 .refine((value)=>/^\d+$/.test(value) && BigInt(value) > 0n, 'must be greater than zero');
@@ -25617,7 +25885,7 @@ const preFinalityRequestSchema = zod.z.object({
  */ const fetchFeeQuoteInputSchema = zod.z.object({
     sourceDomain: zod.z.number().int().nonnegative(),
     destinationDomain: zod.z.number().int().nonnegative(),
-    amount: positiveAmountSchema,
+    amount: positiveAmountSchema$1,
     feeToken: evmAddressSchema.optional(),
     requests: feeQuoteRequestsSchema,
     isTestnet: zod.z.boolean(),
@@ -26494,7 +26762,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
  * The ERC-20 `decimals` field is a `uint8`, so a provider reporting more than
  * this is returning something that cannot describe a real token.
  */ const MAX_TOKEN_DECIMALS = 255;
-/** SDK name used in telemetry payloads. */ const SDK_NAME = resolveKitSdkName(pkg$3.name);
+/** SDK name used in telemetry payloads. */ const SDK_NAME = resolveKitSdkName(pkg$4.name);
 /**
  * Pick the most-relevant `txHash` to attach to an error telemetry payload.
  *
@@ -26535,7 +26803,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
  */ const BRIDGE_KIT_CALLER = {
     type: 'kit',
     name: 'BridgeKit',
-    version: pkg$3.version
+    version: pkg$4.version
 };
 /**
  * Merge BridgeKit's caller into the invocation metadata for retry operations.
@@ -26683,7 +26951,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
         this.disableErrorReporting = config.disableErrorReporting === true;
         this.telemetryConfig = {
             sdkName: SDK_NAME,
-            sdkVersion: pkg$3.version,
+            sdkVersion: pkg$4.version,
             disabled: this.disableErrorReporting
         };
         for (const provider of this.providers){
@@ -27407,7 +27675,7 @@ async function resolveExecutionQuote(binding, suppliedQuote, refundAddress) {
 }
 
 // Auto-register this kit for user agent tracking
-registerKit(`${pkg$3.name}/${pkg$3.version}`);
+registerKit(`${pkg$4.name}/${pkg$4.version}`);
 
 /**
  * Create a BridgeKit instance with optional developer fee configuration.
@@ -27478,11 +27746,11 @@ registerKit(`${pkg$3.name}/${pkg$3.version}`);
     return kit;
 };
 
-var name$1 = "@circle-fin/swap-kit";
-var version$1 = "1.7.0";
-var pkg$1 = {
-	name: name$1,
-	version: version$1};
+var name$2 = "@circle-fin/swap-kit";
+var version$2 = "1.8.0";
+var pkg$2 = {
+	name: name$2,
+	version: version$2};
 
 const chainIdentifierField = zod.z.custom((value)=>chainIdentifierSchema.safeParse(value).success, {
     message: 'chain must be a valid chain identifier'
@@ -27563,7 +27831,7 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
  *
  * @remarks
  * Optionally includes address for developer-controlled adapters.
- */ const adapterContextSchema$2 = zod.z.object({
+ */ const adapterContextSchema$3 = zod.z.object({
     adapter: adapterSchema,
     chain: chainIdentifierField,
     address: zod.z.string().optional()
@@ -27584,7 +27852,7 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
  * }
  * ```
  */ zod.z.object({
-    from: adapterContextSchema$2,
+    from: adapterContextSchema$3,
     tokenIn: zod.z.string({
         required_error: 'tokenIn is required',
         invalid_type_error: 'tokenIn must be a string'
@@ -27822,25 +28090,83 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
     message: 'fee amount must be non-negative (>= 0)'
 });
 /**
- * Zod schema for validating API keys.
- *
- * Accepts a Circle platform API key (`<ENV>_API_KEY:<keyId>:<keySecret>`) and
- * the legacy kit key (`KIT_KEY:<keyId>:<keySecret>`).
- *
- * @example
- * ```typescript
- * import { apiKeySchema } from '@core/service-client'
- *
- * const result = apiKeySchema.safeParse('TEST_API_KEY:e84d2546d4e321b2ff427dc988c89503:f84d2548d4e322b2ff427fc989c87503')
- * if (!result.success) {
- *   console.error('Invalid API key format:', result.error.issues)
- * }
- * ```
- */ const apiKeySchema = zod.z.string({
-    required_error: 'API key is required',
-    invalid_type_error: 'Invalid API key format'
-}).regex(API_KEY_PATTERN, 'Invalid API key format');
-/**
+ * Parses a display-only field leniently: a value `schema` rejects is replaced
+ * with `fallback` instead of failing the response that carries it.
+ * Implemented with `preprocess` rather than Zod's `.catch()` because static
+ * analysis misreads `.catch` on the schema chain as an unhandled Promise
+ * (S7785).
+ */ const withFallback = (schema, fallback)=>zod.z.preprocess((value)=>schema.safeParse(value).success ? value : fallback, schema);
+const swapRouteTokenSchema = zod.z.object({
+    symbol: zod.z.string(),
+    address: zod.z.string(),
+    decimals: zod.z.number()
+});
+const swapRouteMetadataSchema = zod.z.record(zod.z.unknown()).optional();
+const swapRouteStepSchema = zod.z.object({
+    type: zod.z.string(),
+    tool: zod.z.string(),
+    toolName: zod.z.string(),
+    fromToken: swapRouteTokenSchema,
+    toToken: swapRouteTokenSchema,
+    estimate: zod.z.object({
+        fromAmount: zod.z.string(),
+        toAmount: zod.z.string(),
+        gasCostUSD: zod.z.string().optional()
+    }),
+    metadata: swapRouteMetadataSchema
+});
+/**
+ * Strict schema for a `SwapRoute`. Module-private: service responses
+ * parse routes leniently through {@link responseSwapRouteSchema}.
+ */ const swapRouteSchema = zod.z.object({
+    provider: zod.z.string().min(1, 'provider must be a non-empty string'),
+    steps: zod.z.array(swapRouteStepSchema),
+    metadata: swapRouteMetadataSchema
+});
+/**
+ * Route details are display-only, so service responses parse them leniently:
+ * steps or metadata in a shape the SDK does not know are dropped rather than
+ * failing the quote or swap they describe. Steps are all-or-nothing: if any
+ * step is malformed, `steps` is empty, so a route never silently loses a hop.
+ */ const responseSwapRouteSchema = swapRouteSchema.extend({
+    steps: withFallback(swapRouteSchema.shape.steps, []),
+    metadata: withFallback(swapRouteMetadataSchema, undefined)
+});
+const createSwapFeeItemSchema = zod.z.object({
+    token: zod.z.string({
+        required_error: 'fee token is required',
+        invalid_type_error: 'fee token must be a string'
+    }).min(1, 'fee token must be a non-empty string'),
+    amount: feeAmountSchema,
+    decimals: zod.z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
+    symbol: zod.z.string({
+        invalid_type_error: 'fee token symbol must be a string'
+    }).min(1, 'fee token symbol must be a non-empty string').optional(),
+    // Descriptive metadata: a value the SDK cannot use is dropped rather than
+    // failing the response that carries the fee.
+    type: withFallback(zod.z.string().min(1).optional(), undefined),
+    chain: withFallback(zod.z.string().min(1).optional(), undefined)
+});
+/**
+ * Zod schema for validating API keys.
+ *
+ * Accepts a Circle platform API key (`<ENV>_API_KEY:<keyId>:<keySecret>`) and
+ * the legacy kit key (`KIT_KEY:<keyId>:<keySecret>`).
+ *
+ * @example
+ * ```typescript
+ * import { apiKeySchema } from '@core/service-client'
+ *
+ * const result = apiKeySchema.safeParse('TEST_API_KEY:e84d2546d4e321b2ff427dc988c89503:f84d2548d4e322b2ff427fc989c87503')
+ * if (!result.success) {
+ *   console.error('Invalid API key format:', result.error.issues)
+ * }
+ * ```
+ */ const apiKeySchema = zod.z.string({
+    required_error: 'API key is required',
+    invalid_type_error: 'Invalid API key format'
+}).regex(API_KEY_PATTERN, 'Invalid API key format');
+/**
  * Zod schema for platform fees configuration.
  *
  * Validates the fees object for swap quotes.
@@ -27906,10 +28232,7 @@ const optionalChainIdentifierField = chainIdentifierField.optional();
     /** Quote information with estimated amounts and route */ quote: zod.z.object({
         /** Estimated output amount (base units) */ estimatedAmount: zod.z.string().min(1, 'estimatedAmount must be a non-empty string').regex(/^\d+$/, 'estimatedAmount must be a numeric string'),
         /** Guaranteed minimum output amount (base units) */ minAmount: zod.z.string().min(1, 'minAmount must be a non-empty string').regex(/^\d+$/, 'minAmount must be a numeric string'),
-        /** Route information from DEX aggregator */ route: zod.z.object({
-            provider: zod.z.string().min(1, 'provider must be a non-empty string'),
-            steps: zod.z.array(zod.z.unknown())
-        })
+        /** Route information from DEX aggregator */ route: responseSwapRouteSchema
     }),
     /** Fee context indicating where fees should be collected */ feeContext: quoteFeeContextSchema
 });
@@ -28125,19 +28448,6 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     }).min(1, 'toChain must be a non-empty string if provided').optional(),
     apiKey: apiKeySchema.optional()
 });
-/**
- * Zod schema for validating CreateSwapResponse payloads.
- */ const createSwapFeeItemSchema = zod.z.object({
-    token: zod.z.string({
-        required_error: 'fee token is required',
-        invalid_type_error: 'fee token must be a string'
-    }).min(1, 'fee token must be a non-empty string'),
-    amount: feeAmountSchema,
-    decimals: zod.z.number().int('fee token decimals must be an integer').nonnegative('fee token decimals must be a non-negative integer').optional(),
-    symbol: zod.z.string({
-        invalid_type_error: 'fee token symbol must be a string'
-    }).min(1, 'fee token symbol must be a non-empty string').optional()
-});
 /**
  * Developer fee item schema with basis field.
  */ const createSwapDeveloperFeeItemSchema = createSwapFeeItemSchema.extend({
@@ -28275,6 +28585,8 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     correlationId: zod.z.preprocess((value)=>zod.z.string().uuid().safeParse(value).success ? value : undefined, zod.z.string().optional()),
     config: createSwapRequestBaseSchema.shape.config.optional(),
     fees: createSwapFeesSchema.optional(),
+    // A route the SDK cannot parse is dropped instead of failing the swap.
+    route: withFallback(responseSwapRouteSchema.optional(), undefined),
     transaction: createSwapTransactionSchema
 });
 
@@ -28312,6 +28624,146 @@ getQuoteRequestBaseSchema.superRefine(requireCrossChainQuoteToAddress);
     return normalize(source.apiKey) ?? normalize(source.kitKey);
 };
 
+function isBigIntLike$1(value) {
+    try {
+        BigInt(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function isNonNegativeBigIntLike$3(value) {
+    try {
+        return BigInt(value) >= 0n;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * A `0x`-prefixed, even-length hex byte string (`'0x'` for empty calldata).
+ *
+ * @internal
+ */ const hexBytesSchema$3 = zod.z.union([
+    hexStringSchema,
+    zod.z.literal('0x')
+]).refine((value)=>value.length % 2 === 0, {
+    message: 'value must be a 0x-prefixed even-length hex string'
+});
+/**
+ * A non-negative uint256, accepted as a decimal string or a `bigint`.
+ *
+ * @internal
+ */ const uint256LikeSchema$3 = zod.z.union([
+    zod.z.string(),
+    zod.z.bigint()
+]).refine(isNonNegativeBigIntLike$3, {
+    message: 'value must be a non-negative bigint-compatible string or bigint'
+});
+/**
+ * A typed base-unit amount object as emitted by the API.
+ *
+ * @internal
+ */ const amountJsonSchema$2 = zod.z.object({
+    raw: zod.z.string().refine(isBigIntLike$1, {
+        message: 'raw must be a bigint-compatible string'
+    }),
+    decimals: zod.z.number().int().nonnegative()
+});
+/**
+ * One instruction in a signed claim-rewards execution payload.
+ *
+ * `.passthrough()` so a backend that adds a field does not fail validation.
+ *
+ * @internal
+ */ const claimRewardsInstructionSchema = zod.z.object({
+    target: evmAddressSchema$1,
+    data: hexBytesSchema$3,
+    value: uint256LikeSchema$3,
+    tokenIn: evmAddressSchema$1,
+    amountToApprove: uint256LikeSchema$3,
+    tokenOut: evmAddressSchema$1,
+    minTokenOut: uint256LikeSchema$3
+}).passthrough();
+const claimRewardsTokenSchema = zod.z.object({
+    token: evmAddressSchema$1,
+    beneficiary: evmAddressSchema$1
+}).passthrough();
+/**
+ * The signed execution payload the `earn.claimRewards` Adapter action takes.
+ *
+ * @internal
+ */ const claimRewardsExecutionParamsSchema = zod.z.object({
+    instructions: zod.z.tuple([
+        claimRewardsInstructionSchema
+    ]).rest(claimRewardsInstructionSchema),
+    tokens: zod.z.tuple([
+        claimRewardsTokenSchema
+    ]).rest(claimRewardsTokenSchema),
+    execId: uint256LikeSchema$3,
+    deadline: uint256LikeSchema$3,
+    metadata: hexBytesSchema$3
+}).passthrough();
+/**
+ * A single claimable reward entry in a claim-rewards response.
+ *
+ * @internal
+ */ const claimedAmountSchema = zod.z.object({
+    token: evmAddressSchema$1,
+    symbol: zod.z.string(),
+    amount: amountJsonSchema$2
+});
+/**
+ * The `data` envelope of a claim-rewards response.
+ *
+ * `executionParams` and `signature` are present exactly when rewards are
+ * claimable — never one without the other, and never either when `rewards`
+ * is empty.
+ *
+ * @internal
+ */ const claimRewardsPayloadSchema = zod.z.object({
+    rewards: zod.z.array(claimedAmountSchema),
+    executionParams: claimRewardsExecutionParamsSchema.optional(),
+    signature: evmSignatureSchema.optional()
+}).refine((data)=>{
+    const signedFieldCount = (data.executionParams === undefined ? 0 : 1) + (data.signature === undefined ? 0 : 1);
+    if (data.rewards.length > 0) {
+        return signedFieldCount === 2;
+    }
+    return signedFieldCount === 0;
+}, {
+    message: 'claim rewards response must include executionParams and signature only when rewards are claimable'
+});
+/**
+ * Zod schema for a claim-rewards API response.
+ *
+ * @internal
+ */ zod.z.object({
+    data: claimRewardsPayloadSchema
+});
+/**
+ * A single claimable reward entry in a claim-rewards quote response.
+ *
+ * @internal
+ */ const claimRewardsQuoteRewardSchema = zod.z.object({
+    token: zod.z.string(),
+    symbol: zod.z.string(),
+    amount: amountJsonSchema$2
+});
+/**
+ * The `data` envelope of a claim-rewards quote response.
+ *
+ * @internal
+ */ const claimRewardsQuotePayloadSchema = zod.z.object({
+    rewards: zod.z.array(claimRewardsQuoteRewardSchema)
+});
+/**
+ * Zod schema for a claim-rewards quote API response.
+ *
+ * @internal
+ */ zod.z.object({
+    data: claimRewardsQuotePayloadSchema
+});
+
 /**
  * Zod schema for validating EVM adapter capabilities.
  *
@@ -28739,7 +29191,7 @@ const abiParameterSchema = zod.z.object({
  * const result = evmPreparedChainRequestParamsSchema.safeParse(params)
  * ```
  */ zod.z.object({
-    type: zod.z.literal('evm'),
+    type: zod.z.literal('evm').optional(),
     abi: abiSchema,
     address: evmAddressSchema$1,
     functionName: zod.z.string({
@@ -28856,7 +29308,7 @@ const abiParameterSchema = zod.z.object({
     message: 'Private key must be a valid 64-character hex string. Please provide a valid private key with or without "0x" prefix.'
 }));
 
-const hexBytesSchema$1 = zod.z.string().regex(/^0x([0-9a-fA-F]{2})*$/, {
+const hexBytesSchema$2 = zod.z.string().regex(/^0x([0-9a-fA-F]{2})*$/, {
     message: 'value must be a 0x-prefixed even-length hex string'
 }).transform((value)=>value);
 zod.z.object({
@@ -28868,6 +29320,53 @@ zod.z.object({
         amount: zod.z.bigint().refine((value)=>value >= 0n, {
             message: 'amount must be a non-negative bigint'
         }),
+        permitCalldata: hexBytesSchema$2
+    }))
+}).passthrough();
+
+const hexBytesSchema$1 = zod.z.string().regex(/^0x([0-9a-fA-F]{2})*$/, {
+    message: 'value must be a 0x-prefixed even-length hex string'
+}).transform((value)=>value);
+function isNonNegativeBigIntLike$2(value) {
+    try {
+        return BigInt(value) >= 0n;
+    } catch  {
+        return false;
+    }
+}
+const uint256LikeSchema$2 = zod.z.union([
+    zod.z.string(),
+    zod.z.bigint()
+]).refine(isNonNegativeBigIntLike$2, {
+    message: 'value must be a non-negative bigint-compatible string or bigint'
+});
+const borrowExecutionParamsSchema$1 = zod.z.object({
+    instructions: zod.z.array(zod.z.object({
+        target: evmAddressSchema$1,
+        data: hexBytesSchema$1,
+        value: uint256LikeSchema$2,
+        tokenIn: evmAddressSchema$1,
+        amountToApprove: uint256LikeSchema$2,
+        tokenOut: evmAddressSchema$1,
+        minTokenOut: uint256LikeSchema$2
+    }).passthrough()).min(1),
+    tokens: zod.z.array(zod.z.object({
+        token: evmAddressSchema$1,
+        beneficiary: evmAddressSchema$1
+    }).passthrough()),
+    execId: uint256LikeSchema$2,
+    deadline: uint256LikeSchema$2,
+    metadata: hexBytesSchema$1
+}).passthrough();
+zod.z.object({
+    executeParams: borrowExecutionParamsSchema$1,
+    signature: evmSignatureSchema,
+    tokenInputs: zod.z.array(zod.z.object({
+        permitType: zod.z.nativeEnum(BorrowPermitType),
+        token: evmAddressSchema$1,
+        amount: zod.z.bigint().refine((value)=>value >= 0n, {
+            message: 'amount must be a non-negative bigint'
+        }),
         permitCalldata: hexBytesSchema$1
     }))
 }).passthrough();
@@ -29215,6 +29714,16 @@ createTokenRegistry();
         name: 'USDC',
         version: '2'
     },
+    Cronos: {
+        chainId: Cronos.chainId,
+        name: 'USDC',
+        version: '2'
+    },
+    Morph: {
+        chainId: Morph.chainId,
+        name: 'USDC',
+        version: '2'
+    },
     Arc_Testnet: {
         chainId: ArcTestnet.chainId,
         name: 'USDC',
@@ -29260,7 +29769,7 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
  * Schema for validating AdapterContext.
  * Must always contain both adapter and chain explicitly.
  * Optionally includes address for developer-controlled adapters.
- */ const adapterContextSchema$1 = zod.z.object({
+ */ const adapterContextSchema$2 = zod.z.object({
     adapter: adapterSchema,
     chain: swapChainIdentifierField,
     address: zod.z.string().optional()
@@ -29303,6 +29812,7 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
  * - customFee: Optional fee configuration
  * - apiKey: Optional credential string
  * - kitKey: Optional credential string (deprecated alias for apiKey)
+ * - batchTransactions: Optional boolean to opt out of atomic batching
  */ const swapConfigSchema = zod.z.object({
     allowanceStrategy: allowanceStrategySchema.optional(),
     slippageBps: zod.z.number().int().min(0).optional(),
@@ -29313,7 +29823,10 @@ const optionalSwapChainIdentifierField = swapChainIdentifierField.optional();
     })(zod.z.string())).optional(),
     customFee: swapCustomFeeSchema.optional(),
     apiKey: zod.z.string().optional(),
-    kitKey: zod.z.string().optional()
+    kitKey: zod.z.string().optional(),
+    batchTransactions: zod.z.boolean({
+        invalid_type_error: 'batchTransactions must be a boolean'
+    }).optional()
 });
 const swapDestinationSchema = zod.z.object({
     chain: optionalSwapChainIdentifierField,
@@ -29321,7 +29834,7 @@ const swapDestinationSchema = zod.z.object({
         message: 'recipientAddress must be a valid blockchain address: EVM (0x + 40 hex chars) or Solana (base58, 32-44 chars)'
     }).optional()
 }).strict();
-const EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+const EVM_ADDRESS_REGEX$1 = /^0x[a-fA-F0-9]{40}$/;
 const SOLANA_ADDRESS_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 const BASE58_CHARS_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
 /**
@@ -29364,7 +29877,7 @@ const MAX_DISPLAY_LENGTH = 30;
  */ let _symbolResult;
 const swapTokenSchema = zod.z.string().superRefine((value, ctx)=>{
     if (value.startsWith('0x')) {
-        if (!EVM_ADDRESS_REGEX.test(value)) {
+        if (!EVM_ADDRESS_REGEX$1.test(value)) {
             ctx.addIssue({
                 code: zod.z.ZodIssueCode.custom,
                 message: `Invalid EVM token address format. Expected '0x' followed by 40 hexadecimal characters, but received: '${truncate(value)}'`
@@ -29459,7 +29972,7 @@ const amountInSchema = zod.z.string().min(1, 'Required').pipe(createDecimalStrin
  * }
  * ```
  */ zod.z.object({
-    from: adapterContextSchema$1,
+    from: adapterContextSchema$2,
     tokenIn: swapTokenSchema,
     tokenOut: swapTokenSchema,
     amountIn: amountInSchema,
@@ -29500,16 +30013,16 @@ new Set(Object.values(Blockchain));
 
 new Set(Object.values(Blockchain));
 
-/** SDK name used in telemetry payloads. */ resolveKitSdkName(pkg$1.name);
+/** SDK name used in telemetry payloads. */ resolveKitSdkName(pkg$2.name);
 
 // Auto-register this kit for user agent tracking
-registerKit(`${pkg$1.name}/${pkg$1.version}`);
+registerKit(`${pkg$2.name}/${pkg$2.version}`);
 
-var name = "@circle-fin/earn-kit";
-var version = "1.8.0";
-var pkg = {
-	name: name,
-	version: version};
+var name$1 = "@circle-fin/earn-kit";
+var version$1 = "1.9.0";
+var pkg$1 = {
+	name: name$1,
+	version: version$1};
 
 /**
  * Map SDK chain identifiers to bridge API chain strings.
@@ -29581,7 +30094,7 @@ function isBigIntLike(value) {
         return false;
     }
 }
-function isNonNegativeBigIntLike(value) {
+function isNonNegativeBigIntLike$1(value) {
     try {
         return BigInt(value) >= 0n;
     } catch  {
@@ -29601,28 +30114,22 @@ const bridgeFeeTokenSchema = hexAddressSchema;
  * unchanged so signed execution params can be forwarded verbatim.
  *
  * @internal
- */ const uint256LikeSchema = zod.z.union([
+ */ const uint256LikeSchema$1 = zod.z.union([
     zod.z.string(),
     zod.z.bigint()
-]).refine(isNonNegativeBigIntLike, {
+]).refine(isNonNegativeBigIntLike$1, {
     message: 'value must be a non-negative bigint-compatible string or bigint'
 });
 /**
  * Zod schema for typed amount objects emitted by the API.
  *
  * @internal
- */ const amountJsonSchema = zod.z.object({
+ */ const amountJsonSchema$1 = zod.z.object({
     raw: zod.z.string().refine(isBigIntLike, {
         message: 'raw must be a bigint-compatible string'
     }),
     decimals: zod.z.number().int().nonnegative()
 });
-/** @internal */ const hexBytesSchema = zod.z.union([
-    hexStringSchema,
-    zod.z.literal('0x')
-]).refine((value)=>value.length % 2 === 0, {
-    message: 'value must be a 0x-prefixed even-length hex string'
-});
 /** @internal */ const bytes32HexSchema = hexStringSchema.refine((value)=>value.length === BYTES32_HEX_LENGTH, {
     message: 'value must be a 0x-prefixed 32-byte hex string'
 });
@@ -29706,9 +30213,9 @@ const bridgeFeeTokenSchema = hexAddressSchema;
  *
  * @internal
  */ const liquidityProfileSchema = zod.z.object({
-    totalDeposits: amountJsonSchema,
-    available: amountJsonSchema,
-    totalSupply: amountJsonSchema,
+    totalDeposits: amountJsonSchema$1,
+    available: amountJsonSchema$1,
+    totalSupply: amountJsonSchema$1,
     status: zod.z.enum([
         'active',
         'low_liquidity'
@@ -29745,8 +30252,8 @@ const bridgeFeeTokenSchema = hexAddressSchema;
     vaultFee: zod.z.number(),
     rewards: zod.z.array(vaultRewardSchema),
     collateral: zod.z.array(collateralSchema),
-    totalDeposits: amountJsonSchema,
-    liquidity: amountJsonSchema,
+    totalDeposits: amountJsonSchema$1,
+    liquidity: amountJsonSchema$1,
     status: zod.z.enum([
         'active',
         'low_liquidity'
@@ -29856,13 +30363,13 @@ const bridgeFeeTokenSchema = hexAddressSchema;
  */ const accruedRewardSchema = zod.z.object({
     token: zod.z.string(),
     symbol: zod.z.string(),
-    amount: amountJsonSchema
+    amount: amountJsonSchema$1
 });
 const positionPnlSchema = zod.z.discriminatedUnion('status', [
     zod.z.object({
         status: zod.z.literal('available'),
-        principalDeposited: amountJsonSchema,
-        totalYieldEarned: amountJsonSchema
+        principalDeposited: amountJsonSchema$1,
+        totalYieldEarned: amountJsonSchema$1
     }),
     zod.z.object({
         status: zod.z.literal('pending')
@@ -29882,9 +30389,9 @@ const positionPnlSchema = zod.z.discriminatedUnion('status', [
     vaultAddress: zod.z.string(),
     vaultName: zod.z.string(),
     asset: zod.z.string(),
-    currentBalance: amountJsonSchema,
+    currentBalance: amountJsonSchema$1,
     currentApy: zod.z.number(),
-    shares: amountJsonSchema,
+    shares: amountJsonSchema$1,
     pnl: positionPnlSchema,
     accruedRewards: zod.z.array(accruedRewardSchema).optional(),
     rewardsUnavailableReason: zod.z.string().optional()
@@ -29912,7 +30419,7 @@ const positionPnlSchema = zod.z.discriminatedUnion('status', [
  * @internal
  */ const earnInstructionSchema = zod.z.object({
     tokenIn: hexAddressSchema,
-    amountToApprove: uint256LikeSchema
+    amountToApprove: uint256LikeSchema$1
 }).passthrough();
 /**
  * Zod schema for earn execution params returned by the earn service.
@@ -29926,50 +30433,10 @@ const positionPnlSchema = zod.z.discriminatedUnion('status', [
     instructions: zod.z.tuple([
         earnInstructionSchema
     ]).rest(earnInstructionSchema),
-    deadline: uint256LikeSchema
+    deadline: uint256LikeSchema$1
 }).passthrough();
 /** @internal */ const depositExecutionParamsSchema = earnExecutionParamsSchema;
 /** @internal */ const withdrawExecutionParamsSchema = earnExecutionParamsSchema;
-/**
- * Zod schema for the claim rewards instruction fields that must be safe to
- * ABI-encode.
- *
- * Claim rewards has no approval preflight, so this validates the forwarded
- * signed payload at the provider boundary. Additional instruction fields are
- * accepted and preserved.
- *
- * @internal
- */ const claimRewardsInstructionSchema = zod.z.object({
-    target: hexAddressSchema,
-    data: hexBytesSchema,
-    value: uint256LikeSchema,
-    tokenIn: hexAddressSchema,
-    amountToApprove: uint256LikeSchema,
-    tokenOut: hexAddressSchema,
-    minTokenOut: uint256LikeSchema
-}).passthrough();
-/** @internal */ const claimRewardsTokenSchema = zod.z.object({
-    token: hexAddressSchema,
-    beneficiary: hexAddressSchema
-}).passthrough();
-/**
- * Zod schema for signed claim rewards execution params.
- *
- * This enforces the required envelope and preserves additive fields so the
- * adapter receives the signed params verbatim.
- *
- * @internal
- */ const claimRewardsExecutionParamsSchema = zod.z.object({
-    instructions: zod.z.tuple([
-        claimRewardsInstructionSchema
-    ]).rest(claimRewardsInstructionSchema),
-    tokens: zod.z.tuple([
-        claimRewardsTokenSchema
-    ]).rest(claimRewardsTokenSchema),
-    execId: uint256LikeSchema,
-    deadline: uint256LikeSchema,
-    metadata: hexBytesSchema
-}).passthrough();
 /**
  * Zod schema for the deposit payload inside the API `data` envelope.
  *
@@ -30028,9 +30495,9 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
     message: zod.z.object({
         from: hexAddressSchema,
         to: hexAddressSchema,
-        value: uint256LikeSchema,
-        validAfter: uint256LikeSchema,
-        validBefore: uint256LikeSchema,
+        value: uint256LikeSchema$1,
+        validAfter: uint256LikeSchema$1,
+        validBefore: uint256LikeSchema$1,
         nonce: bytes32HexSchema
     }).passthrough()
 }).passthrough();
@@ -30048,7 +30515,7 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
     feeToken: bridgeFeeTokenSchema,
     items: zod.z.array(zod.z.object({
         type: zod.z.string(),
-        amount: uint256LikeSchema
+        amount: uint256LikeSchema$1
     }).passthrough())
 }).passthrough();
 /**
@@ -30064,7 +30531,7 @@ const eip712DomainSchema = eip712DomainSchema$1.extend({
 const bridgeDepositPrepareReviewSchema = zod.z.object({
     sourceChain: zod.z.string(),
     destinationChain: zod.z.string(),
-    amount: amountJsonSchema,
+    amount: amountJsonSchema$1,
     vaultAddress: hexAddressSchema
 }).passthrough();
 /** @internal */ const bridgeQuoteExpirySchema = zod.z.discriminatedUnion('mode', [
@@ -30199,72 +30666,34 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
 // ---------------------------------------------------------------------------
 // Claim rewards response schema
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Deposit quote response schema
+// ---------------------------------------------------------------------------
 /**
- * Zod schema for a claimed reward amount in the API response.
+ * Zod schema for a fee entry in an EarnKit API response.
+ *
+ * Shared across deposit and withdrawal responses (and reusable for real
+ * charged fees, not just quote estimates). `type` identifies the fee category.
+ * For cross-chain deposit quotes this is the kits-proxy fee-quote item type
+ * (e.g. `'FORWARD'`, `'PRE_FINALITY'`). For withdrawal quotes, Circle fees use
+ * `type: 'circle'`. `status` qualifies the fee (e.g. `'estimated'` for a
+ * pre-sign cross-chain fee). Both are omitted on plain fees.
  *
  * @internal
- */ const claimedAmountSchema = zod.z.object({
-    token: hexAddressSchema,
-    symbol: zod.z.string(),
-    amount: amountJsonSchema
+ */ const feeSchema = zod.z.object({
+    type: zod.z.string().optional(),
+    status: zod.z.string().optional(),
+    token: zod.z.string(),
+    amount: amountJsonSchema$1
 });
 /**
- * Zod schema for the claim rewards payload inside the API `data` envelope.
+ * Zod schema for a native gas-fee entry in an EarnKit quote response.
  *
- * Enforce that `executionParams` and `signature` are either both
- * present (claimable rewards) or both absent (nothing to claim).
- *
- * @internal
- */ const claimRewardsPayloadSchema = zod.z.object({
-    rewards: zod.z.array(claimedAmountSchema),
-    executionParams: claimRewardsExecutionParamsSchema.optional(),
-    signature: hexSignatureSchema.optional()
-}).refine((data)=>{
-    const signedFieldCount = (data.executionParams === undefined ? 0 : 1) + (data.signature === undefined ? 0 : 1);
-    if (data.rewards.length > 0) {
-        return signedFieldCount === 2;
-    }
-    return signedFieldCount === 0;
-}, {
-    message: 'claim rewards response must include executionParams and signature only when rewards are claimable'
-});
-/**
- * Zod schema for the `POST /v1/earnKit/claimRewards` API response.
- *
- * The Earn Service API wraps the claim rewards payload in a `data` envelope.
- *
- * @internal
- */ zod.z.object({
-    data: claimRewardsPayloadSchema
-});
-// ---------------------------------------------------------------------------
-// Deposit quote response schema
-// ---------------------------------------------------------------------------
-/**
- * Zod schema for a fee entry in an EarnKit API response.
- *
- * Shared across deposit and withdrawal responses (and reusable for real
- * charged fees, not just quote estimates). `type` identifies the fee category.
- * For cross-chain deposit quotes this is the kits-proxy fee-quote item type
- * (e.g. `'FORWARD'`, `'PRE_FINALITY'`). For withdrawal quotes, Circle fees use
- * `type: 'circle'`. `status` qualifies the fee (e.g. `'estimated'` for a
- * pre-sign cross-chain fee). Both are omitted on plain fees.
- *
- * @internal
- */ const feeSchema = zod.z.object({
-    type: zod.z.string().optional(),
-    status: zod.z.string().optional(),
-    token: zod.z.string(),
-    amount: amountJsonSchema
-});
-/**
- * Zod schema for a native gas-fee entry in an EarnKit quote response.
- *
- * The Earn Service backend estimates gas server-side and returns one entry per
- * action (`Approve`, `Deposit`, `Withdraw`). A successful estimate carries
- * `fees` in the SDK `EstimatedGas` shape (`{ gas, gasPrice, fee }`), each a raw
- * integer string in the chain's native base units. When the backend cannot
- * estimate an action it returns `fees: null` with an `error` message instead.
+ * The Earn Service backend estimates gas server-side and returns one entry per
+ * action (`Approve`, `Deposit`, `Withdraw`). A successful estimate carries
+ * `fees` in the SDK `EstimatedGas` shape (`{ gas, gasPrice, fee }`), each a raw
+ * integer string in the chain's native base units. When the backend cannot
+ * estimate an action it returns `fees: null` with an `error` message instead.
  *
  * The schema deliberately validates almost nothing beyond the envelope: `name`
  * is optional and `fees` is entirely unvalidated (`unknown`). ALL validation
@@ -30292,8 +30721,8 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
     vaultAddress: zod.z.string(),
     vaultName: zod.z.string(),
     asset: zod.z.string(),
-    depositAmount: amountJsonSchema,
-    expectedShares: amountJsonSchema,
+    depositAmount: amountJsonSchema$1,
+    expectedShares: amountJsonSchema$1,
     sharePrice: zod.z.string(),
     currentApy: zod.z.number(),
     fees: zod.z.array(feeSchema).optional(),
@@ -30319,10 +30748,10 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
     vaultAddress: zod.z.string(),
     vaultName: zod.z.string(),
     asset: zod.z.string(),
-    withdrawAmount: amountJsonSchema,
-    sharesToRedeem: amountJsonSchema,
+    withdrawAmount: amountJsonSchema$1,
+    sharesToRedeem: amountJsonSchema$1,
     sharePrice: zod.z.string(),
-    maxWithdrawable: amountJsonSchema,
+    maxWithdrawable: amountJsonSchema$1,
     fees: zod.z.array(feeSchema),
     gasFees: zod.z.array(quoteGasFeeSchema).optional(),
     warnings: zod.z.array(zod.z.string()).optional()
@@ -30339,31 +30768,6 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
 // ---------------------------------------------------------------------------
 // Claim rewards quote response schema
 // ---------------------------------------------------------------------------
-/**
- * Zod schema for a reward in the claim rewards quote response.
- *
- * @internal
- */ const claimRewardsQuoteRewardSchema = zod.z.object({
-    token: zod.z.string(),
-    symbol: zod.z.string(),
-    amount: amountJsonSchema
-});
-/**
- * Zod schema for the inner claim rewards quote payload.
- *
- * @internal
- */ const claimRewardsQuotePayloadSchema = zod.z.object({
-    rewards: zod.z.array(claimRewardsQuoteRewardSchema)
-});
-/**
- * Zod schema for the `POST /v1/earnKit/claimRewards/quote` API response.
- *
- * The API wraps the payload in a `data` envelope.
- *
- * @internal
- */ zod.z.object({
-    data: claimRewardsQuotePayloadSchema
-});
 // ---------------------------------------------------------------------------
 // Batch vault response schema
 // ---------------------------------------------------------------------------
@@ -30503,7 +30907,7 @@ createTokenRegistry();
  * fast instead of being silently stripped.
  *
  * @internal
- */ const adapterContextSchema = zod.z.object({
+ */ const adapterContextSchema$1 = zod.z.object({
     adapter: adapterSchema,
     // AdapterContext accepts a wider chain field, but runtime validation must
     // stay constrained to EarnChain identifiers.
@@ -30735,7 +31139,7 @@ const sourceAdapterContextSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     config: earnConfigSchema.optional()
 });
@@ -30790,7 +31194,7 @@ const sourceAdapterContextSchema = zod.z.object({
  *
  * @internal Exported for branch-targeted validation in the deposit operation.
  */ const sameChainDepositParamsSchema = zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     to: zod.z.undefined().optional(),
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
@@ -30861,7 +31265,7 @@ const crossChainDepositDestinationSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -30915,7 +31319,7 @@ const crossChainDepositDestinationSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -30935,12 +31339,12 @@ const crossChainDepositDestinationSchema = zod.z.object({
  *
  * @internal
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     config: earnConfigSchema.optional()
 });
 const sameChainGetDepositQuoteParamsSchema = zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -31024,7 +31428,7 @@ function hasCrossChainDepositQuoteShape(params) {
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -31044,11 +31448,1363 @@ function hasCrossChainDepositQuoteShape(params) {
  *
  * @internal
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     config: earnConfigSchema.optional()
 });
 
+/** SDK name used in telemetry payloads. */ resolveKitSdkName(pkg$1.name);
+
+// Auto-register this kit for user agent tracking
+registerKit(`${pkg$1.name}/${pkg$1.version}`);
+
+var name = "@circle-fin/borrow-kit";
+var version = "1.1.0";
+var pkg = {
+	name: name,
+	version: version};
+
+const HUMAN_READABLE_AMOUNT_REGEX$1 = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+const EVM_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+const POSITIVE_USDC_AMOUNT_REGEX = /^(?:0|[1-9]\d*)(?:\.\d{1,6})?$/;
+/**
+ * True when `value` parses as a URL whose scheme is exactly `https:`.
+ *
+ * Uses the WHATWG `URL` parser rather than `startsWith('https://')` so the
+ * check is scheme-normalized (case-insensitive, e.g. `HTTPS://...` still
+ * passes) instead of a literal prefix match. `value` has already passed
+ * `z.string().url()` by the time this runs, but a caller could still supply
+ * a string that `URL` itself rejects, so the parse is guarded.
+ */ function isHttpsUrl$1(value) {
+    try {
+        return new URL(value).protocol === 'https:';
+    } catch  {
+        return false;
+    }
+}
+const borrowServiceConfigSchema$1 = zod.z.object({
+    apiKey: zod.z.string().optional(),
+    baseUrl: zod.z.string().url().optional()
+}).strict();
+/** Loan asset amounts are USDC, so they carry at most 6 decimal places. */ function positiveLoanAssetAmountSchema(field) {
+    return zod.z.string().regex(POSITIVE_USDC_AMOUNT_REGEX, `${field} must be a canonical decimal with at most 6 decimal places`).refine((value)=>/[1-9]/.test(value), {
+        message: `${field} must be greater than zero`
+    });
+}
+/**
+ * Collateral amounts denominate an arbitrary token, so the decimal count is the
+ * token's rather than USDC's — a satoshi-precision collateral is valid.
+ */ function positiveCollateralAmountSchema(field) {
+    return zod.z.string().regex(HUMAN_READABLE_AMOUNT_REGEX$1, `${field} must be a canonical decimal`).refine((value)=>/[1-9]/.test(value), {
+        message: `${field} must be greater than zero`
+    });
+}
+/** @internal */ zod.z.object({
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ zod.z.object({
+    walletAddress: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    chain: chainIdentifierSchema,
+    pageSize: zod.z.number().int().positive().optional(),
+    pageAfter: zod.z.string().min(1).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ const marketSortBySchema$1 = zod.z.enum([
+    'lltv',
+    'borrowApy'
+]);
+/** @internal */ const decimalFilterSchema$1 = zod.z.string().regex(/^\d+(\.\d+)?$/, 'filter thresholds must be non-negative decimal strings');
+/**
+ * Provider-level runtime schema for {@link ExploreMarketsServiceParams}.
+ *
+ * Mirrors the kit's `exploreMarketsParamsSchema` at the provider boundary so a
+ * plain-JS caller invoking `BorrowServiceProvider.exploreMarkets` directly is
+ * still validated before any filter reaches `url.searchParams` — including the
+ * kit's `minLltv <= maxLltv` / `minBorrow <= maxBorrow` range check, which
+ * otherwise lets an inverted range serialize into the request and return a
+ * silently empty page.
+ *
+ * @internal
+ */ zod.z.object({
+    chain: chainIdentifierSchema,
+    minLltv: decimalFilterSchema$1.optional(),
+    maxLltv: decimalFilterSchema$1.optional(),
+    minBorrow: decimalFilterSchema$1.optional(),
+    maxBorrow: decimalFilterSchema$1.optional(),
+    sortBy: marketSortBySchema$1.optional(),
+    pageSize: zod.z.number().int().min(1).max(1000).optional(),
+    pageAfter: zod.z.string().min(1).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict().superRefine((value, ctx)=>{
+    if (value.minLltv !== undefined && value.maxLltv !== undefined && Number(value.minLltv) > Number(value.maxLltv)) {
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            path: [
+                'maxLltv'
+            ],
+            message: 'maxLltv must be greater than or equal to minLltv'
+        });
+    }
+    if (value.minBorrow !== undefined && value.maxBorrow !== undefined && Number(value.minBorrow) > Number(value.maxBorrow)) {
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            path: [
+                'maxBorrow'
+            ],
+            message: 'maxBorrow must be greater than or equal to minBorrow'
+        });
+    }
+});
+/** @internal */ const repayQuoteServiceParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    repayAmount: positiveLoanAssetAmountSchema('repayAmount'),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ repayQuoteServiceParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: zod.z.string().uuid().optional()
+});
+/** @internal */ const closeLoanQuoteServiceParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** Fields a borrow carries whichever way it names its position. @internal */ const borrowServiceParamsBaseShape = {
+    loanAssetAmount: positiveLoanAssetAmountSchema('loanAssetAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    idempotencyKey: zod.z.string().uuid().optional(),
+    config: borrowServiceConfigSchema$1.optional()
+};
+/** A first-open: owner, chain and market are required together. @internal */ const openLoanServiceParamsSchema = zod.z.object({
+    ...borrowServiceParamsBaseShape,
+    walletAddress: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1)
+}).strict();
+/** A borrow-more: the loan is the only addressing field. @internal */ const borrowMoreServiceParamsSchema = zod.z.object({
+    ...borrowServiceParamsBaseShape,
+    loanId: zod.z.string().uuid()
+}).strict();
+/**
+ * The two ways a borrow names its position.
+ *
+ * A union of strict objects rather than one object with a refinement:
+ * `.strict()` is what rejects a mixed body, and the service refuses `loanId`
+ * next to any open-tuple field as well as an incomplete open tuple.
+ *
+ * @internal
+ */ zod.z.union([
+    openLoanServiceParamsSchema,
+    borrowMoreServiceParamsSchema
+]);
+/** A first-open quote carries the complete owner/chain/market tuple. @internal */ const openLoanQuoteServiceParamsSchema = zod.z.object({
+    walletAddress: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    loanAssetAmount: positiveLoanAssetAmountSchema('loanAssetAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** A borrow-more quote needs only the existing loan ID. @internal */ const borrowMoreQuoteServiceParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    loanAssetAmount: positiveLoanAssetAmountSchema('loanAssetAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ zod.z.union([
+    openLoanQuoteServiceParamsSchema,
+    borrowMoreQuoteServiceParamsSchema
+]);
+/** @internal */ zod.z.object({
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    loanAssetAmount: positiveLoanAssetAmountSchema('loanAssetAmount'),
+    // `.finite()` is load-bearing, not decoration: the value is encoded as a
+    // decimal string on the wire, and there is no decimal string for Infinity.
+    targetHealthFactor: zod.z.number().positive().finite(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ zod.z.object({
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    collateralAmount: positiveCollateralAmountSchema('collateralAmount'),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ closeLoanQuoteServiceParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: zod.z.string().uuid().optional()
+});
+/**
+ * Provider-level runtime schema for the non-adapter portion of
+ * {@link ClaimRewardsServiceParams} / {@link GetRewardsServiceParams}.
+ *
+ * `from` (the adapter context) is intentionally excluded — like
+ * `repay`/`closeLoan`, it is validated structurally by TypeScript and resolved
+ * via `resolveAdapterContext` rather than by a Zod schema, since it carries a
+ * live adapter instance rather than plain data. `config` is the only field
+ * that reaches the wire, so it is what gets validated here, matching every
+ * other provider method's independent `parseOrThrow` call.
+ *
+ * @internal
+ */ zod.z.object({
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/**
+ * Provider-level runtime schema for {@link GetPositionServiceParams}.
+ *
+ * @internal
+ */ zod.z.object({
+    loanId: zod.z.string().uuid(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ const withdrawCollateralQuoteServiceParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    // Carries no decimal-place cap: the repayment is USDC, but the collateral
+    // is the market's own token and may hold more precision than USDC's six.
+    collateralAmount: positiveCollateralAmountSchema('collateralAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ withdrawCollateralQuoteServiceParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: zod.z.string().uuid().optional()
+});
+/**
+ * Adding collateral sizes no second leg, so there is no slippage bound.
+ *
+ * @internal
+ */ const addCollateralQuoteServiceParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    collateralAmount: positiveCollateralAmountSchema('collateralAmount'),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/** @internal */ addCollateralQuoteServiceParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: zod.z.string().uuid().optional()
+});
+/** @internal */ const borrowAssetAmountSchema = zod.z.object({
+    token: zod.z.string().min(1),
+    tokenAddress: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    decimals: zod.z.number().int().min(0).max(255),
+    amount: zod.z.string().regex(HUMAN_READABLE_AMOUNT_REGEX$1)
+});
+/** @internal */ const healthFactorBandSchema = zod.z.enum([
+    'SAFE',
+    'WARN',
+    'URGENT',
+    'IMMINENT',
+    'LIQUIDATABLE'
+]);
+/**
+ * Whether a loan's economic projection has converged.
+ *
+ * `PENDING` means the loan's identity and lifecycle are known but its
+ * economics are not yet materialized — every economic field is `null` until
+ * the service's repair queue fills them in. See {@link loanSchema}.
+ *
+ * @internal
+ */ const loanDataStatusSchema = zod.z.enum([
+    'READY',
+    'PENDING'
+]);
+/**
+ * Lifecycle status of a loan: still open (`active`) or fully wound down
+ * (`closed`). Unlike {@link loanDataStatusSchema} this is not about whether
+ * economics have converged — a `closed` loan is `READY` with every economic
+ * field legitimately zeroed, not `null`. Shared by {@link loanSchema} and
+ * {@link loanPayloadSchema}, which return the same field for the same entity.
+ *
+ * @internal
+ */ const loanStatusSchema = zod.z.enum([
+    'active',
+    'closed'
+]);
+/**
+ * Zod schema for one loan in the `GET /v1/borrowKit/loans` page.
+ *
+ * @remarks Every economic field is nullable because the service returns a
+ * `PENDING` loan — identity and lifecycle fields set, all economics `null` —
+ * while materialization, principal, debt, or market APY is still converging.
+ * That is the documented representation of a freshly-created loan, so
+ * declaring these non-nullable made the first read after a `borrow()` fail
+ * validation. `dataStatus` tells callers which of the two shapes they hold.
+ *
+ * `status` distinguishes a fully wound-down loan — `READY` with legitimately
+ * zeroed economics — from a live one. Without it a caller cannot tell the two
+ * apart, which is what left a closed loan sitting in `getLoans` output looking
+ * open. It is declared **required here and on {@link loanPayloadSchema}**: a
+ * live `GET /v1/borrowKit/loans` page reports it on every loan, including a
+ * closed one.
+ *
+ * @internal
+ */ const loanSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: zod.z.string().min(1),
+    marketId: zod.z.string().min(1),
+    walletAddress: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    dataStatus: loanDataStatusSchema,
+    collateral: borrowAssetAmountSchema.nullable(),
+    borrowed: borrowAssetAmountSchema.nullable(),
+    principalBorrowed: borrowAssetAmountSchema.nullable(),
+    accruedInterest: borrowAssetAmountSchema.nullable(),
+    borrowApy: zod.z.number().nullable(),
+    ltv: zod.z.number().nullable(),
+    healthFactor: zod.z.number().nullable(),
+    healthFactorBand: healthFactorBandSchema.nullable(),
+    liquidationPrice: borrowAssetAmountSchema.nullable(),
+    status: loanStatusSchema
+});
+/**
+ * Zod schema for the `GET /v1/borrowKit/loans` API response. The Borrow
+ * Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        loans: zod.z.array(loanSchema),
+        pagination: zod.z.object({
+            pageAfter: zod.z.string().optional()
+        })
+    })
+});
+/** @internal */ const borrowFeeSchema = zod.z.object({
+    type: zod.z.string(),
+    token: zod.z.string(),
+    amount: borrowAssetAmountSchema
+});
+/** @internal */ const borrowQuoteGasFeeSchema = zod.z.object({
+    name: zod.z.string(),
+    fees: zod.z.object({
+        gas: zod.z.string(),
+        gasPrice: borrowAssetAmountSchema,
+        fee: borrowAssetAmountSchema
+    })
+});
+/** @internal */ const hexBytesSchema = zod.z.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/).transform((value)=>value);
+function isNonNegativeBigIntLike(value) {
+    try {
+        return BigInt(value) >= 0n;
+    } catch  {
+        return false;
+    }
+}
+/** @internal */ const uint256LikeSchema = zod.z.union([
+    zod.z.string(),
+    zod.z.bigint()
+]).refine(isNonNegativeBigIntLike, {
+    message: 'value must be a non-negative bigint-compatible string or bigint'
+});
+/**
+ * A quoted decimal that has to parse finite, for the response fields the
+ * service marshals from a Go `decimal.Decimal`.
+ *
+ * Deliberately not `z.coerce.number()`: coercion maps `''` and whitespace to
+ * `0`, so a service that stopped sending a value would read as a real `0.0` —
+ * a health factor of zero is a liquidated position, so that failure mode
+ * silently reports the opposite of the truth. Refusing anything unparseable
+ * here also makes the `decimalToNumber` mapper total, with no fallback value to
+ * invent downstream.
+ */ const decimalNumericString = zod.z.string().min(1).refine((value)=>value.trim() !== '' && Number.isFinite(Number(value)), {
+    message: 'value must be a decimal string that parses to a finite number'
+});
+/** @internal */ const borrowExecutionParamsSchema = zod.z.object({
+    instructions: zod.z.array(zod.z.object({
+        target: evmAddressSchema$1,
+        data: hexBytesSchema,
+        value: uint256LikeSchema,
+        tokenIn: evmAddressSchema$1,
+        amountToApprove: uint256LikeSchema,
+        tokenOut: evmAddressSchema$1,
+        minTokenOut: uint256LikeSchema
+    }).passthrough()).min(1),
+    tokens: zod.z.array(zod.z.object({
+        token: evmAddressSchema$1,
+        beneficiary: evmAddressSchema$1
+    }).passthrough()),
+    execId: uint256LikeSchema,
+    deadline: uint256LikeSchema,
+    metadata: hexBytesSchema
+}).passthrough();
+/**
+ * Inner payload for a Borrow Service execution response, shared by every
+ * write endpoint (`borrow`, `repay`, `addCollateral`, `closeLoan`,
+ * `withdrawCollateral`). Kept separate from {@link loanExecutionSchema} so
+ * {@link withdrawCollateralExecutionSchema} — the one execution response that
+ * omits `chain` — can build on it without re-declaring every field.
+ *
+ * @internal
+ */ const loanExecutionPayloadSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: zod.z.string().min(1),
+    execId: zod.z.string().min(1),
+    signature: evmSignatureSchema,
+    executionParams: borrowExecutionParamsSchema
+});
+/**
+ * Zod schema for a Borrow Service execution API response. The Borrow Service
+ * wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: loanExecutionPayloadSchema
+});
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/borrow` execution API
+ * response. Extends {@link loanExecutionPayloadSchema} with `fees`, the fee
+ * legs the signed bundle charges at origination (empty when nothing is
+ * charged) — a field only this endpoint's response carries.
+ *
+ * `fees` is optional here, and only here. The API spec documents it as always
+ * present and `[]` when nothing is charged, but the deployed service omits the
+ * key entirely; requiring it fails validation on a healthy `200` and turns
+ * every borrow into a FATAL error. It is optional rather than defaulted
+ * because the guard consuming this schema reports `safeParse().success` and
+ * discards the parsed value, so a default would never reach a reader.
+ *
+ * The absence is preserved to the caller rather than normalised to `[]`:
+ * `fetchBorrow` returns `response.data` unchanged and `BorrowResponse.fees` is
+ * optional, so "the service named no legs" stays distinguishable from "nothing
+ * was charged". `executeBorrow` is what resolves it, by reporting the fee
+ * transfers the receipt paid out under `type: 'unknown'`.
+ *
+ * @internal
+ */ zod.z.object({
+    data: loanExecutionPayloadSchema.extend({
+        fees: zod.z.array(borrowFeeSchema).optional()
+    })
+});
+/** @internal */ const resultingHealthSchema = {
+    resultingHealthFactor: zod.z.number().nullable(),
+    resultingLtv: zod.z.number().nullable(),
+    resultingBand: healthFactorBandSchema,
+    liquidationPrice: borrowAssetAmountSchema.nullable()
+};
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/:loan_id/repay/quote` API
+ * response. The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        repayAmount: borrowAssetAmountSchema,
+        fees: zod.z.array(borrowFeeSchema),
+        gasFees: zod.z.array(borrowQuoteGasFeeSchema),
+        ...resultingHealthSchema
+    })
+});
+// ---------------------------------------------------------------------------
+// Loan position response schema (SE-6383: getPosition)
+// ---------------------------------------------------------------------------
+/**
+ * Zod schema for the inner loan position payload.
+ *
+ * @remarks Matches the real `GET /v1/borrowKit/loans/:loan_id` wire shape
+ * (Zenith's `borrowkit.LoanResponse`). Two fields in the original placeholder
+ * did not exist on that contract and made every lookup of a real loan fail
+ * validation: the owner address is sent as `walletAddress`, not `wallet`, and
+ * the service sends no liquidation threshold at all — liquidation LTV is a
+ * market property, served by `GET /v1/borrowKit/markets/:chain/:market_id` as
+ * `lltv`, not a per-loan one.
+ *
+ * `collateral` and `borrowed` are nullable for the same reason they are on
+ * {@link loanSchema}: this route returns the same `PENDING` representation —
+ * null economics — for a loan whose on-chain create has not been observed
+ * yet, which is exactly the state a `borrow()` leaves behind. `dataStatus`
+ * distinguishes that from a `READY` loan whose economics happen to be zero.
+ *
+ * Declares the same economic field set as {@link loanSchema}, because Zenith
+ * serves both routes from one struct (`borrowkit.LoanResponse`): a loan read
+ * one at a time reports exactly what the same loan reports inside a page, so a
+ * caller never has to list a wallet to recover a field. Both declare `status`
+ * as required: a live `GET /v1/borrowKit/loans` page reports it on every loan,
+ * including a closed one.
+ *
+ * `registeredAt` is the sole field on the wire that neither schema declares.
+ *
+ * @internal
+ */ const loanPayloadSchema = zod.z.object({
+    loanId: zod.z.string(),
+    walletAddress: zod.z.string(),
+    chain: zod.z.string(),
+    marketId: zod.z.string().min(1),
+    dataStatus: loanDataStatusSchema,
+    collateral: borrowAssetAmountSchema.nullable(),
+    borrowed: borrowAssetAmountSchema.nullable(),
+    principalBorrowed: borrowAssetAmountSchema.nullable(),
+    accruedInterest: borrowAssetAmountSchema.nullable(),
+    borrowApy: zod.z.number().nullable(),
+    ltv: zod.z.number().nullable(),
+    healthFactor: zod.z.number().nullable(),
+    healthFactorBand: healthFactorBandSchema.nullable(),
+    liquidationPrice: borrowAssetAmountSchema.nullable(),
+    status: loanStatusSchema
+});
+/**
+ * Zod schema for the `GET /v1/borrowKit/loans/:loan_id` API response.
+ *
+ * @internal
+ */ zod.z.object({
+    data: loanPayloadSchema
+});
+// ---------------------------------------------------------------------------
+// Inferred types
+// ---------------------------------------------------------------------------
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/borrow/quote` API response.
+ * The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        collateralAmount: borrowAssetAmountSchema,
+        loanAssetAmount: borrowAssetAmountSchema,
+        // Nullable: the service reports null when the curated market row has no
+        // cached rate yet, rather than a misleading 0%. The loans and markets
+        // schemas already allow it; this one did not, so an unpriced market failed
+        // validation and surfaced the whole quote as SERVICE_UNKNOWN_ERROR.
+        borrowApy: zod.z.number().nullable(),
+        fees: zod.z.array(borrowFeeSchema),
+        gasFees: zod.z.array(borrowQuoteGasFeeSchema),
+        ...resultingHealthSchema
+    })
+});
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/:loan_id/addCollateral/quote`
+ * API response. The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        collateralAmount: borrowAssetAmountSchema,
+        fees: zod.z.array(borrowFeeSchema),
+        gasFees: zod.z.array(borrowQuoteGasFeeSchema),
+        ...resultingHealthSchema
+    })
+});
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/:loan_id/closeLoan/quote` API
+ * response. The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        repayAmount: borrowAssetAmountSchema,
+        collateralAmount: borrowAssetAmountSchema,
+        fees: zod.z.array(borrowFeeSchema),
+        gasFees: zod.z.array(borrowQuoteGasFeeSchema),
+        ...resultingHealthSchema
+    })
+});
+/**
+ * The collateral-withdrawal execution response is the one Borrow Service
+ * execution body that omits `chain`, so it cannot reuse
+ * {@link loanExecutionSchema} unchanged. Built on
+ * {@link loanExecutionPayloadSchema} so the `data` envelope only needs to be
+ * applied once.
+ *
+ * @internal
+ */ zod.z.object({
+    data: loanExecutionPayloadSchema.omit({
+        chain: true
+    })
+});
+/**
+ * Zod schema for the
+ * `POST /v1/borrowKit/loans/:loan_id/withdrawCollateral/quote` API response.
+ * The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        repayAmount: borrowAssetAmountSchema,
+        collateralAmount: borrowAssetAmountSchema,
+        fees: zod.z.array(borrowFeeSchema),
+        gasFees: zod.z.array(borrowQuoteGasFeeSchema),
+        ...resultingHealthSchema
+    })
+});
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/requiredCollateral/quote` API
+ * response. The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @remarks Deliberately not {@link resultingHealthSchema}. The two
+ * market-scoped sizing quotes send four fields, not seven — no `resultingLtv`
+ * and no `resultingBand` — so requiring the loan-scoped health block rejected
+ * every well-formed response with `MALFORMED_RESPONSE`.
+ *
+ * `resultingHealthFactor` arrives as a decimal *string* on this route alone
+ * (Zenith types it `decimal.Decimal`, which marshals quoted, where every other
+ * route types it `*float64`). It is accepted as either encoding here and
+ * narrowed to a `number` by the mapper — deliberately not via a Zod
+ * `.transform`, because these schemas are consumed through boolean type guards
+ * (`isRequiredCollateralQuote`), which discard a transform's output and would
+ * leave the raw string flowing on while typed as a number.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        requiredCollateral: borrowAssetAmountSchema,
+        resultingHealthFactor: zod.z.union([
+            zod.z.number(),
+            decimalNumericString
+        ]).nullable(),
+        liquidationPrice: borrowAssetAmountSchema.nullable()
+    })
+});
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/maxBorrow/quote` API response.
+ * The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @remarks Four fields, not seven — see
+ * {@link requiredCollateralQuoteSchema}. `resultingHealthFactor` is a plain
+ * JSON number here (Zenith types it `*float64` on this route), so unlike its
+ * inverse it needs no string coercion.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        chain: zod.z.string().min(1),
+        maxBorrowAmount: borrowAssetAmountSchema,
+        resultingHealthFactor: zod.z.number().nullable(),
+        liquidationPrice: borrowAssetAmountSchema.nullable()
+    })
+});
+/**
+ * Zod schema for the `GET`/`POST /v1/borrowKit/integrators/config` API
+ * response. The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        integratorId: zod.z.string().min(1),
+        integratorFeeBps: zod.z.number().int().min(0),
+        integratorFeeAddress: zod.z.string().regex(EVM_ADDRESS_REGEX).nullable(),
+        createdAt: zod.z.string().datetime({
+            offset: true
+        }),
+        updatedAt: zod.z.string().datetime({
+            offset: true
+        })
+    })
+});
+/** @internal */ zod.z.object({
+    config: borrowServiceConfigSchema$1.optional()
+}).strict();
+/**
+ * Both fee fields are always required, so neither half is accepted alone.
+ *
+ * `integratorFeeAddress` may be `null` only when `integratorFeeBps` is 0, which
+ * is how an integrator turns a fee off and clears the recipient. The reverse is
+ * still allowed: a 0 rate can keep an address, which pauses the fee without
+ * forgetting where it used to go. A rate above 0 with no recipient is unusable.
+ *
+ * The rule spans two fields, so it cannot live on either one and cannot be
+ * expressed in the type. `{ integratorFeeBps: 25, integratorFeeAddress: null }`
+ * type-checks and fails here.
+ *
+ * @internal
+ */ zod.z.object({
+    integratorFeeBps: zod.z.number().int().min(0).max(10_000),
+    integratorFeeAddress: zod.z.string().regex(EVM_ADDRESS_REGEX).nullable(),
+    config: borrowServiceConfigSchema$1.optional()
+}).strict().refine((params)=>params.integratorFeeAddress !== null || params.integratorFeeBps === 0, {
+    message: 'integratorFeeAddress can only be null when integratorFeeBps is 0',
+    path: [
+        'integratorFeeAddress'
+    ]
+});
+/**
+ * Zod schema for the webhook registration payload inside the API `data`
+ * envelope, returned by
+ * `POST /v1/borrowKit/loans/:loan_id/webhookRegistration`.
+ *
+ * @internal
+ */ const webhookRegistrationPayloadSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    webhookUrl: zod.z.string().nullish()
+});
+/**
+ * Zod schema validating the caller-supplied `loanId` and `webhookUrl` inputs
+ * to `BorrowServiceProvider.registerWebhook` before they're signed and
+ * submitted.
+ *
+ * `loanId` must be a UUID, consistent with every other loan-scoped schema in
+ * this package (`repayQuoteServiceParamsSchema`, `loanSchema`,
+ * `loanExecutionSchema`). `webhookUrl` must be `null` (an explicit "unset"
+ * intent) or a syntactically valid **https** URL string — an empty string is
+ * neither, so it's rejected here rather than silently reaching the `?? ''`
+ * coercion that `buildWebhookRegistrationTypedData` applies to a genuine
+ * `null`. The scheme is restricted to `https:` because this URL is where
+ * loan-lifecycle callbacks get delivered and is cryptographically signed by
+ * the loan owner: allowing `http:` would let a signed registration point at
+ * a plaintext endpoint (or a link-local/loopback address reachable only from
+ * the callback sender's own network), and the SDK is the natural place to
+ * refuse that before it's ever signed or transmitted.
+ *
+ * @internal
+ */ zod.z.object({
+    loanId: zod.z.string().uuid(),
+    webhookUrl: zod.z.string().url().refine((value)=>isHttpsUrl$1(value), 'webhookUrl must use the https scheme').nullable()
+}).strict();
+/**
+ * Zod schema for the `POST /v1/borrowKit/loans/:loan_id/webhookRegistration`
+ * API response.
+ *
+ * The Borrow Service API wraps the webhook registration payload in a `data`
+ * envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: webhookRegistrationPayloadSchema
+});
+/** @internal */ const marketAssetSchema = zod.z.object({
+    symbol: zod.z.string().min(1),
+    address: zod.z.string().regex(EVM_ADDRESS_REGEX),
+    decimals: zod.z.number().int().nonnegative()
+});
+/**
+ * Wire shape for a typed token amount: raw atoms as an integer string plus the
+ * token's decimals, matching `@core/amounts` {@link AmountJSON}.
+ *
+ * @internal
+ */ const amountJsonSchema = zod.z.object({
+    raw: zod.z.string().refine(isNonNegativeBigIntLike, {
+        message: 'raw must be a non-negative bigint-compatible string'
+    }),
+    decimals: zod.z.number().int().nonnegative()
+});
+/**
+ * Wire shape for a single borrow market returned by
+ * `GET /v1/borrowKit/markets/:chain/:market_id`. `chain` is the Borrow Service
+ * API chain code (mapped back to the SDK chain by `toMarketInfo`); display
+ * ratios arrive as numbers, token amounts as `{ raw, decimals }` objects.
+ *
+ * @remarks `lltv`, `borrowAssets`, `liquidity`, `borrowApy`, `utilization`,
+ * and `refreshedAt` are all nullable because the service's economics are
+ * cached projections, not live reads: a market that has been discovered but
+ * not yet backfilled by the cache reports every economic field as `null`
+ * rather than a placeholder value. An idle market keeps its last-known values
+ * and old `refreshedAt` rather than reporting zeros, so `null` unambiguously
+ * means "never backfilled." `borrowCap` is always `null` (Morpho Blue has no
+ * per-market cap) but carried anyway so the field does not have to be added
+ * later as a breaking change; it is also optional since the service may omit
+ * it entirely.
+ *
+ * @internal
+ */ const marketResponseSchema = zod.z.object({
+    marketId: zod.z.string().min(1),
+    protocol: zod.z.enum([
+        'morpho'
+    ]),
+    chain: zod.z.string().min(1),
+    loanAsset: marketAssetSchema,
+    collateralAsset: marketAssetSchema,
+    lltv: zod.z.number().nonnegative().nullable(),
+    borrowCap: amountJsonSchema.nullable().optional(),
+    borrowAssets: amountJsonSchema.nullable(),
+    liquidity: amountJsonSchema.nullable(),
+    borrowApy: zod.z.number().nonnegative().nullable(),
+    utilization: zod.z.number().nonnegative().nullable(),
+    refreshedAt: zod.z.string().datetime({
+        offset: true
+    }).nullable()
+});
+/**
+ * Zod schema for the `GET /v1/borrowKit/markets/:chain/:market_id` API
+ * response. The Borrow Service wraps every response in a `data` envelope;
+ * {@link marketResponseSchema} itself stays unwrapped since it is also reused
+ * per-entry inside {@link listMarketsResponseSchema}.
+ *
+ * @internal
+ */ zod.z.object({
+    data: marketResponseSchema
+});
+/**
+ * Wire shape for a page of borrow markets returned by
+ * `GET /v1/borrowKit/markets`. Reuses {@link marketResponseSchema} per entry so
+ * the per-market wire format stays defined in one place, and adds the
+ * pagination envelope: an opaque `pageAfter` cursor absent on the last page.
+ * The Borrow Service wraps every response in a `data` envelope.
+ *
+ * @internal
+ */ zod.z.object({
+    data: zod.z.object({
+        markets: zod.z.array(marketResponseSchema),
+        pagination: zod.z.object({
+            pageAfter: zod.z.string().optional()
+        })
+    })
+});
+
+/** @internal */ const BORROW_CHAIN_TO_API = {
+    [Blockchain.Arc]: 'ARC',
+    [Blockchain.Arc_Testnet]: 'ARC-TESTNET'
+};
+
+Object.fromEntries(Object.entries(BORROW_CHAIN_TO_API).map(([sdkChain, apiChain])=>[
+        apiChain,
+        sdkChain
+    ]));
+
+/**
+ * Schema for the Borrow Service configuration options.
+ *
+ * `apiKey` carries a Circle API key (`<ENV>_API_KEY:<keyId>:<keySecret>`) or a
+ * legacy `KIT_KEY:<keyId>:<keySecret>` value. It is shape-checked only — as
+ * with every other field here, the credential's format is the provider's call,
+ * and `buildConfig` rejects a malformed one via `isValidApiKey`. The empty
+ * string is allowed on purpose: `process.env.CIRCLE_API_KEY ?? ''` yields one
+ * when the variable is unset, and the provider reads that as "no credential"
+ * rather than as a malformed one.
+ *
+ * This schema is `.strict()`, so a field missing here is not merely unvalidated
+ * — it is rejected outright, which is what made an `apiKey` config unusable
+ * before it was listed.
+ *
+ * @internal
+ */ const borrowServiceConfigSchema = zod.z.object({
+    apiKey: zod.z.string().optional(),
+    baseUrl: zod.z.string().url('baseUrl must be a valid URL').optional()
+}).strict();
+/**
+ * Runtime schema for {@link GetLoansParams}.
+ *
+ * @example
+ * ```typescript
+ * import { getLoansParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = getLoansParamsSchema.safeParse({
+ *   walletAddress: '0x1111111111111111111111111111111111111111',
+ *   chain: 'Arc_Testnet',
+ * })
+ * ```
+ */ zod.z.object({
+    walletAddress: evmAddressSchema$1,
+    chain: chainIdentifierSchema,
+    pageSize: zod.z.number().int().positive().optional(),
+    pageAfter: zod.z.string().min(1).optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Runtime schema for {@link GetIntegratorConfigParams}.
+ *
+ * @example
+ * ```typescript
+ * import { getIntegratorConfigParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = getIntegratorConfigParamsSchema.safeParse({
+ *   config: { apiKey: 'TEST_API_KEY:key-id:key-secret' },
+ * })
+ * ```
+ */ zod.z.object({
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Runtime schema for {@link GetMarketParams}.
+ *
+ * @example
+ * ```typescript
+ * import { getMarketParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = getMarketParamsSchema.safeParse({
+ *   chain: 'Arc_Testnet',
+ *   marketId: '0xabc...',
+ * })
+ * ```
+ */ zod.z.object({
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Runtime schema for {@link SetIntegratorConfigParams}.
+ *
+ * Both fee fields are required, so neither half is accepted alone.
+ * `integratorFeeAddress` may be `null` only when `integratorFeeBps` is 0, which
+ * turns the fee off and clears the recipient. A rate above 0 with no recipient
+ * is unusable and is rejected.
+ *
+ * @example
+ * ```typescript
+ * import { setIntegratorConfigParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = setIntegratorConfigParamsSchema.safeParse({
+ *   integratorFeeBps: 25,
+ *   integratorFeeAddress: '0x1111111111111111111111111111111111111111',
+ * })
+ *
+ * // Turning the fee off and clearing the recipient.
+ * const cleared = setIntegratorConfigParamsSchema.safeParse({
+ *   integratorFeeBps: 0,
+ *   integratorFeeAddress: null,
+ * })
+ * ```
+ */ zod.z.object({
+    integratorFeeBps: zod.z.number().int().min(0).max(10_000),
+    integratorFeeAddress: evmAddressSchema$1.nullable(),
+    config: borrowServiceConfigSchema.optional()
+}).strict().refine((params)=>params.integratorFeeAddress !== null || params.integratorFeeBps === 0, {
+    message: 'integratorFeeAddress can only be null when integratorFeeBps is 0',
+    path: [
+        'integratorFeeAddress'
+    ]
+});
+/** @internal */ const HUMAN_READABLE_AMOUNT_REGEX = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+/**
+ * @param maxDecimals - Decimal places the amount may carry, or `null` for no
+ *   cap. USDC amounts take the default six; an amount denominated in a market's
+ *   own collateral token may be finer, so those pass `null`.
+ * @internal
+ */ function createPositiveAmountSchema(field, maxDecimals = 6) {
+    const positive = zod.z.string().regex(HUMAN_READABLE_AMOUNT_REGEX, `${field} must be a human-readable decimal string`).refine((value)=>/[1-9]/.test(value), `${field} must be greater than zero`);
+    if (maxDecimals === null) {
+        return positive;
+    }
+    return positive.refine((value)=>(value.split('.')[1]?.length ?? 0) <= maxDecimals, `${field} must have at most ${maxDecimals.toString()} decimal places`);
+}
+/** @internal */ const positiveAmountSchema = createPositiveAmountSchema('repayAmount');
+const NIL_UUID = '00000000-0000-0000-0000-000000000000';
+const idempotencyKeySchema = zod.z.string().uuid().refine((value)=>value !== NIL_UUID, {
+    message: 'idempotencyKey must not be the nil UUID; generate a fresh one per write'
+});
+/** @internal */ const adapterContextSchema = zod.z.object({
+    // prepareAction is declared in the shape (rather than checked only via
+    // .passthrough()) so its value is read off the input by property access:
+    // .passthrough() only copies an input's own enumerable keys into its
+    // output, which drops prototype methods like a class's prepareAction.
+    adapter: adapterSchema.extend({
+        prepareAction: zod.z.unknown()
+    }).passthrough().refine((adapter)=>typeof adapter.prepareAction === 'function', 'adapter must expose prepareAction'),
+    chain: chainIdentifierSchema,
+    address: evmAddressSchema$1.optional()
+}).strict();
+/**
+ * Shared `superRefine` enforcing the address/adapter-capability contract: a
+ * developer-controlled adapter must supply `address` (the kit cannot resolve
+ * it), and a user-controlled adapter must not (the adapter itself resolves
+ * it — a caller-supplied value would silently take precedence, letting the
+ * two disagree). Applied to every schema whose `from` shape carries an
+ * adapter with a declared `addressContext` capability, so every Borrow Kit
+ * write rejects a mismatched `from` the same way.
+ *
+ * @internal
+ */ function refineAddressContext(from, context) {
+    const addressContext = from.adapter.capabilities?.addressContext;
+    if (addressContext === 'developer-controlled' && from.address === undefined) {
+        context.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            message: 'address is required for developer-controlled adapters',
+            path: [
+                'address'
+            ]
+        });
+    }
+    if (addressContext === 'user-controlled' && from.address !== undefined) {
+        context.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            message: 'address must be resolved by user-controlled adapters',
+            path: [
+                'address'
+            ]
+        });
+    }
+}
+/** @internal */ const borrowExecutionFromSchema = zod.z.object({
+    // prepareAction/validateChainSupport/capabilities are declared in the
+    // shape (rather than checked only via .passthrough()) so their values are
+    // read off the input by property access: .passthrough() only copies an
+    // input's own enumerable keys into its output, which drops a prototype
+    // method or getter like a class's prepareAction/validateChainSupport/
+    // capabilities. capabilities is read below and by refineAddressContext.
+    adapter: adapterSchema.extend({
+        prepareAction: zod.z.unknown(),
+        validateChainSupport: zod.z.unknown(),
+        capabilities: zod.z.unknown()
+    }).passthrough().refine((adapter)=>typeof adapter.prepareAction === 'function', 'adapter must expose prepareAction').refine((adapter)=>typeof adapter.validateChainSupport === 'function', 'adapter must expose validateChainSupport').refine((adapter)=>adapter.capabilities?.addressContext === 'user-controlled' || adapter.capabilities?.addressContext === 'developer-controlled', 'adapter must declare its addressContext capability'),
+    chain: chainIdentifierSchema,
+    address: evmAddressSchema$1.optional()
+}).strict().superRefine(refineAddressContext);
+/**
+ * Runtime schema for {@link RepayQuoteParams}.
+ */ const repayQuoteParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    repayAmount: positiveAmountSchema,
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/** Runtime schema for {@link RepayParams}. */ repayQuoteParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: idempotencyKeySchema.optional(),
+    from: borrowExecutionFromSchema
+});
+/** Runtime schema for requesting a full-close quote. */ const closeLoanQuoteParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/** Runtime schema for atomically closing a loan. */ closeLoanQuoteParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: idempotencyKeySchema.optional(),
+    from: borrowExecutionFromSchema
+});
+/**
+ * Runtime schema for {@link GetPositionParams}.
+ *
+ * @example
+ * ```typescript
+ * import { getPositionParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = getPositionParamsSchema.safeParse({
+ *   loanId: '11111111-1111-4111-8111-111111111111',
+ * })
+ * ```
+ */ zod.z.object({
+    loanId: zod.z.string().uuid(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Schema for the adapter context within Borrow operations.
+ *
+ * `.strict()` so a typo nested inside `from` fails fast instead of being
+ * silently stripped. The address field is optional (resolved from the
+ * adapter at runtime).
+ *
+ * @internal
+ */ const borrowAdapterContextSchema = zod.z.object({
+    // signTypedData/capabilities are declared in the shape (rather than
+    // checked only via .passthrough()) so their values are read off the input
+    // by property access: .passthrough() only copies an input's own
+    // enumerable keys into its output, which drops a prototype method or
+    // getter like a class's signTypedData/capabilities. capabilities is read
+    // by refineAddressContext below.
+    adapter: adapterSchema.extend({
+        signTypedData: zod.z.unknown(),
+        capabilities: zod.z.unknown()
+    }).passthrough().refine(// supportsSignTypedData is optional on SignTypedDataAdapter (see
+    // @core/adapter-evm's hasSignTypedData/canSignTypedData): only
+    // signTypedData itself is required here.
+    (adapter)=>typeof adapter.signTypedData === 'function', 'adapter must support signTypedData'),
+    // BorrowAdapterContext accepts a wider chain field, but runtime
+    // validation must stay constrained to chains where loans exist. No cast
+    // needed here: inferring straight from borrowChainIdentifierSchema keeps
+    // this schema's exported type accurate (only the Borrow chain set),
+    // unlike the previous `as unknown as typeof chainIdentifierSchema` cast,
+    // which over-widened it to the full ChainIdentifier union.
+    chain: borrowChainIdentifierSchema,
+    address: zod.z.string().min(1, 'address must not be empty').optional()
+}).strict()// Same address/adapter-capability contract every other Borrow Kit write
+// enforces via borrowExecutionFromSchema: a developer-controlled adapter
+// without `address` fails fast with a named message instead of falling
+// through to adapter.getAddress(); a user-controlled adapter with `address`
+// set is rejected instead of silently taking precedence.
+.superRefine(refineAddressContext);
+/** @internal */ const borrowParamsBaseSchema = zod.z.object({
+    from: adapterContextSchema,
+    borrowAmount: createPositiveAmountSchema('borrowAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    idempotencyKey: idempotencyKeySchema.optional(),
+    config: borrowServiceConfigSchema.optional()
+});
+/**
+ * Runtime schema for {@link BorrowParams}.
+ *
+ * One strict object with a refinement, rather than a union of a market branch
+ * and a loan branch: a union that fails every branch reports one `invalid_union`
+ * issue, which costs the caller the field that actually failed. The refinement
+ * states the rule it enforces, and every other field keeps naming itself.
+ */ borrowParamsBaseSchema.extend({
+    marketId: zod.z.string().min(1).optional(),
+    loanId: zod.z.string().uuid().optional()
+}).strict().refine((params)=>params.marketId === undefined !== (params.loanId === undefined), {
+    message: 'Provide exactly one of marketId or loanId'
+});
+/**
+ * Schema for the adapter context within reward-claiming operations.
+ *
+ * Validate that a properly-shaped adapter instance and a valid chain
+ * identifier are provided. The address field is optional at the schema
+ * level (resolved from the adapter at runtime for user-controlled
+ * adapters, required for developer-controlled ones — that distinction is
+ * enforced by {@link BorrowAdapterContext}'s conditional `AddressField`,
+ * not by this runtime schema). `.strict()` so a typo nested inside `from`
+ * fails fast instead of being silently stripped.
+ *
+ * Reward claiming is restricted to the Borrow chain identifiers (Arc and
+ * Arc Testnet), which is narrower than the general
+ * {@link chainIdentifierSchema} `repay`/`borrow` accept.
+ *
+ * @internal
+ */ const claimRewardsAdapterContextSchema = zod.z.object({
+    adapter: adapterSchema,
+    chain: borrowChainIdentifierSchema,
+    address: evmAddressSchema$1.optional()
+}).strict()// Same address/adapter-capability contract every other Borrow Kit write
+// enforces via borrowExecutionFromSchema: a developer-controlled adapter
+// without `address` fails fast with a named message instead of falling
+// through to adapter.getAddress(); a user-controlled adapter with `address`
+// set is rejected instead of silently taking precedence.
+.superRefine(refineAddressContext);
+/** @internal */ const borrowPreviewParamsBaseSchema = zod.z.object({
+    chain: chainIdentifierSchema,
+    marketId: zod.z.string().min(1),
+    config: borrowServiceConfigSchema.optional()
+});
+/** Runtime schema for a first-open borrow quote. @internal */ const openLoanQuoteParamsSchema = borrowPreviewParamsBaseSchema.extend({
+    walletAddress: evmAddressSchema$1,
+    borrowAmount: createPositiveAmountSchema('borrowAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional()
+}).strict();
+/** Runtime schema for an existing-loan borrow quote. @internal */ const borrowMoreQuoteParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    borrowAmount: createPositiveAmountSchema('borrowAmount'),
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/** Runtime schema for {@link BorrowQuoteParams}. */ zod.z.union([
+    openLoanQuoteParamsSchema,
+    borrowMoreQuoteParamsSchema
+]);
+/** Runtime schema for {@link RequiredCollateralParams}. */ borrowPreviewParamsBaseSchema.extend({
+    borrowAmount: createPositiveAmountSchema('borrowAmount'),
+    targetHealthFactor: zod.z.number().positive().finite()
+}).strict();
+// Uncapped: repayments are USDC, but collateral is the market's own token and
+// may hold more precision than USDC's six places.
+/** @internal */ const collateralAmountSchema = createPositiveAmountSchema('collateralAmount', null);
+/**
+ * Validation schema for ClaimRewardsParams.
+ *
+ * @example
+ * ```typescript
+ * import { claimRewardsParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = claimRewardsParamsSchema.safeParse({
+ *   from: { adapter, chain: 'Arc_Testnet' },
+ * })
+ * ```
+ */ zod.z.object({
+    from: claimRewardsAdapterContextSchema,
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Validation schema for GetClaimRewardsQuoteParams.
+ *
+ * @example
+ * ```typescript
+ * import { getClaimRewardsQuoteParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = getClaimRewardsQuoteParamsSchema.safeParse({
+ *   from: { adapter, chain: 'Arc_Testnet' },
+ * })
+ * ```
+ */ zod.z.object({
+    from: claimRewardsAdapterContextSchema,
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/** @internal */ const marketSortBySchema = zod.z.enum([
+    'lltv',
+    'borrowApy'
+]);
+/**
+ * Build a schema for an optional non-negative decimal filter string.
+ *
+ * Accepts values like `'0'`, `'100'`, `'0.86'`; rejects negatives, leading
+ * dots, and non-numeric input so a malformed filter fails fast.
+ *
+ * @param field - The filter field name, used in the rejection message.
+ * @returns A Zod string schema constrained to a non-negative decimal form.
+ * @internal
+ */ function decimalFilterSchema(field) {
+    return zod.z.string().regex(/^\d+(\.\d+)?$/, `${field} must be a non-negative decimal string`);
+}
+const exploreMarketsParamsBase = zod.z.object({
+    chain: chainIdentifierSchema,
+    minLltv: decimalFilterSchema('minLltv').optional(),
+    maxLltv: decimalFilterSchema('maxLltv').optional(),
+    minBorrow: decimalFilterSchema('minBorrow').optional(),
+    maxBorrow: decimalFilterSchema('maxBorrow').optional(),
+    sortBy: marketSortBySchema.optional(),
+    // Provisional bounds: the backend has not published a pageSize range, so
+    // reject only implausible values rather than plausible ones.
+    pageSize: zod.z.number().int('pageSize must be an integer').min(1, 'pageSize must be at least 1').max(1000, 'pageSize must be at most 1000').optional(),
+    pageAfter: zod.z.string().min(1, 'pageAfter must not be empty').optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Runtime schema for {@link MaxBorrowParams}.
+ *
+ * The collateral amount is not held to the loan asset's six decimal places: it
+ * denominates the market's collateral token, whose precision may be finer.
+ */ borrowPreviewParamsBaseSchema.extend({
+    collateralAmount: collateralAmountSchema
+}).strict();
+/** Runtime schema for {@link WithdrawCollateralQuoteParams}. */ const withdrawCollateralQuoteParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    collateralAmount: collateralAmountSchema,
+    slippageBps: zod.z.number().int().min(0).max(10_000).optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Maximum accepted signature deadline: 300 seconds from now, matching the
+ * Borrow Service's own hard limit on `WebhookRegistration` deadlines. A wider
+ * SDK-side window would let a caller sign a deadline the service always
+ * rejects.
+ *
+ * @internal
+ */ const MAX_DEADLINE_SKEW_SECONDS = 300;
+/**
+ * True when `value` parses as a URL whose scheme is exactly `https:`.
+ *
+ * Uses the WHATWG `URL` parser rather than `startsWith('https://')` so the
+ * check is scheme-normalized (case-insensitive, e.g. `HTTPS://...` still
+ * passes) instead of a literal prefix match. `value` has already passed
+ * `z.string().url()` by the time this runs, but a caller could still supply
+ * a string that `URL` itself rejects, so the parse is guarded.
+ *
+ * @internal
+ */ function isHttpsUrl(value) {
+    try {
+        return new URL(value).protocol === 'https:';
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Validation schema for RegisterWebhookParams.
+ *
+ * @example
+ * ```typescript
+ * import { registerWebhookParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = registerWebhookParamsSchema.safeParse({
+ *   from: { adapter, chain: 'Arc_Testnet' },
+ *   loanId: '11111111-1111-4111-8111-111111111111',
+ *   webhookUrl: 'https://example.com/webhook',
+ * })
+ * ```
+ */ zod.z.object({
+    from: borrowAdapterContextSchema,
+    // loanId must be a UUID, consistent with every other loan-scoped schema
+    // in this package (repayQuoteParamsSchema, closeLoanQuoteParamsSchema,
+    // borrowParamsSchema) and with the provider-level
+    // registerWebhookInputSchema, which already enforces this.
+    loanId: zod.z.string().uuid(),
+    // Restricted to https: for the same reason as the provider-level
+    // registerWebhookInputSchema — this URL receives a cryptographically
+    // signed, owner-authorized registration, and http:// would let that
+    // signed intent point at a plaintext or link-local/loopback endpoint.
+    webhookUrl: zod.z.string().url('webhookUrl must be a valid URL').refine((value)=>isHttpsUrl(value), 'webhookUrl must use the https scheme').nullable().optional(),
+    deadline: zod.z.number().int('deadline must be an integer unix-seconds timestamp').refine((deadline)=>deadline > Math.floor(Date.now() / 1000), 'deadline must be in the future — a past deadline would sign a message the Borrow Service always rejects').refine((deadline)=>deadline <= Math.floor(Date.now() / 1000) + MAX_DEADLINE_SKEW_SECONDS, `deadline must be at most ${String(MAX_DEADLINE_SKEW_SECONDS)} seconds from now`).optional(),
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/**
+ * Reject a filter range whose lower bound exceeds its upper bound.
+ *
+ * Each bound is validated independently, so `{ minLltv: '0.9', maxLltv: '0.1' }`
+ * would otherwise pass and return a silently empty page; comparing the bounds
+ * numerically turns that contradiction into a clear validation error. Shared by
+ * the single-page and iterator schemas so the two cannot drift.
+ *
+ * @param value - The parsed explore filters.
+ * @param ctx - The Zod refinement context that collects any range issues.
+ * @internal
+ */ function refineFilterRanges(value, ctx) {
+    if (value.minLltv !== undefined && value.maxLltv !== undefined && Number(value.minLltv) > Number(value.maxLltv)) {
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            path: [
+                'maxLltv'
+            ],
+            message: 'maxLltv must be greater than or equal to minLltv'
+        });
+    }
+    if (value.minBorrow !== undefined && value.maxBorrow !== undefined && Number(value.minBorrow) > Number(value.maxBorrow)) {
+        ctx.addIssue({
+            code: zod.z.ZodIssueCode.custom,
+            path: [
+                'maxBorrow'
+            ],
+            message: 'maxBorrow must be greater than or equal to minBorrow'
+        });
+    }
+}
+/**
+ * Runtime schema for {@link ExploreMarketsParams}.
+ *
+ * `chain` is required; every filter is optional. `pageAfter` is an opaque
+ * non-empty cursor and `pageSize` a positive integer (provisional upper bound
+ * 1000, pending backend confirmation). Unknown keys are rejected, and a range
+ * whose minimum exceeds its maximum is rejected rather than returning a
+ * silently empty page.
+ *
+ * @example
+ * ```typescript
+ * import { exploreMarketsParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = exploreMarketsParamsSchema.safeParse({
+ *   chain: 'Arc_Testnet',
+ *   minLltv: '0.8',
+ *   sortBy: 'borrowApy',
+ * })
+ * ```
+ */ exploreMarketsParamsBase.superRefine(refineFilterRanges);
+/**
+ * Runtime schema for {@link ExploreMarketsIteratorParams}.
+ *
+ * Identical to {@link exploreMarketsParamsSchema} minus `pageAfter`: the
+ * iterator owns the cursor and advances through pages itself.
+ *
+ * @example
+ * ```typescript
+ * import { exploreMarketsIteratorParamsSchema } from '@circle-fin/borrow-kit'
+ *
+ * const result = exploreMarketsIteratorParamsSchema.safeParse({
+ *   chain: 'Arc_Testnet',
+ *   sortBy: 'borrowApy',
+ * })
+ * ```
+ */ exploreMarketsParamsBase.omit({
+    pageAfter: true
+}).superRefine(refineFilterRanges);
+/** Runtime schema for {@link WithdrawCollateralParams}. */ withdrawCollateralQuoteParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: idempotencyKeySchema.optional(),
+    from: borrowExecutionFromSchema
+});
+/** Runtime schema for {@link AddCollateralQuoteParams}. */ const addCollateralQuoteParamsSchema = zod.z.object({
+    loanId: zod.z.string().uuid(),
+    chain: chainIdentifierSchema,
+    collateralAmount: collateralAmountSchema,
+    config: borrowServiceConfigSchema.optional()
+}).strict();
+/** Runtime schema for {@link AddCollateralParams}. */ addCollateralQuoteParamsSchema.omit({
+    chain: true
+}).extend({
+    idempotencyKey: idempotencyKeySchema.optional(),
+    from: borrowExecutionFromSchema
+});
+
 /** SDK name used in telemetry payloads. */ resolveKitSdkName(pkg.name);
 
 // Auto-register this kit for user agent tracking