@circle-fin/adapter-ethers-v6 0.0.2-alpha.7 → 1.0.1

package/index.mjs

@@ -17,6 +17,7 @@
  */
 
 import { JsonRpcProvider, Wallet, BrowserProvider, Interface, Contract } from 'ethers';
+export { JsonRpcProvider } from 'ethers';
 import { z } from 'zod';
 import { hexlify, hexZeroPad } from '@ethersproject/bytes';
 import { getAddress } from '@ethersproject/address';
@@ -262,6 +263,7 @@ var Blockchain;
     Blockchain["Algorand_Testnet"] = "Algorand_Testnet";
     Blockchain["Aptos"] = "Aptos";
     Blockchain["Aptos_Testnet"] = "Aptos_Testnet";
+    Blockchain["Arc_Testnet"] = "Arc_Testnet";
     Blockchain["Arbitrum"] = "Arbitrum";
     Blockchain["Arbitrum_Sepolia"] = "Arbitrum_Sepolia";
     Blockchain["Avalanche"] = "Avalanche";
@@ -482,6 +484,48 @@ const BRIDGE_CONTRACT_EVM_TESTNET = '0xC5567a5E3370d4DBfB0540025078e283e36A363d'
  */
 const BRIDGE_CONTRACT_EVM_MAINNET = '0xB3FA262d0fB521cc93bE83d87b322b8A23DAf3F0';
 
