@agglayer/sdk 0.1.0-beta.0

package/dist/index.mjs

@@ -0,0 +1,1842 @@
+// src/native/chains/registry.ts
+var ChainRegistry = class _ChainRegistry {
+  constructor() {
+    this.chains = /* @__PURE__ */ new Map();
+    this.viemChains = /* @__PURE__ */ new Map();
+    this.initializeDefaultChains();
+  }
+  static getInstance() {
+    if (!_ChainRegistry.instance) {
+      _ChainRegistry.instance = new _ChainRegistry();
+    }
+    return _ChainRegistry.instance;
+  }
+  initializeDefaultChains() {
+    this.registerChain({
+      chainId: 11155111,
+      networkId: 0,
+      name: "Ethereum Sepolia",
+      rpcUrl: "https://rpc.sepolia.org",
+      nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+      blockExplorer: {
+        name: "Sepolia Etherscan",
+        url: "https://sepolia.etherscan.io"
+      },
+      bridgeAddress: "0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582",
+      proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/testnet/",
+      isTestnet: true
+    });
+    this.registerChain({
+      chainId: 2442,
+      networkId: 1,
+      name: "Polygon Cardona",
+      rpcUrl: "https://rpc.cardona.zkevm-rpc.com",
+      nativeCurrency: { name: "Ethereum", symbol: "ETH", decimals: 18 },
+      blockExplorer: {
+        name: "Cardona PolygonScan",
+        url: "https://cardona-zkevm.polygonscan.com"
+      },
+      bridgeAddress: "0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582",
+      proofApiUrl: "https://api-gateway.polygon.technology/api/v3/proof/testnet/",
+      isTestnet: true
+    });
+  }
+  /**
+   * Register a new chain
+   */
+  registerChain(config) {
+    this.chains.set(config.chainId, config);
+    const viemChain = {
+      id: config.chainId,
+      name: config.name,
+      nativeCurrency: config.nativeCurrency,
+      rpcUrls: {
+        default: { http: [config.rpcUrl] }
+      }
+    };
+    this.viemChains.set(config.chainId, viemChain);
+  }
+  /**
+   * Get chain configuration by ID
+   */
+  getChain(chainId) {
+    const chain = this.chains.get(chainId);
+    if (!chain) {
+      throw new Error(
+        `Chain ${chainId} not found. Available chains: ${Array.from(this.chains.keys()).join(", ")}`
+      );
+    }
+    return chain;
+  }
+  /**
+   * Get chain configuration by network ID
+   */
+  getChainByNetworkId(networkId) {
+    const chain = Array.from(this.chains.values()).find(
+      (chain2) => chain2.networkId === networkId
+    );
+    if (!chain) {
+      throw new Error(
+        `Chain with network ID ${networkId} not found. Available network IDs: ${Array.from(
+          this.chains.values()
+        ).map((chain2) => chain2.networkId).filter(Boolean).join(", ")}`
+      );
+    }
+    return chain;
+  }
+  /**
+   * Get viem chain object by ID
+   */
+  getViemChain(chainId) {
+    const chain = this.viemChains.get(chainId);
+    if (!chain) {
+      throw new Error(
+        `Chain ${chainId} not found. Available chains: ${Array.from(this.viemChains.keys()).join(", ")}`
+      );
+    }
+    return chain;
+  }
+  /**
+   * Get all registered chain IDs
+   */
+  getSupportedChainIds() {
+    return Array.from(this.chains.keys());
+  }
+  /**
+   * Get all registered chains
+   */
+  getAllChains() {
+    return Array.from(this.chains.values());
+  }
+  /**
+   * Check if chain is supported
+   */
+  isChainSupported(chainId) {
+    return this.chains.has(chainId);
+  }
+  /**
+   * Check if chain is supported by network ID
+   */
+  isChainSupportedByNetworkId(networkId) {
+    return Array.from(this.chains.values()).some(
+      (chain) => chain.networkId === networkId
+    );
+  }
+  /**
+   * Get chains by type
+   */
+  getChainsByType(type) {
+    return Array.from(this.chains.values()).filter((chain) => {
+      if (type === "mainnet") {
+        return !chain.isTestnet && !chain.isLocal;
+      }
+      if (type === "testnet") {
+        return chain.isTestnet;
+      }
+      if (type === "local") {
+        return chain.isLocal;
+      }
+      return false;
+    });
+  }
+  /**
+   * Add custom RPC URL for existing chain
+   */
+  addCustomRpcUrl(chainId, rpcUrl) {
+    const chain = this.getChain(chainId);
+    const customChain = {
+      ...chain,
+      rpcUrl
+    };
+    this.registerChain(customChain);
+  }
+};
+var chainRegistry = ChainRegistry.getInstance();
+
+// src/native/utils/validation.ts
+var ValidationUtils = class {
+  /**
+   * Convert value to BigInt safely
+   */
+  static toBigInt(value) {
+    return BigInt(value.toString());
+  }
+  /**
+   * Validate Ethereum address format
+   */
+  static validateAddress(address, name = "Address") {
+    if (!address || !address.startsWith("0x") || address.length !== 42) {
+      throw new Error(`${name} must be a valid 0x-prefixed address`);
+    }
+  }
+  /**
+   * Validate amount (must be positive)
+   */
+  static validateAmount(amount, name = "Amount") {
+    const amountStr = amount.toString();
+    if (!amountStr || amountStr === "0" || this.toBigInt(amount) <= 0n) {
+      throw new Error(`${name} must be a positive value`);
+    }
+  }
+  /**
+   * Check if address is valid without throwing
+   */
+  static isValidAddress(address) {
+    return Boolean(address) && address.startsWith("0x") && address.length === 42;
+  }
+  /**
+   * Check if amount is valid without throwing
+   */
+  static isValidAmount(amount) {
+    try {
+      const amountStr = amount.toString();
+      return Boolean(amountStr) && amountStr !== "0" && this.toBigInt(amount) > 0n;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Validate chain ID
+   */
+  static validateChainId(chainId) {
+    if (!Number.isInteger(chainId) || chainId <= 0) {
+      throw new Error("Chain ID must be a positive integer");
+    }
+  }
+  /**
+   * Validate RPC URL
+   */
+  static validateRpcUrl(rpcUrl) {
+    if (!rpcUrl || !rpcUrl.startsWith("http")) {
+      throw new Error("RPC URL must be a valid HTTP/HTTPS URL");
+    }
+  }
+};
+
+// src/native/base/contract.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+var BaseContract = class {
+  constructor(config) {
+    const chain = chainRegistry.getViemChain(config.chainId);
+    this.client = createPublicClient({
+      chain,
+      transport: http(config.rpcUrl)
+    });
+  }
+  /**
+   * Get nonce for an address
+   */
+  async getNonce(address) {
+    if (!address) return void 0;
+    const nonceValue = await this.client.getTransactionCount({
+      address
+    });
+    return `0x${nonceValue.toString(16)}`;
+  }
+  /**
+   * Estimate gas for transaction
+   */
+  async estimateGas(data, to, from) {
+    const gasEstimate = await this.client.estimateGas({
+      account: from,
+      to,
+      data
+    });
+    return gasEstimate.toString();
+  }
+};
+
+// src/native/tokens/build.ts
+import { encodeFunctionData } from "viem";
+
+// src/native/tokens/abi/erc20.ts
+var erc20Abi = [
+  // Standard ERC20 functions
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "transferFrom",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Additional ERC20 functions
+  {
+    name: "name",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // Events
+  {
+    name: "Transfer",
+    type: "event",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "Approval",
+    type: "event",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/native/tokens/build.ts
+async function buildApprove(ctx, spender, amount, from) {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, from)
+  ]);
+  return {
+    from,
+    to: ctx.tokenAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+async function buildTransfer(ctx, to, amount, from) {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [to, amount]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, from)
+  ]);
+  return {
+    from,
+    to: ctx.tokenAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+async function buildTransferFrom(ctx, fromAddress, to, amount, spender) {
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transferFrom",
+    args: [fromAddress, to, amount]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(spender),
+    ctx.estimateGas(data, spender)
+  ]);
+  return {
+    from: spender,
+    to: ctx.tokenAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+
+// src/native/bridge/build.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+
+// src/native/bridge/abi/bridge.ts
+var bridgeAbi = [
+  {
+    inputs: [
+      { internalType: "uint32", name: "destinationNetwork", type: "uint32" },
+      { internalType: "address", name: "destinationAddress", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "address", name: "token", type: "address" },
+      { internalType: "bool", name: "forceUpdateGlobalExitRoot", type: "bool" },
+      { internalType: "bytes", name: "permitData", type: "bytes" }
+    ],
+    name: "bridgeAsset",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32[32]",
+        name: "smtProofLocalExitRoot",
+        type: "bytes32[32]"
+      },
+      {
+        internalType: "bytes32[32]",
+        name: "smtProofRollupExitRoot",
+        type: "bytes32[32]"
+      },
+      { internalType: "uint256", name: "globalIndex", type: "uint256" },
+      { internalType: "bytes32", name: "mainnetExitRoot", type: "bytes32" },
+      { internalType: "bytes32", name: "rollupExitRoot", type: "bytes32" },
+      { internalType: "uint32", name: "originNetwork", type: "uint32" },
+      { internalType: "address", name: "originTokenAddress", type: "address" },
+      { internalType: "uint32", name: "destinationNetwork", type: "uint32" },
+      { internalType: "address", name: "destinationAddress", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "bytes", name: "metadata", type: "bytes" }
+    ],
+    name: "claimAsset",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "leafIndex", type: "uint32" },
+      { internalType: "uint32", name: "sourceBridgeNetwork", type: "uint32" }
+    ],
+    name: "isClaimed",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "originNetwork", type: "uint32" },
+      { internalType: "address", name: "originTokenAddress", type: "address" }
+    ],
+    name: "getTokenWrappedAddress",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "destinationNetwork", type: "uint32" },
+      { internalType: "address", name: "destinationAddress", type: "address" },
+      { internalType: "bool", name: "forceUpdateGlobalExitRoot", type: "bool" },
+      { internalType: "bytes", name: "permitData", type: "bytes" }
+    ],
+    name: "bridgeMessage",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32[32]",
+        name: "smtProofLocalExitRoot",
+        type: "bytes32[32]"
+      },
+      {
+        internalType: "bytes32[32]",
+        name: "smtProofRollupExitRoot",
+        type: "bytes32[32]"
+      },
+      { internalType: "uint256", name: "globalIndex", type: "uint256" },
+      { internalType: "bytes32", name: "mainnetExitRoot", type: "bytes32" },
+      { internalType: "bytes32", name: "rollupExitRoot", type: "bytes32" },
+      { internalType: "uint32", name: "originNetwork", type: "uint32" },
+      { internalType: "address", name: "originTokenAddress", type: "address" },
+      { internalType: "uint32", name: "destinationNetwork", type: "uint32" },
+      { internalType: "address", name: "destinationAddress", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" },
+      { internalType: "bytes", name: "metadata", type: "bytes" }
+    ],
+    name: "claimMessage",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint32", name: "originNetwork", type: "uint32" },
+      { internalType: "address", name: "originTokenAddress", type: "address" }
+    ],
+    name: "precalculatedWrapperAddress",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "wrappedToken", type: "address" }
+    ],
+    name: "wrappedTokenToTokenInfo",
+    outputs: [
+      { internalType: "uint32", name: "originNetwork", type: "uint32" },
+      { internalType: "address", name: "originTokenAddress", type: "address" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "networkID",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint8",
+        name: "leafType",
+        type: "uint8"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "originNetwork",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "originAddress",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "destinationNetwork",
+        type: "uint32"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "destinationAddress",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "metadata",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "uint32",
+        name: "depositCount",
+        type: "uint32"
+      }
+    ],
+    name: "BridgeEvent",
+    type: "event"
+  }
+];
+
+// src/native/bridge/build.ts
+async function buildBridgeAsset(ctx, destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData = "0x", from) {
+  const data = encodeFunctionData2({
+    abi: bridgeAbi,
+    functionName: "bridgeAsset",
+    args: [
+      destinationNetwork,
+      destinationAddress,
+      amount,
+      token,
+      forceUpdateGlobalExitRoot,
+      permitData
+    ]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, ctx.bridgeAddress, from)
+  ]);
+  return {
+    from,
+    to: ctx.bridgeAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+async function buildClaimAsset(ctx, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata, from) {
+  const data = encodeFunctionData2({
+    abi: bridgeAbi,
+    functionName: "claimAsset",
+    args: [
+      // @ts-ignore - Viem expects exact tuple types but we're passing arrays
+      smtProofLocalExitRoot,
+      // @ts-ignore - Viem expects exact tuple types but we're passing arrays
+      smtProofRollupExitRoot,
+      globalIndex,
+      mainnetExitRoot,
+      rollupExitRoot,
+      originNetwork,
+      originTokenAddress,
+      destinationNetwork,
+      destinationAddress,
+      amount,
+      metadata
+    ]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, ctx.bridgeAddress, from)
+  ]);
+  return {
+    from,
+    to: ctx.bridgeAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+
+// src/native/bridge/message.ts
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+async function buildBridgeMessage(ctx, destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, permitData = "0x", from) {
+  const data = encodeFunctionData3({
+    abi: bridgeAbi,
+    functionName: "bridgeMessage",
+    args: [
+      destinationNetwork,
+      destinationAddress,
+      forceUpdateGlobalExitRoot,
+      permitData
+    ]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, ctx.bridgeAddress, from)
+  ]);
+  return {
+    from,
+    to: ctx.bridgeAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+async function buildClaimMessage(ctx, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata, from) {
+  const data = encodeFunctionData3({
+    abi: bridgeAbi,
+    functionName: "claimMessage",
+    args: [
+      // @ts-ignore - Viem expects exact tuple types but we're passing arrays
+      smtProofLocalExitRoot,
+      // @ts-ignore - Viem expects exact tuple types but we're passing arrays
+      smtProofRollupExitRoot,
+      globalIndex,
+      mainnetExitRoot,
+      rollupExitRoot,
+      originNetwork,
+      originTokenAddress,
+      destinationNetwork,
+      destinationAddress,
+      amount,
+      metadata
+    ]
+  });
+  const [nonce, gas] = await Promise.all([
+    ctx.getNonce(from),
+    ctx.estimateGas(data, ctx.bridgeAddress, from)
+  ]);
+  return {
+    from,
+    to: ctx.bridgeAddress,
+    data,
+    gas,
+    nonce
+  };
+}
+
+// src/native/bridge/util.ts
+import {
+  decodeEventLog,
+  createPublicClient as createPublicClient2,
+  http as http2
+} from "viem";
+var BridgeUtil = class _BridgeUtil {
+  constructor(client, proofApiUrl) {
+    this.BRIDGE_TOPIC = "0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b";
+    this.client = client;
+    this.proofApiUrl = proofApiUrl;
+  }
+  /**
+   * Create BridgeUtil instance from network ID using chain registry
+   *
+   * @param sourceNetworkId - Network ID of the source network
+   * @returns BridgeUtil instance configured for the source network
+   */
+  static async fromNetworkId(sourceNetworkId) {
+    const chain = _BridgeUtil.findChain(sourceNetworkId);
+    if (!chain.proofApiUrl) {
+      throw new Error(
+        `No proof API URL configured for network ${sourceNetworkId}`
+      );
+    }
+    const sourceClient = createPublicClient2({
+      transport: http2(chain.rpcUrl)
+    });
+    return new _BridgeUtil(sourceClient, chain.proofApiUrl);
+  }
+  /**
+   * Find chain configuration by network ID
+   *
+   * @param sourceNetworkId - Network ID to search for
+   * @returns Chain configuration
+   * @throws Error if chain not found
+   */
+  static findChain(sourceNetworkId) {
+    try {
+      return chainRegistry.getChainByNetworkId(sourceNetworkId);
+    } catch {
+      const allChains = chainRegistry.getAllChains();
+      const availableNetworkIds = allChains.map((chain) => chain.networkId).filter(Boolean).join(", ");
+      throw new Error(
+        `Source network ${sourceNetworkId} not found in chain registry. Available network IDs: ${availableNetworkIds}`
+      );
+    }
+  }
+  /**
+   * Extract bridge event data from transaction receipt
+   */
+  async extractBridgeEvent(transactionHash, _networkId, bridgeIndex = 0) {
+    try {
+      const receipt = await this.client.getTransactionReceipt({
+        hash: transactionHash
+      });
+      const bridgeLogs = receipt.logs.filter(
+        (log2) => log2.topics[0] && log2.topics[0].toLowerCase() === this.BRIDGE_TOPIC.toLowerCase()
+      );
+      if (!bridgeLogs.length) {
+        throw new Error("No bridge event found in transaction receipt");
+      }
+      if (bridgeIndex >= bridgeLogs.length) {
+        throw new Error(
+          `Bridge index ${bridgeIndex} not found. Available indices: 0-${bridgeLogs.length - 1}`
+        );
+      }
+      const log = bridgeLogs[bridgeIndex];
+      if (!log) {
+        throw new Error("Bridge log not found");
+      }
+      const decoded = decodeEventLog({
+        abi: bridgeAbi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName !== "BridgeEvent") {
+        throw new Error("Invalid bridge event");
+      }
+      const args = decoded.args;
+      const {
+        originNetwork,
+        originAddress,
+        destinationNetwork,
+        destinationAddress,
+        amount,
+        metadata,
+        depositCount
+      } = args;
+      return {
+        originNetwork: Number(originNetwork),
+        originTokenAddress: originAddress,
+        destinationNetwork: Number(destinationNetwork),
+        destinationAddress,
+        amount,
+        metadata: metadata || "0x",
+        depositCount: Number(depositCount)
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to extract bridge event: ${error.message}`);
+      }
+      throw new Error("Failed to extract bridge event: Unknown error");
+    }
+  }
+  /**
+   * Fetch merkle proof from Polygon's proof API
+   */
+  async fetchMerkleProof(networkId, depositCount) {
+    try {
+      const baseUrl = this.proofApiUrl.endsWith("/") ? this.proofApiUrl : `${this.proofApiUrl}/`;
+      const url = `${baseUrl}merkle-proof?networkId=${networkId}&depositCount=${depositCount}`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch merkle proof: ${response.statusText} (${response.status})`
+        );
+      }
+      const data = await response.json();
+      if (!data.proof) {
+        throw new Error("Invalid response format: missing proof data");
+      }
+      return data.proof;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to fetch merkle proof: ${error.message}`);
+      }
+      throw new Error("Failed to fetch merkle proof: Unknown error");
+    }
+  }
+  /**
+   * Compute global index from local index and network ID
+   */
+  computeGlobalIndex(indexLocal, sourceNetworkId) {
+    const MAINNET_FLAG = BigInt(2 ** 64);
+    if (BigInt(sourceNetworkId) === BigInt(0)) {
+      return BigInt(indexLocal) + MAINNET_FLAG;
+    } else {
+      return BigInt(indexLocal) + BigInt(sourceNetworkId - 1) * BigInt(2 ** 32);
+    }
+  }
+  /**
+   * Build claim payload from transaction hash (user-friendly method)
+   */
+  async buildPayloadForClaim(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    const bridgeEvent = await this.extractBridgeEvent(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+    const proof = await this.fetchMerkleProof(
+      sourceNetworkId,
+      bridgeEvent.depositCount
+    );
+    const globalIndex = this.computeGlobalIndex(
+      bridgeEvent.depositCount,
+      sourceNetworkId
+    );
+    return {
+      smtProof: proof.merkle_proof,
+      smtProofRollup: proof.rollup_merkle_proof,
+      globalIndex: globalIndex.toString(),
+      mainnetExitRoot: proof.main_exit_root,
+      rollupExitRoot: proof.rollup_exit_root,
+      originNetwork: bridgeEvent.originNetwork,
+      originTokenAddress: bridgeEvent.originTokenAddress,
+      destinationNetwork: bridgeEvent.destinationNetwork,
+      destinationAddress: bridgeEvent.destinationAddress,
+      amount: bridgeEvent.amount,
+      metadata: bridgeEvent.metadata
+    };
+  }
+  /**
+   * Build claim asset parameters from transaction hash
+   */
+  async buildClaimAssetParams(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    const payload = await this.buildPayloadForClaim(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+    return {
+      smtProofLocalExitRoot: payload.smtProof,
+      smtProofRollupExitRoot: payload.smtProofRollup,
+      globalIndex: BigInt(payload.globalIndex),
+      mainnetExitRoot: payload.mainnetExitRoot,
+      rollupExitRoot: payload.rollupExitRoot,
+      originNetwork: payload.originNetwork,
+      originTokenAddress: payload.originTokenAddress,
+      destinationNetwork: payload.destinationNetwork,
+      destinationAddress: payload.destinationAddress,
+      amount: payload.amount,
+      metadata: payload.metadata
+    };
+  }
+  /**
+   * Build claim message parameters from transaction hash
+   */
+  async buildClaimMessageParams(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    const payload = await this.buildPayloadForClaim(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+    return {
+      smtProofLocalExitRoot: payload.smtProof,
+      smtProofRollupExitRoot: payload.smtProofRollup,
+      globalIndex: BigInt(payload.globalIndex),
+      mainnetExitRoot: payload.mainnetExitRoot,
+      rollupExitRoot: payload.rollupExitRoot,
+      originNetwork: payload.originNetwork,
+      originTokenAddress: payload.originTokenAddress,
+      destinationNetwork: payload.destinationNetwork,
+      destinationAddress: payload.destinationAddress,
+      amount: payload.amount,
+      metadata: payload.metadata
+    };
+  }
+  /**
+   * Get bridge event info from transaction hash
+   */
+  async getBridgeEventInfo(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    return this.extractBridgeEvent(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+  }
+};
+
+// src/native/bridge/bridge.ts
+var Bridge = class extends BaseContract {
+  constructor(config) {
+    super({ rpcUrl: config.rpcUrl, chainId: config.chainId });
+    this.bridgeAddress = config.bridgeAddress;
+  }
+  /**
+   * Build bridge asset transaction
+   */
+  async buildBridgeAsset(params, from) {
+    ValidationUtils.validateAddress(
+      params.destinationAddress,
+      "Destination address"
+    );
+    ValidationUtils.validateAddress(params.token, "Token address");
+    return buildBridgeAsset(
+      {
+        bridgeAddress: this.bridgeAddress,
+        estimateGas: (data, to, from2) => this.estimateGas(data, to, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      params.destinationNetwork,
+      params.destinationAddress,
+      BigInt(params.amount),
+      params.token,
+      params.forceUpdateGlobalExitRoot,
+      params.permitData,
+      from
+    );
+  }
+  /**
+   * Build claim asset transaction
+   */
+  async buildClaimAsset(params, from) {
+    ValidationUtils.validateAddress(
+      params.originTokenAddress,
+      "Origin token address"
+    );
+    ValidationUtils.validateAddress(
+      params.destinationAddress,
+      "Destination address"
+    );
+    return buildClaimAsset(
+      {
+        bridgeAddress: this.bridgeAddress,
+        estimateGas: (data, to, from2) => this.estimateGas(data, to, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      params.smtProofLocalExitRoot,
+      params.smtProofRollupExitRoot,
+      params.globalIndex,
+      params.mainnetExitRoot,
+      params.rollupExitRoot,
+      params.originNetwork,
+      params.originTokenAddress,
+      params.destinationNetwork,
+      params.destinationAddress,
+      params.amount,
+      params.metadata,
+      from
+    );
+  }
+  /**
+   * Check if bridge deposit is claimed
+   */
+  async isClaimed(params) {
+    const result = await this.client.readContract({
+      address: this.bridgeAddress,
+      abi: bridgeAbi,
+      functionName: "isClaimed",
+      args: [params.leafIndex, params.sourceBridgeNetwork]
+    });
+    return result;
+  }
+  /**
+   * Get wrapped token address
+   */
+  async getWrappedTokenAddress(params) {
+    ValidationUtils.validateAddress(
+      params.originTokenAddress,
+      "Origin token address"
+    );
+    const result = await this.client.readContract({
+      address: this.bridgeAddress,
+      abi: bridgeAbi,
+      functionName: "getTokenWrappedAddress",
+      args: [params.originNetwork, params.originTokenAddress]
+    });
+    return result;
+  }
+  /**
+   * Get network ID
+   */
+  async getNetworkId() {
+    const result = await this.client.readContract({
+      address: this.bridgeAddress,
+      abi: bridgeAbi,
+      functionName: "networkID",
+      args: []
+    });
+    return Number(result);
+  }
+  /**
+   * Get bridge contract address
+   */
+  getBridgeAddress() {
+    return this.bridgeAddress;
+  }
+  /**
+   * Build bridge message transaction
+   */
+  async buildBridgeMessage(params, from) {
+    ValidationUtils.validateAddress(
+      params.destinationAddress,
+      "Destination address"
+    );
+    return buildBridgeMessage(
+      {
+        bridgeAddress: this.bridgeAddress,
+        estimateGas: (data, to, from2) => this.estimateGas(data, to, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      params.destinationNetwork,
+      params.destinationAddress,
+      params.forceUpdateGlobalExitRoot,
+      params.permitData || "0x",
+      from
+    );
+  }
+  /**
+   * Build claim message transaction
+   */
+  async buildClaimMessage(params, from) {
+    ValidationUtils.validateAddress(
+      params.originTokenAddress,
+      "Origin token address"
+    );
+    ValidationUtils.validateAddress(
+      params.destinationAddress,
+      "Destination address"
+    );
+    return buildClaimMessage(
+      {
+        bridgeAddress: this.bridgeAddress,
+        estimateGas: (data, to, from2) => this.estimateGas(data, to, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      params.smtProofLocalExitRoot,
+      params.smtProofRollupExitRoot,
+      params.globalIndex,
+      params.mainnetExitRoot,
+      params.rollupExitRoot,
+      params.originNetwork,
+      params.originTokenAddress,
+      params.destinationNetwork,
+      params.destinationAddress,
+      params.amount,
+      params.metadata,
+      from
+    );
+  }
+  /**
+   * Get precalculated wrapper address
+   */
+  async getPrecalculatedWrapperAddress(params) {
+    ValidationUtils.validateAddress(
+      params.originTokenAddress,
+      "Origin token address"
+    );
+    const result = await this.client.readContract({
+      address: this.bridgeAddress,
+      abi: bridgeAbi,
+      functionName: "precalculatedWrapperAddress",
+      args: [params.originNetwork, params.originTokenAddress]
+    });
+    return result;
+  }
+  /**
+   * Get origin token info from wrapped token
+   */
+  async getOriginTokenInfo(params) {
+    ValidationUtils.validateAddress(
+      params.wrappedToken,
+      "Wrapped token address"
+    );
+    const result = await this.client.readContract({
+      address: this.bridgeAddress,
+      abi: bridgeAbi,
+      functionName: "wrappedTokenToTokenInfo",
+      args: [params.wrappedToken]
+    });
+    return result;
+  }
+  /**
+   * Build claim asset transaction from bridge transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   * @param from - From address for the claim transaction
+   */
+  async buildClaimAssetFromHash(transactionHash, sourceNetworkId, bridgeIndex = 0, from) {
+    const bridgeUtil = await BridgeUtil.fromNetworkId(sourceNetworkId);
+    const params = await bridgeUtil.buildClaimAssetParams(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+    return this.buildClaimAsset(params, from);
+  }
+  /**
+   * Build claim message transaction from bridge transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   * @param from - From address for the claim transaction
+   */
+  async buildClaimMessageFromHash(transactionHash, sourceNetworkId, bridgeIndex = 0, from) {
+    const bridgeUtil = await BridgeUtil.fromNetworkId(sourceNetworkId);
+    const params = await bridgeUtil.buildClaimMessageParams(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+    return this.buildClaimMessage(params, from);
+  }
+  /**
+   * Get bridge event info from transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   */
+  async getBridgeEventInfo(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    const bridgeUtil = await BridgeUtil.fromNetworkId(sourceNetworkId);
+    return bridgeUtil.getBridgeEventInfo(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+  }
+};
+
+// src/native/services/abi.ts
+var ABIS = {
+  BRIDGE: bridgeAbi,
+  ERC20: erc20Abi
+};
+function getAbi(contractType) {
+  return ABIS[contractType];
+}
+
+// src/native/tokens/erc20.ts
+var ERC20 = class extends BaseContract {
+  constructor(config) {
+    super({ rpcUrl: config.rpcUrl, chainId: config.chainId });
+    this.tokenAddress = config.tokenAddress;
+    this.config = config;
+  }
+  /**
+   * Get ERC20 token balance in wei
+   */
+  async getBalance(address) {
+    ValidationUtils.validateAddress(address, "Address");
+    const balance = await this.client.readContract({
+      address: this.tokenAddress,
+      abi: getAbi("ERC20"),
+      functionName: "balanceOf",
+      args: [address]
+    });
+    return balance.toString();
+  }
+  /**
+   * Get allowance in wei
+   */
+  async getAllowance(owner, spender) {
+    ValidationUtils.validateAddress(owner, "Owner address");
+    ValidationUtils.validateAddress(spender, "Spender address");
+    try {
+      const allowance = await this.client.readContract({
+        address: this.tokenAddress,
+        abi: getAbi("ERC20"),
+        functionName: "allowance",
+        args: [owner, spender]
+      });
+      return allowance.toString();
+    } catch (error) {
+      throw new Error(
+        `Failed to get allowance: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Build approve transaction
+   */
+  async buildApprove(spender, amount, from) {
+    ValidationUtils.validateAddress(spender, "Spender address");
+    ValidationUtils.validateAmount(amount, "Amount");
+    return buildApprove(
+      {
+        tokenAddress: this.tokenAddress,
+        estimateGas: (data, from2) => this.estimateGas(data, this.tokenAddress, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      spender,
+      BigInt(amount),
+      from
+    );
+  }
+  /**
+   * Build transfer transaction
+   */
+  async buildTransfer(to, amount, from) {
+    ValidationUtils.validateAddress(to, "Recipient address");
+    ValidationUtils.validateAmount(amount, "Amount");
+    return buildTransfer(
+      {
+        tokenAddress: this.tokenAddress,
+        estimateGas: (data, from2) => this.estimateGas(data, this.tokenAddress, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      to,
+      BigInt(amount),
+      from
+    );
+  }
+  /**
+   * Build transferFrom transaction
+   */
+  async buildTransferFrom(from, to, amount, spender) {
+    ValidationUtils.validateAddress(from, "Owner address");
+    ValidationUtils.validateAddress(to, "Recipient address");
+    ValidationUtils.validateAmount(amount, "Amount");
+    return buildTransferFrom(
+      {
+        tokenAddress: this.tokenAddress,
+        estimateGas: (data, from2) => this.estimateGas(data, this.tokenAddress, from2),
+        getNonce: (address) => this.getNonce(address)
+      },
+      from,
+      to,
+      BigInt(amount),
+      spender
+    );
+  }
+  /**
+   * Bridge this token to another network
+   */
+  async bridgeTo(destinationNetwork, destinationAddress, amount, from, options = {}) {
+    ValidationUtils.validateAddress(destinationAddress, "Destination address");
+    ValidationUtils.validateAmount(amount, "Amount");
+    const bridge = this.getBridge();
+    return bridge.buildBridgeAsset(
+      {
+        destinationNetwork,
+        destinationAddress,
+        amount,
+        token: this.tokenAddress,
+        forceUpdateGlobalExitRoot: options.forceUpdateGlobalExitRoot ?? true,
+        permitData: options.permitData || "0x"
+      },
+      from
+    );
+  }
+  /**
+   * Get wrapped version of this token on destination network
+   */
+  async getWrappedToken() {
+    const bridge = this.getBridge();
+    return bridge.getWrappedTokenAddress({
+      originNetwork: this.config.chainId,
+      originTokenAddress: this.tokenAddress
+    });
+  }
+  /**
+   * Claim asset from bridge transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   * @param from - From address for the claim transaction
+   */
+  async claimAsset(transactionHash, sourceNetworkId, bridgeIndex = 0, from) {
+    const bridge = this.getBridge();
+    return bridge.buildClaimAssetFromHash(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex,
+      from
+    );
+  }
+  /**
+   * Claim message from bridge transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   * @param from - From address for the claim transaction
+   */
+  async claimMessage(transactionHash, sourceNetworkId, bridgeIndex = 0, from) {
+    const bridge = this.getBridge();
+    return bridge.buildClaimMessageFromHash(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex,
+      from
+    );
+  }
+  /**
+   * Get bridge event info from transaction hash
+   *
+   * @param transactionHash - Hash of the bridge transaction on the source network
+   * @param sourceNetworkId - Network ID of the source network (where bridge tx happened)
+   * @param bridgeIndex - Index of bridge event in transaction (default: 0)
+   */
+  async getBridgeEventInfo(transactionHash, sourceNetworkId, bridgeIndex = 0) {
+    const bridge = this.getBridge();
+    return bridge.getBridgeEventInfo(
+      transactionHash,
+      sourceNetworkId,
+      bridgeIndex
+    );
+  }
+  getBridge() {
+    const chain = chainRegistry.getChain(this.config.chainId);
+    if (!chain.bridgeAddress) {
+      throw new Error(
+        `No bridge address configured for network ${this.config.chainId}`
+      );
+    }
+    return new Bridge({
+      bridgeAddress: chain.bridgeAddress,
+      rpcUrl: this.config.rpcUrl,
+      chainId: this.config.chainId
+    });
+  }
+};
+
+// src/native/index.ts
+import { createPublicClient as createPublicClient3, http as http3 } from "viem";
+
+// src/constants.ts
+var NETWORKS = {
+  SEPOLIA: 11155111,
+  CARDONA: 2442
+};
+var DEFAULT_NETWORK = NETWORKS.SEPOLIA;
+
+// src/native/index.ts
+var NativeClient = class {
+  constructor(config) {
+    this.config = config;
+    this.defaultNetwork = this.config.defaultNetwork || DEFAULT_NETWORK;
+    if (this.config.chains) {
+      this.config.chains.forEach((chain) => {
+        chainRegistry.registerChain(chain);
+      });
+    }
+    if (this.config.customRpcUrls) {
+      Object.entries(this.config.customRpcUrls).forEach(([chainId, rpcUrl]) => {
+        chainRegistry.addCustomRpcUrl(Number(chainId), rpcUrl);
+      });
+    }
+  }
+  /**
+   * Get network configuration from chain registry
+   * @param networkId - The network ID (chain ID)
+   * @returns Chain configuration
+   */
+  getNetwork(networkId) {
+    return chainRegistry.getChain(networkId);
+  }
+  /**
+   * Get all supported networks
+   * @returns Array of network IDs
+   */
+  getSupportedNetworks() {
+    return chainRegistry.getSupportedChainIds();
+  }
+  /**
+   * Get default network ID
+   * @returns Default network ID
+   */
+  getDefaultNetwork() {
+    return this.defaultNetwork;
+  }
+  /**
+   * Get chain registry for advanced usage
+   */
+  getChainRegistry() {
+    return chainRegistry;
+  }
+  /**
+   * Create an ERC20 instance for a specific token on a specific network
+   * @param tokenAddress - The ERC20 token contract address
+   * @param networkId - The network ID (optional, uses default if not provided)
+   * @returns ERC20 instance
+   */
+  erc20(tokenAddress, networkId) {
+    const network = this.getNetwork(networkId || this.defaultNetwork);
+    return new ERC20({
+      tokenAddress,
+      rpcUrl: network.rpcUrl,
+      chainId: network.chainId
+    });
+  }
+  /**
+   * Get native token balance in wei
+   * @param address - The address to check balance for
+   * @param networkId - The network ID (optional, uses default if not provided)
+   * @returns Native token balance as string
+   */
+  async getNativeBalance(address, networkId) {
+    ValidationUtils.validateAddress(address, "Address");
+    const network = this.getNetwork(networkId || this.defaultNetwork);
+    const client = createPublicClient3({
+      chain: {
+        id: network.chainId,
+        name: network.name,
+        nativeCurrency: network.nativeCurrency,
+        rpcUrls: {
+          default: { http: [network.rpcUrl] },
+          public: { http: [network.rpcUrl] }
+        }
+      },
+      transport: http3(network.rpcUrl)
+    });
+    const balance = await client.getBalance({ address });
+    return balance.toString();
+  }
+  /**
+   * Create a Bridge instance for a specific network
+   * @param bridgeAddress - The bridge contract address
+   * @param networkId - The network ID (optional, uses default if not provided)
+   * @returns Bridge instance
+   */
+  bridge(bridgeAddress, networkId) {
+    const network = this.getNetwork(networkId || this.defaultNetwork);
+    return new Bridge({
+      bridgeAddress,
+      rpcUrl: network.rpcUrl,
+      chainId: network.chainId
+    });
+  }
+};
+
+// src/types/config.ts
+var SDK_MODES = {
+  CORE: "CORE",
+  NATIVE: "NATIVE"
+};
+
+// src/core/utils/httpClient.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      retries: 3,
+      retryDelay: 1e3,
+      defaultHeaders: {
+        "Content-Type": "application/json"
+      },
+      ...config
+    };
+  }
+  async request(url, config) {
+    const fullUrl = this.buildUrl(url);
+    const requestConfig = this.buildRequestConfig(config);
+    let lastError;
+    for (let attempt = 0; attempt <= (this.config.retries ?? 3); attempt++) {
+      try {
+        const response = await this.makeRequest(fullUrl, requestConfig);
+        return response;
+      } catch (error) {
+        lastError = error;
+        if (attempt === (this.config.retries ?? 3) || !this.isRetryableError(error)) {
+          break;
+        }
+        if (attempt < (this.config.retries ?? 3)) {
+          await this.delay(
+            (this.config.retryDelay ?? 1e3) * Math.pow(2, attempt)
+          );
+        }
+      }
+    }
+    throw new Error(
+      `Request failed after ${this.config.retries ?? 3} retries: ${lastError?.message ?? "Unknown error"}`
+    );
+  }
+  async get(url, params) {
+    const queryString = params ? this.buildQueryString(params) : "";
+    const fullUrl = queryString ? `${url}?${queryString}` : url;
+    return this.request(fullUrl, { method: "GET" });
+  }
+  async post(url, data, config) {
+    return this.request(url, {
+      method: "POST",
+      body: data,
+      ...config
+    });
+  }
+  buildUrl(url) {
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      return url;
+    }
+    return `${this.config.baseUrl}${url.startsWith("/") ? url : `/${url}`}`;
+  }
+  buildRequestConfig(config) {
+    const headers = new Headers(this.config.defaultHeaders);
+    if (config.headers) {
+      Object.entries(config.headers).forEach(([key, value]) => {
+        headers.set(key, value);
+      });
+    }
+    const requestConfig = {
+      method: config.method,
+      headers
+    };
+    if (config.body) {
+      if (typeof config.body === "string") {
+        requestConfig.body = config.body;
+      } else {
+        requestConfig.body = JSON.stringify(config.body);
+      }
+    }
+    return requestConfig;
+  }
+  async makeRequest(url, config) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        ...config,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      let data;
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        data = await response.text();
+      }
+      return {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        ok: response.ok
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timeout after ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  buildQueryString(params) {
+    const flattenedParams = this.flattenParams(params);
+    return Object.entries(flattenedParams).filter(([, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+  }
+  flattenParams(params, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(params)) {
+      const fullKey = prefix ? `${prefix}[${key}]` : key;
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (item !== void 0 && item !== null) {
+            result[`${fullKey}[${index}]`] = String(item);
+          }
+        });
+      } else if (typeof value === "object") {
+        Object.assign(
+          result,
+          this.flattenParams(value, fullKey)
+        );
+      } else {
+        result[fullKey] = String(value);
+      }
+    }
+    return result;
+  }
+  isRetryableError(error) {
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+      return message.includes("timeout") || message.includes("network") || message.includes("fetch");
+    }
+    return false;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/core/services/arcApi.ts
+var ArcApiService = class {
+  constructor({ baseUrl, timeout }) {
+    this.httpClient = new HttpClient({ baseUrl, timeout });
+  }
+  // responsible for both chains metadata and tokens
+  async chains({
+    withSupportedTokens = false,
+    limit = 20,
+    startAfter = 0,
+    chainIds
+  } = {}) {
+    return this.httpClient.get("/metadata/chains", {
+      withSupportedTokens,
+      limit,
+      startAfter,
+      chainIds
+    });
+  }
+  async routes(routesRequestParams) {
+    return this.httpClient.post("/routes", routesRequestParams);
+  }
+  async buildTransaction(builtTransactionRequestBody) {
+    return this.httpClient.post(
+      "/build-transaction",
+      builtTransactionRequestBody
+    );
+  }
+  async transactions(transactionsRequestQueryParams) {
+    return this.httpClient.get("/transactions", {
+      transactionsRequestQueryParams
+    });
+  }
+};
+
+// src/core/index.ts
+var CoreClient = class {
+  constructor(config) {
+    this.config = config;
+    if (!this.config) {
+      throw new Error("Config is required");
+    }
+    if (!this.config.apiBaseUrl) {
+      throw new Error("API base URL is required");
+    }
+    const { apiBaseUrl, apiTimeout } = this.config;
+    this.arcApiService = new ArcApiService({
+      baseUrl: apiBaseUrl,
+      timeout: apiTimeout ?? 3e4
+    });
+  }
+  /**
+   * Get all chains metadata from AggLayer API
+   */
+  async getAllChains() {
+    const response = await this.arcApiService.chains();
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Get chain metadata by id from AggLayer API
+   * @param ids - the ids of the chains to get metadata for
+   */
+  async getChainMetadataByChainIds(ids) {
+    const response = await this.arcApiService.chains({ chainIds: ids });
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Get all tokens from AggLayer API
+   */
+  async getTokens() {
+    const response = await this.arcApiService.chains({
+      withSupportedTokens: true
+    });
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Get chain data and tokens by AggLayer API
+   * @param ids - the ids of the chains to get data and tokens for
+   */
+  async getChainDataAndTokensByChainIds(ids) {
+    const response = await this.arcApiService.chains({
+      chainIds: ids,
+      withSupportedTokens: true
+    });
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Get all routes from AggLayer API
+   */
+  async getRoutes(routesRequestParams) {
+    const response = await this.arcApiService.routes(routesRequestParams);
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Build transaction from a step object
+   */
+  async buildTransaction(builtTransactionRequestBody) {
+    const response = await this.arcApiService.buildTransaction(
+      builtTransactionRequestBody
+    );
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+  /**
+   * Get all transactions via web sockets
+   */
+  async getTransactions(transactionsRequestQueryParams) {
+    const response = await this.arcApiService.transactions(
+      transactionsRequestQueryParams
+    );
+    if (response.data.status === "success") {
+      return response.data.data;
+    }
+    throw new Error(response.data.message);
+  }
+};
+
+// src/index.ts
+var AggLayerSDK = class {
+  constructor(config) {
+    this.config = config;
+    if (!config.mode || config.mode && config.mode.length === 0) {
+      this.config.mode = ["CORE"];
+    }
+    if (config.mode.includes(SDK_MODES.CORE)) {
+      if (!this.config.core) {
+        throw new Error("Core config is required");
+      }
+      this.core = new CoreClient(this.config.core);
+    }
+    if (this.config.mode?.includes(SDK_MODES.NATIVE)) {
+      if (!this.config.native) {
+        throw new Error("NATIVE config is required");
+      }
+      const nativeConfig = {
+        defaultNetwork: this.config.native?.defaultNetwork || DEFAULT_NETWORK,
+        ...this.config.native?.chains && {
+          chains: this.config.native.chains
+        },
+        ...this.config.native?.customRpcUrls && {
+          customRpcUrls: this.config.native.customRpcUrls
+        }
+      };
+      this.native = new NativeClient(nativeConfig);
+    }
+  }
+  /**
+   * Get core submodule
+   */
+  getCore() {
+    if (!this.core) {
+      throw new Error('Core module not initialized. Add "core" to mode array.');
+    }
+    return this.core;
+  }
+  /**
+   * Get native submodule
+   */
+  getNative() {
+    if (!this.native) {
+      throw new Error(
+        'NATIVE module not initialized. Add "native" to mode array.'
+      );
+    }
+    return this.native;
+  }
+};
+export {
+  AggLayerSDK,
+  SDK_MODES
+};
+//# sourceMappingURL=index.mjs.map