@circle-fin/bridge-kit 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,109 @@
+# @circle-fin/bridge-kit
+
+## 1.1.1
+
+### Patch Changes
+
+- Fix CommonJS compatibility by correcting file extensions and package exports. This resolves a "ReferenceError: require is not defined" error that occurred when using packages in CommonJS projects with ts-node.
+
+- Fixes a bug where the `recipientAddress` field in the `to` parameter was not being properly propagated to the underlying CCTP v2 provider. This caused custom recipient addresses to be ignored during cross-chain USDC transfers, resulting in funds being minted to the signer's address instead of the intended recipient.
+
+  With this fix, when you specify a `recipientAddress` in the `to` parameter, the Bridge Kit now correctly passes it through to the provider, ensuring funds are minted to the correct address.
+
+  **Example usage** (no changes needed if already using this pattern):
+
+  ```typescript
+  await kit.bridge({
+    from: { adapter: sourceAdapter, chain: 'Ethereum' },
+    to: {
+      adapter: destAdapter,
+      chain: 'Base',
+      recipientAddress: '0x...', // Now properly respected
+    },
+    amount: '10',
+    token: 'USDC',
+  })
+  ```
+
+  **No breaking changes** - existing code without `recipientAddress` continues to work unchanged. This fix only affects transfers where you explicitly provide a custom recipient address.
+
+## 1.1.0
+
+### Minor Changes
+
+- Add automatic HTTP request tracking for analytics and debugging. The kit now automatically registers itself when the module loads, enabling Circle to track kit usage and identify issues. Applications can optionally set an external prefix using the new `setExternalPrefix` function to identify themselves in request analytics. All HTTP requests from the kit will include user agent information in the format: `[app/version] bridge-kit/version (runtime)`. This feature requires no code changes for existing users.
+
+### Patch Changes
+
+- Standardize `maxFee` parameter to accept human-readable values. The `maxFee` parameter in `BridgeConfig` now correctly accepts human-readable token amounts (e.g., `"1"` for 1 USDC, `"0.5"` for 0.5 USDC), matching the behavior of `customFee.value`. This resolves an undocumented inconsistency in the API. If you were previously passing values in smallest units, update to human-readable format: use `"1"` instead of `"1000000"` for 1 USDC.
+- Complete CCTP v2 chain support exports
+
+  Ensures all 35 chains with CCTP v2 support are properly exported from the `chains` entry point. This fix adds previously missing chain definitions including Codex, HyperEVM, Ink, Plume, Sei, Sonic, Unichain, WorldChain, and XDC networks (both mainnet and testnet variants where applicable).
+
+- Add support for Arc Testnet chain definition. Arc is Circle's EVM-compatible Layer-1 blockchain designed for stablecoin finance and asset
+  tokenization, featuring USDC as the native gas token and sub-second finality via the Malachite BFT consensus engine.
+- Fix support for developer-controlled address context. Bridge operations now correctly accept an explicit `address` field in the context, allowing developer-controlled adapters to specify which address to use for operations. Previously, this field was incorrectly rejected at runtime.
+- Update Sonic Testnet chain definition to canonical network. The `SonicTestnet` chain definition now points to the official Sonic Testnet (chainId: 14601) instead of the deprecated Sonic Blaze Testnet (chainId: 57054). The RPC endpoint has been updated to `https://rpc.testnet.soniclabs.com`, the display name simplified to "Sonic Testnet", and the USDC contract address updated to the new deployment.
+
+  **Breaking Changes:**
+  - **Chain ID:** 57054 → 14601
+  - **RPC Endpoint:** `https://rpc.blaze.soniclabs.com` → `https://rpc.testnet.soniclabs.com`
+  - **USDC Address:** `0xA4879Fed32Ecbef99399e5cbC247E533421C4eC6` → `0x0BA304580ee7c9a980CF72e55f5Ed2E9fd30Bc51`
+
+  **Migration:** If you were using `SonicTestnet`, your application will automatically connect to the new network upon upgrading. Any accounts, contracts, or transactions on the old Blaze testnet (chainId: 57054) will need to be recreated on the new testnet.
+
+## 1.0.0
+
+### Major Changes
+
+- # Bridge Kit 1.0.0 Release 🎉
+
+  The core orchestration library for cross-chain USDC transfers - providing a unified, type-safe interface for bridging USDC between heterogeneous blockchain networks.
+
+  ## 🚀 Core Features
+  - **Complete Cross-chain Orchestration**: High-level API for USDC transfers between any supported chains
+  - **Type-safe APIs**: Exhaustive runtime validation with strict TypeScript support
+  - **Deterministic Operations**: Pre-flight simulations and predictable quote generation
+  - **Comprehensive Finality Tracking**: Monitor transfer progress across all bridge steps
+
+  ## 🔄 Intelligent Retry System
+
+  Sophisticated retry mechanism that automatically handles failed or incomplete transfers:
+  - **Automatic Recovery**: Resume transfers from the exact point of failure
+  - **Step Analysis**: Intelligent detection of which operations completed successfully
+  - **Network Resilience**: Handle temporary connectivity issues and gas estimation failures
+  - **Multi-step Flow Support**: Retry complex bridge operations involving multiple blockchain transactions
+
+  ```typescript
+  // Retry a failed transfer with fresh adapter instances
+  const retryResult = await kit.retry(failedResult, {
+    from: sourceAdapter,
+    to: destAdapter,
+  })
+  ```
+
+  ## 💰 Flexible Fee Management
+
+  Comprehensive fee system supporting both protocol fees and custom integrator fees:
+  - **Transfer Speed Options**: Choose between FAST (with fees) and SLOW (fee-free) transfers
+  - **Dynamic Fee Calculation**: Automatic fee estimation based on transfer amount and network conditions
+  - **Custom Fee Policies**: Implement your own fee structures with absolute amounts
+  - **Multi-chain Fee Support**: Different fee configurations per source chain
+  - **Fee Recipient Control**: Specify where fees are sent on the source chain
+
+  ```typescript
+  // Set custom fee policy
+  kit.setCustomFeePolicy({
+    calculateFee: (params) =>
+      params.from.chain.type === 'solana' ? '0.1' : '0.2',
+    resolveFeeRecipientAddress: (chain) => getFeeRecipientForChain(chain),
+  })
+  ```
+
+  ## 🎯 Use Cases
+  - **Multi-chain dApp Integration**: Single SDK for all cross-chain USDC needs
+  - **Wallet Integration**: Seamless cross-chain transfers for end users
+  - **Exchange Integration**: Institutional-grade cross-chain USDC movement
+  - **DeFi Protocol Integration**: Bridge USDC liquidity across ecosystems
+
+  This release provides the foundational orchestration layer for cross-chain USDC applications with production-ready reliability and comprehensive developer tooling.