+/**
+ * Arc Testnet chain definition
+ * @remarks
+ * This represents the test network for the Arc blockchain,
+ * Circle's EVM-compatible Layer-1 designed for stablecoin finance
+ * and asset tokenization. Arc uses USDC as the native gas token and
+ * features the Malachite Byzantine Fault Tolerant (BFT) consensus
+ * engine for sub-second finality.
+ */
+const ArcTestnet = defineChain({
+    type: 'evm',
+    chain: Blockchain.Arc_Testnet,
+    name: 'Arc Testnet',
+    title: 'ArcTestnet',
+    nativeCurrency: {
+        name: 'Arc',
+        symbol: 'Arc',
+        decimals: 18,
+    },
+    chainId: 5042002,
+    isTestnet: true,
+    explorerUrl: 'https://testnet.arcscan.app/tx/{hash}',
+    rpcEndpoints: ['https://rpc.testnet.arc.network/'],
+    eurcAddress: '0x89B50855Aa3bE2F677cD6303Cec089B5F319D72a',
+    usdcAddress: '0x3600000000000000000000000000000000000000',
+    cctp: {
+        domain: 26,
+        contracts: {
+            v2: {
+                type: 'split',
+                tokenMessenger: '0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA',
+                messageTransmitter: '0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275',
+                confirmations: 1,
+                fastConfirmations: 1,
+            },
+        },
+    },
+    kitContracts: {
+        bridge: BRIDGE_CONTRACT_EVM_TESTNET,
+    },
+});
+
 /**
  * Arbitrum Mainnet chain definition
  * @remarks
@@ -1773,26 +1817,26 @@ const Sonic = defineChain({
 });
 
 /**
- * Sonic Blaze Testnet chain definition
+ * Sonic Testnet chain definition
  * @remarks
  * This represents the official test network for the Sonic blockchain.
  */
 const SonicTestnet = defineChain({
     type: 'evm',
     chain: Blockchain.Sonic_Testnet,
-    name: 'Sonic Blaze Testnet',
-    title: 'Sonic Blaze Testnet',
+    name: 'Sonic Testnet',
+    title: 'Sonic Testnet',
     nativeCurrency: {
         name: 'Sonic',
         symbol: 'S',
         decimals: 18,
     },
-    chainId: 57054,
+    chainId: 14601,
     isTestnet: true,
     explorerUrl: 'https://testnet.sonicscan.org/tx/{hash}',
-    rpcEndpoints: ['https://rpc.blaze.soniclabs.com'],
+    rpcEndpoints: ['https://rpc.testnet.soniclabs.com'],
     eurcAddress: null,
-    usdcAddress: '0xA4879Fed32Ecbef99399e5cbC247E533421C4eC6',
+    usdcAddress: '0x0BA304580ee7c9a980CF72e55f5Ed2E9fd30Bc51',
     cctp: {
         domain: 13,
         contracts: {
@@ -2309,6 +2353,7 @@ var Blockchains = /*#__PURE__*/Object.freeze({
     AptosTestnet: AptosTestnet,
     Arbitrum: Arbitrum,
     ArbitrumSepolia: ArbitrumSepolia,
+    ArcTestnet: ArcTestnet,
     Avalanche: Avalanche,
     AvalancheFuji: AvalancheFuji,
     Base: Base,
@@ -2441,6 +2486,11 @@ const baseChainDefinitionSchema = z.object({
     eurcAddress: z.string().nullable(),
     usdcAddress: z.string().nullable(),
     cctp: z.any().nullable(), // We'll accept any CCTP config structure
+    kitContracts: z
+        .object({
+        bridge: z.string().optional(),
+    })
+        .optional(),
 });
 /**
  * Zod schema for validating EVM chain definitions specifically.
@@ -2472,13 +2522,15 @@ const baseChainDefinitionSchema = z.object({
  * }
  * ```
  */
-const evmChainDefinitionSchema = baseChainDefinitionSchema.extend({
+const evmChainDefinitionSchema = baseChainDefinitionSchema
+    .extend({
     type: z.literal('evm'),
     chainId: z.number({
         required_error: 'EVM chains must have a chainId. Please provide a valid EVM chain ID.',
         invalid_type_error: 'EVM chain ID must be a number.',
     }),
-});
+})
+    .strict(); //// Reject any additional properties not defined in the schema
 /**
  * Zod schema for validating non-EVM chain definitions.
  * This schema extends the base schema with non-EVM specific properties.
@@ -2498,7 +2550,7 @@ const nonEvmChainDefinitionSchema = baseChainDefinitionSchema
         'polkadot',
     ]),
 })
-    .strict(); // Reject additional properties like chainId
+    .strict(); // Reject any additional properties not defined in the schema
 /**
  * Discriminated union schema for all chain definitions.
  * This schema validates different chain types based on their 'type' field.
@@ -2980,67 +3032,41 @@ class KitError extends Error {
 }
 
 /**
- * Standardized error codes for INPUT type errors.
+ * Minimum error code for INPUT type errors.
+ * INPUT errors represent validation failures and invalid parameters.
+ */
+/**
+ * Standardized error definitions for INPUT type errors.
+ *
+ * Each entry combines the numeric error code with its corresponding
+ * string name to ensure consistency when creating error instances.
  *
  * Error codes follow a hierarchical numbering scheme where the first digit
  * indicates the error category (1 = INPUT) and subsequent digits provide
  * specific error identification within that category.
  *
+ *
  * @example
  * ```typescript
- * import { InputErrorCode, InputErrorName } from '@core/errors'
+ * import { InputError } from '@core/errors'
  *
  * const error = new KitError({
- *   code: InputErrorCode.NETWORK_MISMATCH,
- *   name: InputErrorName.NETWORK_MISMATCH,
+ *   ...InputError.NETWORK_MISMATCH,
  *   recoverability: 'FATAL',
  *   message: 'Source and destination networks must be different'
  * })
- * ```
- */
-var InputErrorCode;
-(function (InputErrorCode) {
-    /** Network type mismatch between chains (mainnet vs testnet) */
-    InputErrorCode[InputErrorCode["NETWORK_MISMATCH"] = 1001] = "NETWORK_MISMATCH";
-    /** Invalid amount format or value (negative, zero, or malformed) */
-    InputErrorCode[InputErrorCode["INVALID_AMOUNT"] = 1002] = "INVALID_AMOUNT";
-    /** Unsupported or invalid bridge route configuration */
-    InputErrorCode[InputErrorCode["UNSUPPORTED_ROUTE"] = 1003] = "UNSUPPORTED_ROUTE";
-    /** Invalid wallet or contract address format */
-    InputErrorCode[InputErrorCode["INVALID_ADDRESS"] = 1004] = "INVALID_ADDRESS";
-    /** Invalid or unsupported chain identifier */
-    InputErrorCode[InputErrorCode["INVALID_CHAIN"] = 1005] = "INVALID_CHAIN";
-    /** General validation failure for complex validation rules */
-    InputErrorCode[InputErrorCode["VALIDATION_FAILED"] = 1098] = "VALIDATION_FAILED";
-})(InputErrorCode || (InputErrorCode = {}));
-/**
- * Standardized error names for INPUT type errors.
- *
- * These names correspond 1:1 with InputErrorCode and should always
- * be used together to ensure consistency across error instances.
  *
- * @example
- * ```typescript
- * import { InputErrorCode, InputErrorName } from '@core/errors'
- *
- * // Use matching code and name enums
- * const error = new KitError({
- *   code: InputErrorCode.NETWORK_MISMATCH,
- *   name: InputErrorName.NETWORK_MISMATCH,
- *   recoverability: 'FATAL',
- *   message: 'Network mismatch detected'
- * })
+ * // Access code and name individually if needed
+ * console.log(InputError.NETWORK_MISMATCH.code)  // 1001
+ * console.log(InputError.NETWORK_MISMATCH.name)  // 'INPUT_NETWORK_MISMATCH'
  * ```
  */
-var InputErrorName;
-(function (InputErrorName) {
-    InputErrorName["NETWORK_MISMATCH"] = "INPUT_NETWORK_MISMATCH";
-    InputErrorName["INVALID_AMOUNT"] = "INPUT_INVALID_AMOUNT";
-    InputErrorName["UNSUPPORTED_ROUTE"] = "INPUT_UNSUPPORTED_ROUTE";
-    InputErrorName["INVALID_ADDRESS"] = "INPUT_INVALID_ADDRESS";
-    InputErrorName["INVALID_CHAIN"] = "INPUT_INVALID_CHAIN";
-    InputErrorName["VALIDATION_FAILED"] = "INPUT_VALIDATION_FAILED";
-})(InputErrorName || (InputErrorName = {}));
+const InputError = {
+    /** Unsupported or invalid bridge route configuration */
+    UNSUPPORTED_ROUTE: {
+        code: 1003,
+        name: 'INPUT_UNSUPPORTED_ROUTE',
+    }};
 
 /**
  * Creates error for unsupported bridge route.
@@ -3062,8 +3088,7 @@ var InputErrorName;
  */
 function createUnsupportedRouteError(source, destination) {
     const errorDetails = {
-        code: InputErrorCode.UNSUPPORTED_ROUTE,
-        name: InputErrorName.UNSUPPORTED_ROUTE,
+        ...InputError.UNSUPPORTED_ROUTE,
         recoverability: 'FATAL',
         message: `Route from ${source} to ${destination} is not supported.`,
         cause: {
@@ -3112,26 +3137,6 @@ class Adapter {
      * ```
      */
     capabilities;
-    /**
-     * Default chain for operations when none is explicitly provided.
-     *
-     * This allows adapters to have sensible defaults for chain operations,
-     * reducing the need for explicit chain specification in every call.
-     *
-     * @remarks
-     * This is optional for backward compatibility and because some adapter types
-     * (like developer-controlled adapters) may not have meaningful defaults.
-     *
-     * @example
-     * ```typescript
-     * // User-controlled adapter with default chain
-     * defaultChain = Ethereum
-     *
-     * // Developer-controlled adapter (no default)
-     * defaultChain = undefined
-     * ```
-     */
-    defaultChain;
     /**
      * Registry of available actions for this adapter.
      *
@@ -3203,17 +3208,14 @@ class Adapter {
      * - **Browser wallet adapters**: Request chain switch via EIP-1193 or equivalent
      * - **Multi-entity adapters**: Validate chain support (operations are contextual)
      *
-     * @param chain - The target chain for operations. If not provided, uses the adapter's defaultChain.
+     * @param chain - The target chain for operations.
      * @returns A promise that resolves when the adapter is operating on the specified chain.
      * @throws When the target chain is not supported or chain switching fails.
      *
      * @remarks
-     * This method replaces the pattern of calling `getChain()` to check current chain and then
-     * manually switching. It provides a declarative "ensure this chain" interface for operations.
-     *
-     * **Backward Compatibility**: The default implementation provides basic validation but
-     * doesn't perform actual chain switching. Concrete adapter implementations should override
-     * this method to provide proper chain switching logic.
+     * This method always calls `switchToChain()` to ensure consistency across all adapter types.
+     * The underlying implementations handle idempotent switching efficiently (e.g., browser wallets
+     * gracefully handle switching to the current chain, private key adapters recreate lightweight clients).
      *
      * @example
      * ```typescript
@@ -3227,25 +3229,9 @@ class Adapter {
      * await circleWalletsAdapter.ensureChain(Ethereum)
      * ```
      */
-    async ensureChain(chain) {
-        const targetChain = chain ?? this.defaultChain;
-        if (!targetChain) {
-            return;
-        }
+    async ensureChain(targetChain) {
         this.validateChainSupport(targetChain);
-        // Check if already on the target chain (skip for developer-controlled adapters)
-        if (this.capabilities?.addressContext !== 'developer-controlled') {
-            try {
-                const currentChain = await this.getChain();
-                if (currentChain.chain === targetChain.chain) {
-                    return; // Already on the correct chain
-                }
-            }
-            catch {
-                // If getChain() fails, we'll proceed with switching anyway
-            }
-        }
-        // Delegate actual switching to the concrete implementation
+        // Always delegate to switchToChain - implementations handle idempotent switching
         try {
             await this.switchToChain(targetChain);
         }
@@ -3808,7 +3794,6 @@ base58StringSchema.refine((value) => value.length >= 86 && value.length <= 88, '
 const adapterSchema = z.object({
     prepare: z.function(),
     waitForTransaction: z.function(),
-    getChain: z.function(),
     getAddress: z.function(),
 });
 
@@ -8070,6 +8055,246 @@ class EvmAdapter extends Adapter {
     }
 }
 
+// --- Signature Parsing Constants ---
+const SIGNATURE_BYTE_LENGTH = 65; // Total bytes in an Ethereum signature
+const HEX_CHARS_PER_BYTE = 2;
+const SIGNATURE_HEX_LENGTH = SIGNATURE_BYTE_LENGTH * HEX_CHARS_PER_BYTE;
+const R_HEX_LENGTH = 32 * HEX_CHARS_PER_BYTE; // 32 bytes for 'r'
+const S_HEX_LENGTH = 32 * HEX_CHARS_PER_BYTE; // 32 bytes for 's'
+// --- Recovery ID Validation Constants ---
+/**
+ * Legacy recovery IDs (pre-EIP-155 format):
+ * - 0 or 1 (older clients) or 27, 28 (Ethereum before chain-id inclusion)
+ */
+const LEGACY_V_VALUES = new Set([0, 1, 27, 28]);
+/**
+ * Minimum v value indicating an EIP-155 style signature.
+ * Calculated as 35 + (2 * chainId) + recoveryId (0 or 1).
+ */
+const MIN_EIP155_V = 35;
+/**
+ * parseSignature
+ *
+ * Parse a 65-byte ECDSA signature into its r, s, and v components, expressed in hex.
+ *
+ * Ethereum signatures are structured as:
+ *   signature = r (32 bytes) || s (32 bytes) || v (1 byte)
+ *
+ * - r, s: Big-endian hex values (32 bytes each)
+ * - v: Recovery identifier, used by secp256k1 to reconstruct the signer’s public key
+ *
+ * @param signatureHex - Signature as a hex string, optionally prefixed with "0x".
+ * @returns { r, s, v }
+ *   - r: Hex string of the R component.
+ *   - s: Hex string of the S component.
+ *   - v: Numeric recovery ID.
+ *
+ * @throws Error if:
+ *   - Input is not valid hex.
+ *   - Incorrect length (must be exactly 65 bytes / 130 hex chars).
+ *   - v is outside the supported range (Legacy or EIP-155 formula).
+ *
+ * Notes on EIP-155 overload:
+ * EIP-155 repurposes the v field so that:
+ *   v = 35 + (2 * chainId) + recoveryId(0 or 1)
+ * Any v value >= 35 indicates the chain-id is encoded, preventing cross-chain replay.
+ * r and s values remain unchanged.
+ *
+ * Example:
+ * ```typescript
+ * const rawSig = '0x6c1b...f02b'
+ * try {
+ *   const { r, s, v } = parseSignature(rawSig)
+ *   console.log('R:', r)
+ *   console.log('S:', s)
+ *   console.log('Recovery ID (v):', v)
+ * } catch (err) {
+ *   console.error('Signature parse error:', err.message)
+ * }
+ * ```
+ */
+function parseSignature(signatureHex) {
+    // 1) Remove optional '0x' prefix
+    const hex = signatureHex.startsWith('0x')
+        ? signatureHex.slice(2)
+        : signatureHex;
+    // 2) Validate hex format and length
+    const VALID_HEX_REGEX = /^[0-9a-fA-F]+$/;
+    if (!VALID_HEX_REGEX.test(hex)) {
+        throw new Error('Signature must be a valid hex string (0-9, a-f, A-F).');
+    }
+    if (hex.length !== SIGNATURE_HEX_LENGTH) {
+        throw new Error(`Invalid length: expected ${SIGNATURE_HEX_LENGTH.toString()} hex chars (65 bytes), got ${hex.length.toString()}`);
+    }
+    // 3) Extract components
+    const r = `0x${hex.slice(0, R_HEX_LENGTH)}`;
+    const s = `0x${hex.slice(R_HEX_LENGTH, R_HEX_LENGTH + S_HEX_LENGTH)}`;
+    const vValue = parseInt(hex.slice(R_HEX_LENGTH + S_HEX_LENGTH), 16);
+    // 4) Ensure v is within supported values
+    const isLegacy = LEGACY_V_VALUES.has(vValue);
+    const isEIP155 = vValue >= MIN_EIP155_V;
+    if (!isLegacy && !isEIP155) {
+        throw new Error(`Unsupported v value: ${vValue.toString()}. Must be one of [${[
+            ...LEGACY_V_VALUES,
+        ].join(', ')}] or >=${MIN_EIP155_V.toString()}`);
+    }
+    return { r: r, s: s, v: vValue };
+}
+/**
+ * buildTypedData
+ *
+ * Create an EIP-712 compliant "TypedData" object, encapsulating:
+ *  - Domain separator (application/contract identity, chain ID)
+ *  - Explicit type definitions (field names and types)
+ *  - Primary type name identifying the root object
+ *  - Message payload matching the defined schema
+ *
+ * This enforces structured, non-ambiguous signing, and guards against signature replay.
+ *
+ * @typeParam Types - Map of type names to arrays of { name, type } definitions.
+ * @typeParam Msg - Object whose shape matches the primaryType fields.
+ *
+ * @param domain - EIP712Domain, e.g. { name, version, chainId, verifyingContract }.
+ * @param types - Type definitions, e.g.:
+ *   {
+ *     Mail: [ { name: 'from', type: 'string' }, { name: 'contents', type: 'string' } ],
+ *   }
+ * @param primaryType - Root key in types, e.g. 'Mail'.
+ * @param message - The actual values, e.g. { from: 'Alice', contents: 'Hello' }.
+ *
+ * @returns TypedData object ready for use with signing libraries.
+ *
+ * Example:
+ * ```typescript
+ * const typedData = buildTypedData(
+ *   { name: 'MyDApp', version: '1', chainId: 1, verifyingContract: '0xabc...' },
+ *   { Message: [{ name: 'text', type: 'string' }] },
+ *   'Message',
+ *   { text: 'Hello, EIP-712!' }
+ * )
+ * // Pass typedData to ethers.js signer._signTypedData(domain, types, message)
+ * ```
+ */
+function buildTypedData(domain, types, primaryType, message) {
+    return { domain, types, primaryType, message };
+}
+
+/**
+ * Compute default deadline for permit signatures.
+ *
+ * Returns a timestamp 1 hour (3600 seconds) from the current time,
+ * converted to Unix timestamp format as a bigint. This is commonly
+ * used as the default expiration time for EIP-2612 permit signatures.
+ *
+ * @returns Unix timestamp (in seconds) 1 hour from now as a bigint
+ *
+ * @example
+ * ```typescript
+ * import { computeDefaultDeadline } from '@core/adapter-evm'
+ *
+ * const deadline = computeDefaultDeadline()
+ * console.log(`Permit expires at: ${deadline}`)
+ * // Output: Permit expires at: 1640998800
+ * ```
+ */
+function computeDefaultDeadline() {
+    return BigInt(Math.floor(Date.now() / 1000) + 3600);
+}
+
+/**
+ * EIP-2612 permit type definition.
+ * Defines the structure for permit signatures according to EIP-2612 specification.
+ *
+ * @see {@link https://eips.ethereum.org/EIPS/eip-2612 | EIP-2612 Specification}
+ */
+const EIP2612_TYPES = {
+    Permit: [
+        { name: 'owner', type: 'address' },
+        { name: 'spender', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'deadline', type: 'uint256' },
+    ],
+};
+
+/**
+ * Build EIP-2612 typed data for permit signing.
+ *
+ * This function creates the complete EIP-712 typed data structure required
+ * for EIP-2612 permit signatures, including automatic nonce fetching using
+ * the adapter's built-in nonce fetching capability.
+ *
+ * **Address Formatting**: All addresses are automatically formatted with proper
+ * EIP-55 checksumming using the `convertAddress` utility, ensuring compatibility
+ * with strict validation libraries like viem.
+ *
+ * **Nonce Handling**: The nonce can be provided explicitly or will be fetched
+ * automatically using the adapter's `fetchEIP2612Nonce` method, which queries
+ * the token contract's `nonces(owner)` function.
+ *
+ * **Deadline Calculation**: If no deadline is provided, it defaults to 24 hours
+ * from the current time (computed using `computeDefaultDeadline`).
+ *
+ * @param meta - Domain metadata for the token contract
+ * @param adapter - Adapter instance with nonce-fetching capability
+ * @param opts - EIP-2612 permit options including owner, spender, value
+ * @returns Complete EIP-712 typed data ready for signing
+ *
+ * @example
+ * ```typescript
+ * import { buildEIP2612TypedData } from '@core/adapter-evm'
+ *
+ * const typedData = await buildEIP2612TypedData(
+ *   {
+ *     name: 'USD Coin',
+ *     version: '2',
+ *     chainId: 1,
+ *     verifyingContract: '0xa0b86a33e6441e4d178bb0c14ce0e9ce9c83bdd8'
+ *   },
+ *   adapter,
+ *   {
+ *     owner: '0x742d35cc6639c0532fbe9002b3a2265ca4c878f8e',
+ *     spender: '0x1234567890123456789012345678901234567890',
+ *     value: 1000000n
+ *   }
+ * )
+ *
+ * const signature = await adapter.signTypedData(typedData)
+ * ```
+ */
+async function buildEIP2612TypedData(meta, adapter, opts, ctx) {
+    // Format addresses to ensure proper EIP-55 checksumming
+    const formattedOwner = convertAddress(opts.owner, 'evm');
+    const formattedSpender = convertAddress(opts.spender, 'evm');
+    const formattedContract = convertAddress(meta.verifyingContract, 'evm');
+    // Fetch nonce if not provided - adapter handles the contract interaction
+    const nonce = opts.nonce ??
+        (await adapter.fetchEIP2612Nonce(formattedContract, formattedOwner, ctx));
+    /*
+     * Calculate deadline if not provided (24 hours from now)
+     * EIP-2612 deadline is a uint256 in the permit struct, so we use bigint for full compatibility
+     * with on-chain values and to avoid overflow/precision issues with large timestamps.
+     * Most real-world deadlines are within JS safe integer range, but using bigint is safest.
+     */
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const deadline = opts.deadline !== undefined
+        ? BigInt(opts.deadline)
+        : computeDefaultDeadline();
+    if (deadline <= now) {
+        throw new Error(`EIP-2612 deadline must be in the future (got ${deadline.toString()}, now ${now.toString()})`);
+    }
+    // Build the message with properly formatted addresses
+    const message = {
+        owner: formattedOwner,
+        spender: formattedSpender,
+        value: opts.value,
+        nonce,
+        deadline,
+    };
+    // Return complete typed data structure with formatted contract address
+    return buildTypedData({ ...meta, verifyingContract: formattedContract }, EIP2612_TYPES, 'Permit', message);
+}
+
 /**
  * Checks if a function in an ABI is read-only (view or pure).
  *
@@ -8444,7 +8669,6 @@ const abiSchema = z
  * - A chainType property set to 'evm'
  * - An actionRegistry with registerHandlers method and actionHandlers record
  * - A prepare method for creating chain requests
- * - A getChain method for retrieving chain configuration
  *
  * @throws \{ValidationError\} If validation fails, with details about which properties failed
  *
@@ -8461,7 +8685,6 @@ const abiSchema = z
  *     }
  *   },
  *   prepare: async (request: any) => ({}),
- *   getChain: async () => ({ name: 'Ethereum', type: 'evm' as const })
  * }
  *
  * const result = evmAdapterSchema.safeParse(validAdapter)
@@ -8563,6 +8786,44 @@ const evmTransactionHashSchema = z
     .refine((hash) => /^0x[0-9a-fA-F]{64}$/.test(hash), (hash) => ({
     message: `Transaction hash "${hash}" contains invalid characters. Only hexadecimal characters (0-9, a-f, A-F) are allowed after '0x'.`,
 }));
+/**
+ * Zod schema for validating EVM private keys.
+ *
+ * This schema validates private key strings to ensure they are properly formatted:
+ * - Accepts private keys with or without '0x' prefix
+ * - Automatically normalizes by adding '0x' prefix if missing
+ * - Validates that the key is exactly 64 hexadecimal characters (32 bytes)
+ * - Ensures only valid hexadecimal characters (0-9, a-f, A-F) are used
+ *
+ * @remarks
+ * This is a shared schema used by both ethers.v6 and viem.v2 adapters to ensure
+ * consistent private key validation across all EVM adapters.
+ *
+ * @throws \{ValidationError\} If validation fails, with details about the issue
+ *
+ * @example
+ * ```typescript
+ * import { evmPrivateKeySchema } from '@core/adapter-evm/validation'
+ *
+ * // Both formats are accepted and normalized
+ * const keyWithPrefix = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+ * const keyWithoutPrefix = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
+ *
+ * const result1 = evmPrivateKeySchema.safeParse(keyWithPrefix)
+ * const result2 = evmPrivateKeySchema.safeParse(keyWithoutPrefix)
+ *
+ * // Both succeed and produce the same normalized result with '0x' prefix
+ * ```
+ */
+const evmPrivateKeySchema = z
+    .string({
+    required_error: 'Private key is required. Please provide a valid private key.',
+    invalid_type_error: 'Private key must be a string. Please provide a valid private key.',
+})
+    .transform((val) => (val.startsWith('0x') ? val : `0x${val}`))
+    .pipe(z.string().regex(/^0x[0-9a-fA-F]{64}$/, {
+    message: 'Private key must be a valid 64-character hex string. Please provide a valid private key with or without "0x" prefix.',
+}));
 
 const assertEvmPreparedChainRequestParamsSymbol = Symbol('assertEvmPreparedChainRequestParams');
 /**
@@ -9331,7 +9592,7 @@ const ethersAdapterOptionsSchema = z.object({
  * Zod schema for validating parameters to create an EthersAdapter from a private key.
  *
  * @remarks
- * - `privateKey` must be a string starting with "0x" and 64 hexadecimal characters.
+ * - `privateKey` can be provided with or without the "0x" prefix. The schema automatically normalizes keys by adding the "0x" prefix if missing before validation.
  * - `getProvider` is optional and, if provided, must be a function accepting an object with a `chain` parameter and returning any value.
  * - `capabilities` is optional and allows partial overrides with smart defaults.
  *
@@ -9339,27 +9600,22 @@ const ethersAdapterOptionsSchema = z.object({
  * ```typescript
  * import { createAdapterFromPrivateKeyParamsSchema } from '@circle-fin/adapter-ethers-v6/validation'
  *
- * const params = {
+ * // Both formats are supported:
+ * const paramsWithPrefix = {
  *   privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
  * }
  *
- * const result = createAdapterFromPrivateKeyParamsSchema.safeParse(params)
- * if (result.success) {
- *   console.log('Parameters are valid')
- * } else {
- *   console.error('Validation failed:', result.error)
+ * const paramsWithoutPrefix = {
+ *   privateKey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
  * }
+ *
+ * const result1 = createAdapterFromPrivateKeyParamsSchema.safeParse(paramsWithPrefix)
+ * const result2 = createAdapterFromPrivateKeyParamsSchema.safeParse(paramsWithoutPrefix)
+ * // Both succeed and produce the same normalized result
  * ```
  */
 const createAdapterFromPrivateKeyParamsSchema = z.object({
-    privateKey: z
-        .string({
-        required_error: 'Private key is required. Please provide a valid private key.',
-        invalid_type_error: 'Private key must be a string. Please provide a valid private key.',
-    })
-        .regex(/^0x[0-9a-fA-F]{64}$/, {
-        message: 'Private key must be a 64-character hexadecimal string prefixed with "0x".',
-    }),
+    privateKey: evmPrivateKeySchema,
     getProvider: z
         .function()
         .args(z.object({ chain: z.unknown() }))
@@ -9468,28 +9724,6 @@ z.object({
 function validateEthersAdapterOptions(options) {
     validate(options, ethersAdapterOptionsSchema, 'EthersAdapterOptions');
 }
-/**
- * Validates parameters for creating an Ethers adapter from a private key.
- *
- * This function validates the parameters used by the createAdapterFromPrivateKey
- * factory function for the Ethers adapter.
- *
- * @param params - The parameters to validate. Must include a `privateKey` string and optionally a `getProvider` function and `capabilities`.
- * @throws \{ValidationError\} If validation fails.
- * @example
- * ```typescript
- * import { validateCreateAdapterFromPrivateKeyParams } from '@circle-fin/adapter-ethers-v6/validation'
- *
- * const params = {
- *   privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
- * }
- *
- * validateCreateAdapterFromPrivateKeyParams(params) // throws if invalid
- * ```
- */
-function validateCreateAdapterFromPrivateKeyParams(params) {
-    validate(params, createAdapterFromPrivateKeyParamsSchema, 'CreateAdapterFromPrivateKeyParams');
-}
 /**
  * Validates parameters for creating an Ethers adapter from an EIP-1193 provider.
  *
@@ -10035,6 +10269,11 @@ class EthersAdapter extends EvmAdapter {
      * ```
      */
     async getAddress(chain) {
+        // Prevent calling getAddress on developer-controlled adapters
+        if (this.capabilities?.addressContext === 'developer-controlled') {
+            throw new Error('Cannot call getAddress() on developer-controlled adapters. ' +
+                'Address must be provided explicitly in the operation context.');
+        }
         // Chain parameter should now be provided by resolveOperationContext
         if (!chain) {
             throw new Error('Chain parameter is required for address resolution. ' +
@@ -10046,45 +10285,6 @@ class EthersAdapter extends EvmAdapter {
         const address = await signer.getAddress();
         return address;
     }
-    /**
-     * Gets the current chain definition.
-     *
-     * TEMP This method is temporary and will be removed once all adapters migrate to the OperationContext pattern.
-     *
-     * **Migration Guide:**
-     *
-     * With the OperationContext pattern, chain information is provided explicitly in each operation
-     * rather than queried from the adapter. This eliminates ambiguity and enables seamless multi-chain
-     * operations with a single adapter instance.
-     *
-     * **Before (Deprecated):**
-     * ```typescript
-     * const chain = await adapter.getChain()
-     * const prepared = await adapter.prepare(params) // Uses cached chain
-     * ```
-     *
-     * **After (OperationContext):**
-     * ```typescript
-     * // Chain specified explicitly per operation
-     * const prepared = await adapter.prepare(params, { chain: 'Ethereum' })
-     *
-     * // Multi-chain operations with same adapter
-     * const ethPrepared = await adapter.prepare(params, { chain: 'Ethereum' })
-     * const basePrepared = await adapter.prepare(params, { chain: 'Base' })
-     * ```
-     *
-     * @returns A promise that resolves to the first supported chain from capabilities
-     * @throws Error when no supported chains are configured
-     */
-    async getChain() {
-        // Fallback: return first supported chain (deprecated - only for backward compatibility)
-        const firstChain = this.capabilities?.supportedChains?.[0];
-        if (!firstChain) {
-            throw new Error('No supported chains configured. ' +
-                'This method is deprecated - use OperationContext pattern instead.');
-        }
-        return await Promise.resolve(firstChain);
-    }
     /**
      * Waits for a transaction to be mined and confirmed on the blockchain.
      *
@@ -10359,16 +10559,17 @@ class EthersAdapter extends EvmAdapter {
  * ```typescript
  * import { createAdapterFromPrivateKey } from '@circle-fin/adapter-ethers-v6'
  *
- * // Minimal configuration with lazy initialization
- * const adapter = createAdapterFromPrivateKey({
- *   privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'
- *   // Defaults applied:
- *   // - addressContext: 'user-controlled'
- *   // - supportedChains: all EVM chains (~29 networks)
+ * // Both private key formats are supported (with or without '0x' prefix):
+ * const adapter1 = createAdapterFromPrivateKey({
+ *   privateKey: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef' // With prefix
+ * })
+ *
+ * const adapter2 = createAdapterFromPrivateKey({
+ *   privateKey: '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef' // Without prefix (automatically normalized)
  * })
  *
  * // Chain specified per-operation via OperationContext
- * const prepared = await adapter.prepare({
+ * const prepared = await adapter1.prepare({
  *   address: '0x...',
  *   abi: contractAbi,
  *   functionName: 'transfer',
@@ -10427,9 +10628,9 @@ class EthersAdapter extends EvmAdapter {
  * ```
  */
 function createAdapterFromPrivateKey(params) {
-    // Validate input parameters at runtime
-    validateCreateAdapterFromPrivateKeyParams(params);
-    const { privateKey, getProvider, capabilities } = params;
+    // Parse and validate input parameters at runtime (normalizes the private key by adding '0x' prefix if missing)
+    const { privateKey } = createAdapterFromPrivateKeyParamsSchema.parse(params);
+    const { getProvider, capabilities } = params;
     // Resolve capabilities with default configuration
     const resolvedCapabilities = createAdapterCapabilities('evm', capabilities);
     // Validate that capabilities are appropriate for private key adapters
@@ -10444,6 +10645,7 @@ function createAdapterFromPrivateKey(params) {
     const getProviderFn = getProvider ?? getDefaultProviderUtil(new Map());
     // Create wallet WITHOUT provider (lazy initialization)
     // The wallet will be connected to a provider when ensureChain is called
+    // Type assertion safe because we normalized the private key in the schema
     const wallet = new Wallet(privateKey);
     // Create and return the adapter
     return new EthersAdapter({
@@ -10552,13 +10754,13 @@ function createAdapterFromPrivateKey(params) {
  * ```typescript
  * // Cross-chain transfer using a single adapter
  * import { createAdapterFromProvider } from '@circle-fin/adapter-ethers-v6'
- * import { BridgingKit } from '@circle-fin/bridging-kit'
+ * import { BridgeKit } from '@circle-fin/bridge-kit'
  *
  * const adapter = await createAdapterFromProvider({
  *   provider: window.ethereum
  * })
  *
- * const kit = new BridgingKit()
+ * const kit = new BridgeKit()
  *
  * // Use the same adapter for both source and destination
  * const result = await kit.bridge({
@@ -10621,5 +10823,5 @@ const createAdapterFromProvider = async (params) => {
     }, resolvedCapabilities);
 };
 
-export { EthersAdapter, createAdapterFromPrivateKey, createAdapterFromProvider, validateAdapterCapabilities };
+export { Blockchain, EthersAdapter, buildEIP2612TypedData, computeDefaultDeadline, createAdapterFromPrivateKey, createAdapterFromProvider, parseSignature, validateAdapterCapabilities };
 //# sourceMappingURL=index.mjs.map