@circle-fin/app-kit 1.15.2 → 1.16.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);
     }
@@ -3135,6 +3163,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 +3562,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 +3686,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
@@ -3861,6 +3941,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 +4288,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 +4450,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 +4524,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,
@@ -8083,7 +8197,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()
 });
@@ -8279,6 +8394,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 +8636,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;
 }
@@ -9198,6 +9350,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 +9430,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 +9517,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);
     }
@@ -12062,11 +12235,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.2";
+var pkg$4 = {
+	name: name$3,
+	version: version$4};
 
 const assertCustomFeePolicySymbol = Symbol('assertCustomFeePolicy');
 /**
@@ -12635,6 +12808,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.
  *
@@ -19758,7 +19937,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 +19946,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 +20028,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 +20188,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 +23407,16 @@ const mockAttestationMessage = {
     return step;
 }
 
-var version$2 = "1.14.0";
-var pkg$2 = {
-	version: version$2};
+var version$3 = "1.14.1";
+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 +23789,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 +25716,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 +25796,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 +26673,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 +26714,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 +26862,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 +27586,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 +27657,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.7.1";
+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 +27742,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 +27763,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'
@@ -28312,36 +28491,176 @@ 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;
+    }
+}
 /**
- * Zod schema for validating EVM adapter capabilities.
+ * A `0x`-prefixed, even-length hex byte string (`'0x'` for empty calldata).
  *
- * This schema ensures that EVM adapter capabilities meet the requirements for the
- * OperationContext pattern by validating the addressContext property and ensuring
- * the supportedChains property contains only EVM-compatible chains.
+ * @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`.
  *
- * @remarks
- * This schema enforces that all supported chains are EVM type, making it specific
- * to EVM adapters (Ethers, Viem, etc.). For non-EVM adapters, a different validation
- * schema should be used.
+ * @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.
  *
- * When used with the validate() function from @core/utils, this throws KitError
- * with INPUT_VALIDATION_FAILED code if validation fails, with details about which
- * properties failed.
+ * @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.
  *
- * @example
- * ```typescript
- * import { AdapterCapabilitiesSchema } from '@core/adapter-evm/validation'
- * import { Ethereum, Base } from '@core/chains'
+ * `.passthrough()` so a backend that adds a field does not fail validation.
  *
- * // Valid user-controlled capabilities
- * const userCapabilities = {
- *   addressContext: 'user-controlled',
- *   supportedChains: [Ethereum, Base]
- * }
+ * @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.
  *
- * // Valid developer-controlled capabilities
- * const devCapabilities = {
- *   addressContext: 'developer-controlled',
+ * @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.
+ *
+ * This schema ensures that EVM adapter capabilities meet the requirements for the
+ * OperationContext pattern by validating the addressContext property and ensuring
+ * the supportedChains property contains only EVM-compatible chains.
+ *
+ * @remarks
+ * This schema enforces that all supported chains are EVM type, making it specific
+ * to EVM adapters (Ethers, Viem, etc.). For non-EVM adapters, a different validation
+ * schema should be used.
+ *
+ * When used with the validate() function from @core/utils, this throws KitError
+ * with INPUT_VALIDATION_FAILED code if validation fails, with details about which
+ * properties failed.
+ *
+ * @example
+ * ```typescript
+ * import { AdapterCapabilitiesSchema } from '@core/adapter-evm/validation'
+ * import { Ethereum, Base } from '@core/chains'
+ *
+ * // Valid user-controlled capabilities
+ * const userCapabilities = {
+ *   addressContext: 'user-controlled',
+ *   supportedChains: [Ethereum, Base]
+ * }
+ *
+ * // Valid developer-controlled capabilities
+ * const devCapabilities = {
+ *   addressContext: 'developer-controlled',
  *   supportedChains: [Ethereum]
  * }
  *
@@ -28739,7 +29058,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 +29175,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 +29187,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();
@@ -29260,7 +29626,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()
@@ -29321,7 +29687,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 +29730,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 +29825,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 +29866,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.7.0";
-var pkg = {
-	name: name,
-	version: version};
+var name$1 = "@circle-fin/earn-kit";
+var version$1 = "1.8.1";
+var pkg$1 = {
+	name: name$1,
+	version: version$1};
 
 /**
  * Map SDK chain identifiers to bridge API chain strings.
@@ -29581,7 +29947,7 @@ function isBigIntLike(value) {
         return false;
     }
 }
-function isNonNegativeBigIntLike(value) {
+function isNonNegativeBigIntLike$1(value) {
     try {
         return BigInt(value) >= 0n;
     } catch  {
@@ -29601,28 +29967,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'
 });
@@ -29648,10 +30008,8 @@ const bridgeFeeTokenSchema = hexAddressSchema;
     assetAddress: zod.z.string(),
     lltv: zod.z.number(),
     supplyUsd: zod.z.number(),
-    // Optional during the expand/contract window (a backend that predates the
-    // field omits the key), mirroring the `.optional()` facets on the base
-    // schema; `null` when the product exposes no per-market allocation (V2).
-    allocationPct: zod.z.number().nullable().optional()
+    // `null` when the product exposes no per-market allocation (V2).
+    allocationPct: zod.z.number().nullable()
 });
 /**
  * Zod schema for a Morpho vault warning in the API response.
@@ -29708,9 +30066,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'
@@ -29747,8 +30105,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'
@@ -29758,19 +30116,20 @@ const bridgeFeeTokenSchema = hexAddressSchema;
     earnKitWarnings: zod.z.array(zod.z.string()).optional()
 });
 /**
- * Shared base schema: existing flat fields (kept) plus the new nested
- * facets and neutral identity. Facets are `.optional()` during the
- * transition; flip to required once the backend is confirmed emitting.
+ * Shared base schema: existing flat fields (kept as deprecated aliases) plus
+ * the nested facets. Zenith emits all facets on every response; required here
+ * so a partial emission is caught at parse time rather than surfacing as a
+ * runtime `undefined` access.
  *
  * @internal
  */ const earnBaseSchema = vaultInfoResponseSchema.extend({
-    address: zod.z.string().optional(),
-    asOf: zod.z.string().optional(),
-    manager: managerSchema.nullable().optional(),
-    apyProfile: apyProfileSchema.optional(),
-    fee: feeInfoSchema.optional(),
-    liquidityProfile: liquidityProfileSchema.optional(),
-    riskSignals: riskSignalsSchema.optional()
+    address: zod.z.string(),
+    asOf: zod.z.string(),
+    manager: managerSchema.nullable(),
+    apyProfile: apyProfileSchema,
+    fee: feeInfoSchema,
+    liquidityProfile: liquidityProfileSchema,
+    riskSignals: riskSignalsSchema
 });
 /**
  * Zod schema for the `vault` opportunity variant.
@@ -29857,13 +30216,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')
@@ -29883,9 +30242,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()
@@ -29913,7 +30272,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.
@@ -29927,50 +30286,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.
  *
@@ -30029,9 +30348,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();
@@ -30049,7 +30368,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();
 /**
@@ -30065,7 +30384,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', [
@@ -30200,44 +30519,6 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
 // ---------------------------------------------------------------------------
 // Claim rewards response schema
 // ---------------------------------------------------------------------------
-/**
- * Zod schema for a claimed reward amount in the API response.
- *
- * @internal
- */ const claimedAmountSchema = zod.z.object({
-    token: hexAddressSchema,
-    symbol: zod.z.string(),
-    amount: amountJsonSchema
-});
-/**
- * Zod schema for the claim rewards payload inside the API `data` envelope.
- *
- * 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
 // ---------------------------------------------------------------------------
@@ -30256,7 +30537,7 @@ const bridgeDepositPrepareReviewSchema = zod.z.object({
     type: zod.z.string().optional(),
     status: zod.z.string().optional(),
     token: zod.z.string(),
-    amount: amountJsonSchema
+    amount: amountJsonSchema$1
 });
 /**
  * Zod schema for a native gas-fee entry in an EarnKit quote response.
@@ -30293,8 +30574,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(),
@@ -30320,10 +30601,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()
@@ -30340,31 +30621,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
 // ---------------------------------------------------------------------------
@@ -30504,7 +30760,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.
@@ -30736,10 +30992,53 @@ const sourceAdapterContextSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     config: earnConfigSchema.optional()
 });
+/**
+ * Schema for a successful gas fee entry (fees is non-null).
+ *
+ * Validates the kit shape — {@link EarnEstimatedGas} uses decimal strings for
+ * `gas`, `gasPrice`, and `fee`. Only digits are accepted so that the deposit
+ * operation can safely convert them to `bigint` before passing them to the
+ * provider's `computeGasReserve`.
+ *
+ * @internal
+ */ const earnGasFeeEstimateSuccessSchema = zod.z.object({
+    name: zod.z.string(),
+    token: zod.z.string(),
+    blockchain: zod.z.string(),
+    fees: zod.z.object({
+        gas: zod.z.string().regex(/^\d+$/, 'gas must be a non-negative integer string'),
+        gasPrice: zod.z.string().regex(/^\d+$/, 'gasPrice must be a non-negative integer string'),
+        fee: zod.z.string().regex(/^\d+$/, 'fee must be a non-negative integer string')
+    }),
+    error: zod.z.undefined().optional()
+}).strict();
+/**
+ * Schema for a failed gas fee entry (fees is null, error is a string).
+ *
+ * @internal
+ */ const earnGasFeeEstimateFailureSchema = zod.z.object({
+    name: zod.z.string(),
+    token: zod.z.string(),
+    blockchain: zod.z.string(),
+    fees: zod.z.null(),
+    error: zod.z.string()
+}).strict();
+/**
+ * Schema for a single kit-level gas fee estimate entry.
+ *
+ * Rejects arbitrary inputs (null, numbers, empty objects, non-numeric fee
+ * strings) so callers receive a descriptive validation error instead of a
+ * raw `BigInt` conversion error inside `computeGasReserve`.
+ *
+ * @internal
+ */ const earnGasFeeEstimateSchema = zod.z.union([
+    earnGasFeeEstimateSuccessSchema,
+    earnGasFeeEstimateFailureSchema
+]);
 /**
  * Validation schema for the same-chain variant of DepositParams.
  *
@@ -30748,10 +31047,11 @@ 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,
+    gasFees: zod.z.array(earnGasFeeEstimateSchema).optional(),
     config: earnConfigSchema.optional()
 }).strict();
 const crossChainDepositDestinationSchema = zod.z.object({
@@ -30818,7 +31118,7 @@ const crossChainDepositDestinationSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -30872,7 +31172,7 @@ const crossChainDepositDestinationSchema = zod.z.object({
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -30892,12 +31192,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()
@@ -30981,7 +31281,7 @@ function hasCrossChainDepositQuoteShape(params) {
  * })
  * ```
  */ zod.z.object({
-    from: adapterContextSchema,
+    from: adapterContextSchema$1,
     vaultAddress: vaultAddressSchema,
     amount: amountSchema,
     config: earnConfigSchema.optional()
@@ -31001,11 +31301,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.0.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