package/QUICKSTART.md

@@ -13,6 +13,7 @@ Welcome to the Bridge Kit! This guide will help you understand the ecosystem and
 - [Event Handling](#event-handling)
 - [Supported Chains](#supported-chains)
 - [Error Handling](#error-handling)
+- [Retry Guide: Resuming Failed Transfers](#retry-guide-resuming-failed-transfers)
 - [Troubleshooting](#troubleshooting)
 - [Best Practices](#best-practices)
 - [Next Steps](#next-steps)
@@ -514,11 +515,12 @@ Customize your transfer behavior with the `config` parameter:
 interface BridgeConfig {
   transferSpeed: 'FAST' | 'SLOW' // Default: 'FAST'
   /**
-   * The maximum bridging fee you're willing to pay (in smallest units for that chain).
+   * The maximum bridging fee you're willing to pay in human-readable format.
+   * For example: "1" for 1 USDC, "0.5" for 0.5 USDC.
    * You should only set this parameter if speed is set to FAST.
    * If this value ends up being less than the protocol fee, the bridge flow will be executed as a SLOW transfer.
    */
-  maxFee?: string // Optional: maximum fee in smallest units
+  maxFee?: string // Optional: maximum fee (e.g., "1" for 1 USDC)
 }
 ```
 
@@ -714,7 +716,7 @@ const result2 = await kit.bridge({
     recipientAddress: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
   },
   amount: '100.0',
-  config: { transferSpeed: 'FAST', maxFee: '1000000' },
+  config: { transferSpeed: 'FAST', maxFee: '1' }, // 1 USDC maximum fee
 })
 ```
 
@@ -722,7 +724,7 @@ const result2 = await kit.bridge({
 
 ## Event Handling
 
-Events allow you to subscribe to different parts of the briding lifecycle and respond to them however you want. Events match up 1-1 to actions that are taken by the Bridge Kit: **'approve', 'burn', 'attestsion', and 'mint'** are the events you can subscribe to, or you can use **'\*'** to subscribe to all events.
+Events allow you to subscribe to different parts of the briding lifecycle and respond to them however you want. Events match up 1-1 to actions that are taken by the Bridge Kit: **'approve', 'burn', 'fetchAttestation', and 'mint'** are the events you can subscribe to, or you can use **'\*'** to subscribe to all events.
 
 Each event can also be subscribed to multiple times with different callbacks.
 
@@ -740,19 +742,19 @@ kit.on('*', (event) => {
 
 // Listen to specific events
 kit.on('approve', (event) => {
-  console.log('Approval completed:', event.txHash)
+  console.log('Approval completed:', event.values.txHash)
 })
 
 kit.on('burn', (event) => {
-  console.log('Burn completed:', event.txHash)
+  console.log('Burn completed:', event.values.txHash)
 })
 
-kit.on('attestation', (event) => {
-  console.log('Attestation received:', event.attestation)
+kit.on('fetchAttestation', (event) => {
+  console.log('Attestation received:', event.values.data)
 })
 
 kit.on('mint', (event) => {
-  console.log('Mint completed:', event.txHash)
+  console.log('Mint completed:', event.values.txHash)
 })
 ```
 
@@ -792,7 +794,169 @@ For recoverable issues during transfer execution, the kit returns a result objec
 
 This approach gives you full control over recovery scenarios while preventing unexpected crashes.
 
-> **Note**: In the future, we will be adding capabilities to continue from a certain point in the bridging lifecycle to accomodate soft error cases.
+> **Note**: You can resume actionable failures using `BridgeKit.retry(result, context)`. See the Retry Guide below.
+
+## Retry Guide: Resuming Failed Transfers
+
+Use `kit.retry(result, context)` to resume failed or incomplete transfers when the failure is actionable (e.g., transient network issues, dropped/repriced transactions, or a failed step in a multi-step flow). The kit delegates retry to the original provider (CCTPv2 supports actionable retries) and continues from the correct step.
+
+### Method signature
+
+```typescript
+retry<
+  TFromAdapterCapabilities extends AdapterCapabilities,
+  TToAdapterCapabilities extends AdapterCapabilities
+>(
+  result: BridgeResult,
+  context: RetryContext<TFromAdapterCapabilities, TToAdapterCapabilities>
+): Promise<BridgeResult>
+```
+
+### When to retry vs manual intervention
+
+- Retry: transient RPC/network errors; gas repricing; step failed but prior steps succeeded.
+- Manual: insufficient funds; wrong recipient; unsupported route; errors indicating non-actionable state.
+
+### Example A: EVM → EVM retry (Ethereum Sepolia → Base Sepolia)
+
+```typescript
+import { BridgeKit } from '@circle-fin/bridge-kit'
+import { createAdapterFromPrivateKey } from '@circle-fin/adapter-viem-v2'
+
+const kit = new BridgeKit()
+const adapter = createAdapterFromPrivateKey({
+  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
+})
+
+// Start a transfer that may fail
+const result = await kit.bridge({
+  from: { adapter, chain: 'Ethereum_Sepolia' },
+  to: { adapter, chain: 'Base_Sepolia' },
+  amount: '1',
+})
+
+if (result.state === 'error') {
+  try {
+    const retryResult = await kit.retry(result, { from: adapter, to: adapter })
+    console.log('Retry state:', retryResult.state)
+    console.log('Steps:', retryResult.steps)
+  } catch (error) {
+    console.error('Retry failed:', error)
+  }
+}
+```
+
+### Example B: EVM → Solana retry (Ethereum → Solana Devnet)
+
+```typescript
+import { BridgeKit } from '@circle-fin/bridge-kit'
+import { createAdapterFromPrivateKey as createEvmAdapter } from '@circle-fin/adapter-viem-v2'
+import { createAdapterFromPrivateKey as createSolAdapter } from '@circle-fin/adapter-solana'
+
+const kit = new BridgeKit()
+const evm = createEvmAdapter({
+  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
+})
+const sol = createSolAdapter({
+  privateKey: process.env.SOL_PRIVATE_KEY as string,
+})
+
+const result = await kit.bridge({
+  from: { adapter: evm, chain: 'Ethereum' },
+  to: { adapter: sol, chain: 'Solana' },
+  amount: '1',
+})
+
+// Check if the bridge failed and retry if needed
+if (result.state === 'error') {
+  try {
+    const retryResult = await kit.retry(result, { from: evm, to: sol })
+    console.log('Retry state:', retryResult.state)
+  } catch (error) {
+    console.error('Retry failed:', error)
+  }
+}
+```
+
+### Limitations
+
+- Only actionable failures can be retried; some failures require user action first.
+- Provide valid adapters for both `from` and `to` contexts.
+
+### Common Retry Scenarios
+
+#### 1) Transient RPC/network timeout (use backoff)
+
+```typescript
+import { BridgeKit, BridgeResult } from '@circle-fin/bridge-kit'
+import { createAdapterFromPrivateKey } from '@circle-fin/adapter-viem-v2'
+
+const kit = new BridgeKit()
+const adapter = createAdapterFromPrivateKey({
+  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
+})
+
+async function retryWithBackoff(result: BridgeResult) {
+  let attempt = 0
+  const maxAttempts = 5
+  const baseDelayMs = 1000
+
+  while (attempt < maxAttempts) {
+    try {
+      return await kit.retry(result, { from: adapter, to: adapter })
+    } catch (error) {
+      attempt++
+      if (attempt >= maxAttempts) throw error
+      const delay = baseDelayMs * 2 ** (attempt - 1)
+      await new Promise((r) => setTimeout(r, delay))
+    }
+  }
+}
+```
+
+#### 2) Burn succeeded, attestation pending (wait, then retry)
+
+```typescript
+// If failure indicates attestation delay, wait/poll before retrying
+if (result.state === 'error') {
+  const burnStep = result.steps.find((s) => s.name === 'burn')
+  const attestationStep = result.steps.find(
+    (s) => s.name === 'fetchAttestation',
+  )
+
+  if (burnStep?.state === 'success' && attestationStep?.state !== 'success') {
+    // Wait a bit for attestation availability (example: 30 seconds)
+    await new Promise((r) => setTimeout(r, 30_000))
+  }
+
+  const retryResult = await kit.retry(result, { from: adapter, to: adapter })
+  console.log('Retry state:', retryResult.state)
+}
+```
+
+#### 3) Mint failed due to gas (EVM gas repricing), then retry
+
+```typescript
+// If the mint step failed on destination chain (EVM), reprice and retry
+const mintStep = result.steps.find((s) => s.name === 'mint')
+if (result.state === 'error' && mintStep?.state === 'error') {
+  // Recreate destination adapter with updated gas settings as needed
+  const dest = createAdapterFromPrivateKey({
+    privateKey: process.env.PRIVATE_KEY as `0x${string}`,
+    // Provide a higher-priority RPC or adjust client gas policies here if supported by your setup
+  })
+
+  const retryResult = await kit.retry(result, { from: adapter, to: dest })
+  console.log('Retry state:', retryResult.state)
+}
+```
+
+### Performance and best practices
+
+- Backoff on transient failures (2s, 4s, 8s...).
+- Reprice gas sensibly when congestion is high.
+- Persist `result.steps` and transaction hashes for observability.
+- Log and monitor both source and destination tx hashes.
 
 ## Troubleshooting
 
@@ -889,7 +1053,7 @@ const publicClient = createPublicClient({
 
 When transfers encounter soft errors (network congestion, insufficient gas, RPC timeouts), you can recover by using the CCTPv2BridgingProvider directly to complete the remaining steps. The BridgeKit's transfer result contains enough information to resume from any point.
 
-> **🚀 Coming Soon**: We're working on built-in recovery functionality that will allow you to pass the current transfer state directly to `kit.resume(bridgeResult)` for automatic retry logic. For now, you can use the manual recovery patterns below.
+> **Note**: You can resume actionable failures using `BridgeKit.retry(result, context)` to automatically continue from the correct step. For non-actionable cases, use the manual recovery patterns below.
 
 #### Understanding Transfer State
 

package/README.md

@@ -37,6 +37,7 @@ _Making cross-chain stablecoin (USDC, and soon more tokens) transfers as simple
     - [Complete Example with All Options](#complete-example-with-all-options)
     - [Bridge Speed Configuration](#bridge-speed-configuration)
   - [Error Handling](#error-handling)
+  - [Retrying Failed Transfers](#retrying-failed-transfers)
   - [Examples](#examples)
     - [Basic Bridge Operation](#basic-bridge-operation)
     - [EVM to Non-EVM Bridge (EVM ↔ Solana)](#evm-to-non-evm-bridge-evm--solana)
@@ -394,12 +395,80 @@ if (result.state === 'success') {
 }
 ```
 
+## Retrying Failed Transfers
+
+Use `BridgeKit.retry` to resume failed or incomplete bridge operations when the failure is actionable (e.g., transient RPC issues, dropped transactions, or a failed step in a multi-step flow). The kit delegates retry to the original provider (CCTPv2 supports actionable retries) and continues from the appropriate step.
+
+### Method signature
+
+```typescript
+retry<
+  TFromAdapterCapabilities extends AdapterCapabilities,
+  TToAdapterCapabilities extends AdapterCapabilities
+>(
+  result: BridgeResult,
+  context: RetryContext<TFromAdapterCapabilities, TToAdapterCapabilities>
+): Promise<BridgeResult>
+```
+
+### Basic usage (EVM → EVM)
+
+```typescript
+import { BridgeKit } from '@circle-fin/bridge-kit'
+import { createAdapterFromPrivateKey } from '@circle-fin/adapter-viem-v2'
+
+const kit = new BridgeKit()
+const adapter = createAdapterFromPrivateKey({
+  privateKey: process.env.PRIVATE_KEY as `0x${string}`,
+})
+
+const result = await kit.bridge({
+  from: { adapter, chain: 'Ethereum_Sepolia' },
+  to: { adapter, chain: 'Base_Sepolia' },
+  amount: '1',
+})
+
+if (result.state === 'error') {
+  try {
+    const retryResult = await kit.retry(result, { from: adapter, to: adapter })
+    console.log('Retry state:', retryResult.state)
+  } catch (error) {
+    console.error('Retry failed:', error)
+  }
+}
+```
+
+### When to retry vs manual intervention
+
+- Retry: transient network/RPC errors, gas repricing/dropped txs, step failure with progress recorded.
+- Manual: insufficient funds, incorrect recipient, unsupported route, or errors indicating non-actionable state.
+
+### Limitations
+
+- Only actionable failures can be retried; some failures require user action first.
+- Source and destination chains must still be supported by the provider (CCTPv2).
+- Provide valid adapters for both `from` and `to` contexts.
+
+### Performance and best practices
+
+- Use exponential backoff on transient failures; avoid rapid replay.
+- Reprice gas sensibly on congested networks.
+- Persist `result.steps` and tx hashes to aid observability and support.
+
+### Troubleshooting
+
+- "Retry not supported for this result, requires user action": fix balances/addresses/attestation issues and try again.
+- "Provider not found": ensure the same provider (e.g., CCTPv2) is present in `BridgeKit` configuration.
+
+> See a runnable example at `examples/basic-usdc-transfer/src/retry.ts` (script: `yarn start:retry`).
+
 ## API Reference
 
 ### Core Methods
 
 - `kit.bridge(params)` - Execute cross-chain bridge operation
 - `kit.estimate(params)` - Get cost estimates before bridging
+- `kit.retry(result, context)` - Resume actionable failed/partial transfers
 - `kit.supportsRoute(source, destination, token)` - Check route support
 - `kit.on(event, handler)` - Listen to bridge events
 - `kit.off(event, handler)` - Removes the listener from bridge events
@@ -415,8 +484,12 @@ interface BridgeParams {
   config?: BridgeConfig // Optional bridge configuration (e.g., transfer speed). If omitted, defaults will be used
 }
 
-// AdapterContext: Your blockchain connection (always explicit)
-type AdapterContext = { adapter: Adapter; chain: ChainIdentifier }
+// AdapterContext: Your blockchain connection
+type AdapterContext = {
+  adapter: Adapter
+  chain: ChainIdentifier
+  address?: string // Required for developer-controlled adapters; forbidden for user-controlled
+}
 
 // BridgeDestination: Where funds go
 type BridgeDestination =
@@ -450,7 +523,10 @@ nx test @circle-fin/bridge-kit
 # Install dependencies
 yarn install
 
-# Build the project
+# Build all packages
+yarn build
+
+# Build the bridge-kit specifically
 nx build @circle-fin/bridge-kit
 
 # Run tests

package/{chains.cjs.js → chains.cjs}

@@ -35,6 +35,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";
@@ -255,6 +256,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
@@ -784,7 +827,7 @@ defineChain({
  * HyperEVM is a Layer 1 blockchain specialized for DeFi and trading applications
  * with native orderbook and matching engine.
  */
-defineChain({
+const HyperEVM = defineChain({
     type: 'evm',
     chain: Blockchain.HyperEVM,
     name: 'HyperEVM',
@@ -823,7 +866,7 @@ defineChain({
  * This represents the official testnet for the HyperEVM blockchain.
  * Used for development and testing purposes before deploying to mainnet.
  */
-defineChain({
+const HyperEVMTestnet = defineChain({
     type: 'evm',
     chain: Blockchain.HyperEVM_Testnet,
     name: 'HyperEVM Testnet',
@@ -863,7 +906,7 @@ defineChain({
  * Ink is a Layer 1 blockchain specialized for DeFi and trading applications
  * with native orderbook and matching engine.
  */
-defineChain({
+const Ink = defineChain({
     type: 'evm',
     chain: Blockchain.Ink,
     name: 'Ink',
@@ -905,7 +948,7 @@ defineChain({
  * This represents the official testnet for the Ink blockchain.
  * Used for development and testing purposes before deploying to mainnet.
  */
-defineChain({
+const InkTestnet = defineChain({
     type: 'evm',
     chain: Blockchain.Ink_Testnet,
     name: 'Ink Sepolia',
@@ -1222,7 +1265,7 @@ const OptimismSepolia = defineChain({
  * Plume is a Layer 1 blockchain specialized for DeFi and trading applications
  * with native orderbook and matching engine.
  */
-defineChain({
+const Plume = defineChain({
     type: 'evm',
     chain: Blockchain.Plume,
     name: 'Plume',
@@ -1261,7 +1304,7 @@ defineChain({
  * This represents the official testnet for the Plume blockchain.
  * Used for development and testing purposes before deploying to mainnet.
  */
-defineChain({
+const PlumeTestnet = defineChain({
     type: 'evm',
     chain: Blockchain.Plume_Testnet,
     name: 'Plume Testnet',
@@ -1435,7 +1478,7 @@ const PolygonAmoy = defineChain({
  * Sei is a Layer 1 blockchain specialized for DeFi and trading applications
  * with native orderbook and matching engine.
  */
-defineChain({
+const Sei = defineChain({
     type: 'evm',
     chain: Blockchain.Sei,
     name: 'Sei',
@@ -1474,7 +1517,7 @@ defineChain({
  * This represents the official testnet for the Sei blockchain.
  * Used for development and testing purposes before deploying to mainnet.
  */
-defineChain({
+const SeiTestnet = defineChain({
     type: 'evm',
     chain: Blockchain.Sei_Testnet,
     name: 'Sei Testnet',
@@ -1546,26 +1589,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: {
@@ -1955,7 +1998,7 @@ const WorldChainSepolia = defineChain({
  * XDC is a Layer 1 blockchain specialized for DeFi and trading applications
  * with native orderbook and matching engine.
  */
-defineChain({
+const XDC = defineChain({
     type: 'evm',
     chain: Blockchain.XDC,
     name: 'XDC',
@@ -1993,7 +2036,7 @@ defineChain({
  * @remarks
  * This represents the official test network for the XDC Network, known as Apothem.
  */
-defineChain({
+const XDCApothem = defineChain({
     type: 'evm',
     chain: Blockchain.XDC_Apothem,
     name: 'Apothem Network',
@@ -2225,6 +2268,7 @@ zod.z.union([
 
 exports.Arbitrum = Arbitrum;
 exports.ArbitrumSepolia = ArbitrumSepolia;
+exports.ArcTestnet = ArcTestnet;
 exports.Avalanche = Avalanche;
 exports.AvalancheFuji = AvalancheFuji;
 exports.Base = Base;
@@ -2233,12 +2277,20 @@ exports.Codex = Codex;
 exports.CodexTestnet = CodexTestnet;
 exports.Ethereum = Ethereum;
 exports.EthereumSepolia = EthereumSepolia;
+exports.HyperEVM = HyperEVM;
+exports.HyperEVMTestnet = HyperEVMTestnet;
+exports.Ink = Ink;
+exports.InkTestnet = InkTestnet;
 exports.Linea = Linea;
 exports.LineaSepolia = LineaSepolia;
 exports.Optimism = Optimism;
 exports.OptimismSepolia = OptimismSepolia;
+exports.Plume = Plume;
+exports.PlumeTestnet = PlumeTestnet;
 exports.Polygon = Polygon;
 exports.PolygonAmoy = PolygonAmoy;
+exports.Sei = Sei;
+exports.SeiTestnet = SeiTestnet;
 exports.Solana = Solana;
 exports.SolanaDevnet = SolanaDevnet;
 exports.Sonic = Sonic;
@@ -2247,4 +2299,6 @@ exports.Unichain = Unichain;
 exports.UnichainSepolia = UnichainSepolia;
 exports.WorldChain = WorldChain;
 exports.WorldChainSepolia = WorldChainSepolia;
-//# sourceMappingURL=chains.cjs.js.map
+exports.XDC = XDC;
+exports.XDCApothem = XDCApothem;
+//# sourceMappingURL=chains.cjs.map

package/chains.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}