@talken/talkenkit 2.5.1 → 2.5.2

package/dist/wallets/walletConnectors/chunk-TVZHPWFR.js

@@ -0,0 +1,843 @@
+"use client";
+import {
+  getChainKey,
+  getExplorerTxUrl,
+  getNetworkName
+} from "./chunk-OASBABPG.js";
+import {
+  getCredentialManager
+} from "./chunk-QKK3OPQA.js";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-PF65YS3T.js";
+import {
+  TalkenApiError
+} from "./chunk-4P3SPC44.js";
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+import {
+  getShowPendingTransaction,
+  getTalkenApiClient,
+  getUpdateTransactionResult
+} from "@talken/talkenkit";
+import { parseGwei } from "viem";
+var EventEmitter = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+      return true;
+    }
+    return false;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+    return this;
+  }
+};
+var ProviderRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ProviderRpcError";
+  }
+};
+var ErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  CHAIN_DISCONNECTED: 4901,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var AbcEvmProvider = class extends EventEmitter {
+  constructor(talkenApi) {
+    super();
+    this.wallet = null;
+    this.chainId = 1;
+    // Default to Ethereum mainnet
+    this.connected = false;
+    this.talkenApi = talkenApi;
+  }
+  getRecoveryEmail() {
+    const walletEmail = this.wallet?.email?.trim();
+    if (walletEmail) {
+      return walletEmail;
+    }
+    return getCredentialManager().getEmail() || void 0;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    const previousChainId = this.chainId;
+    this.wallet = wallet;
+    this.chainId = wallet.chainId;
+    this.connected = true;
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+    }
+    if (previousChainId !== wallet.chainId) {
+      this.emit("chainChanged", numberToHex(wallet.chainId));
+    }
+    this.emit("connect", { chainId: numberToHex(wallet.chainId) });
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect", {
+      code: ErrorCode.DISCONNECTED,
+      message: "User disconnected"
+    });
+    this.emit("accountsChanged", []);
+  }
+  /**
+   * Set request interceptor for sign confirmation
+   * The interceptor is called before signing operations to show confirmation UI
+   */
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, transaction methods will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  getTalkenApiClientOrThrow() {
+    const api = this.talkenApi || getTalkenApiClient();
+    if (!api) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "TalkenApiClient not initialized"
+      );
+    }
+    return api;
+  }
+  /**
+   * Check if an error is a "Missing required wallet fields" 502 from the server.
+   * When the server's in-memory signing credential cache is cold, it needs
+   * a wallet.generate() call (idempotent create/recover) to repopulate.
+   */
+  isSigningCredentialError(error) {
+    return error instanceof TalkenApiError && error.statusCode === 502 && error.message.includes("Missing required wallet fields");
+  }
+  /**
+   * Refresh server-side signing credentials.
+   *
+   * Strategy (in priority order):
+   * 1. PIN hash in memory → wallet.generate() to repopulate server cache
+   * 2. Neither available → throw UNAUTHORIZED
+   *
+   * Note: sessionStorage-cached credentials (evmCreds) are automatically
+   * attached to every signing request by TalkenApiClient, so the server
+   * can use them as fallback without a separate refresh call.
+   */
+  async refreshSigningCredentials() {
+    const credMgr = getCredentialManager();
+    const pinHash = credMgr.getPinHash();
+    const email = this.getRecoveryEmail();
+    if (pinHash && email) {
+      const api = this.getTalkenApiClientOrThrow();
+      console.log(
+        "[AbcProvider] Refreshing signing credentials via wallet.generate..."
+      );
+      await api.wallet.generate(pinHash, email);
+      console.log("[AbcProvider] Signing credentials refreshed via PIN");
+      return;
+    }
+    console.warn(
+      "[AbcProvider] Cannot refresh signing credentials \u2014 PIN hash or email missing"
+    );
+    throw new ProviderRpcError(
+      ErrorCode.UNAUTHORIZED,
+      "Session expired. Please reconnect and verify your PIN."
+    );
+  }
+  /**
+   * Wrap a signing operation with auto-retry on "Missing required wallet fields" error.
+   * On first failure, refreshes the server's signing credential cache and retries once.
+   */
+  async withSigningCredentialRetry(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (this.isSigningCredentialError(error)) {
+        console.log(
+          "[AbcProvider] Signing credentials missing on server \u2014 attempting refresh and retry"
+        );
+        await this.refreshSigningCredentials();
+        return await operation();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Call request interceptor if configured
+   * Called by specific signing/transaction methods that need user confirmation
+   * @returns Resolved transaction with user modifications if changed in confirmation modal
+   */
+  async callInterceptor(method, params) {
+    if (!this.requestInterceptor) {
+      return void 0;
+    }
+    const request = {
+      method,
+      params,
+      chainId: this.chainId,
+      address: this.wallet?.address || ""
+    };
+    return this.requestInterceptor(request);
+  }
+  /**
+   * EIP-1193 request method
+   */
+  async request(args) {
+    const { method, params } = args;
+    switch (method) {
+      case "eth_requestAccounts":
+        return this.eth_requestAccounts();
+      case "eth_accounts":
+        return this.eth_accounts();
+      case "eth_chainId":
+        return this.eth_chainId();
+      case "eth_sendTransaction":
+      case "wallet_sendTransaction":
+        return this.eth_sendTransaction(params);
+      case "eth_signTransaction":
+        return this.eth_signTransaction(params);
+      case "personal_sign":
+        return this.personal_sign(params);
+      case "eth_sign":
+        return this.eth_sign(params);
+      case "eth_signTypedData":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+        return this.eth_signTypedData(params);
+      case "wallet_getCapabilities":
+        return this.wallet_getCapabilities();
+      case "eth_signAuthorization":
+        return this.eth_signAuthorization(params);
+      case "wallet_switchEthereumChain":
+        return this.wallet_switchEthereumChain(params);
+      case "wallet_addEthereumChain":
+        return this.wallet_addEthereumChain(params);
+      case "eth_estimateGas":
+        return this.eth_estimateGas(params);
+      case "eth_getTransactionCount":
+        return this.eth_getTransactionCount(
+          Array.isArray(params) ? params : []
+        );
+      case "eth_call":
+        return this.eth_call(params);
+      case "eth_getBalance":
+        return this.eth_getBalance(params);
+      case "eth_blockNumber":
+      case "eth_gasPrice":
+      case "eth_getBlockByHash":
+      case "eth_getBlockByNumber":
+      case "eth_getCode":
+      case "eth_getStorageAt":
+      case "eth_getTransactionByHash":
+      case "eth_getTransactionReceipt":
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} should be handled by RPC provider`
+        );
+      default:
+        throw new ProviderRpcError(
+          ErrorCode.UNSUPPORTED_METHOD,
+          `Method ${method} not supported`
+        );
+    }
+  }
+  /**
+   * Request accounts (EIP-1193)
+   */
+  async eth_requestAccounts() {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get accounts
+   */
+  async eth_accounts() {
+    if (!this.wallet) {
+      return [];
+    }
+    return [this.wallet.address];
+  }
+  /**
+   * Get chain ID
+   */
+  async eth_chainId() {
+    return numberToHex(this.chainId);
+  }
+  /**
+   * Send transaction
+   */
+  async eth_sendTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction params"
+      );
+    }
+    const resolved = await this.callInterceptor("eth_sendTransaction", params);
+    const tx = params[0];
+    console.log("[AbcProvider] eth_sendTransaction incoming gas params:", {
+      gas: tx.gas ?? tx.gasLimit,
+      gasPrice: tx.gasPrice,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
+    console.log("[AbcProvider] eth_sendTransaction final gas params:", {
+      gas: tx.gas ?? tx.gasLimit,
+      gasPrice: tx.gasPrice,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    const isContractDeployment = !tx.to || tx.to === "0x" || tx.to === "0x0" || tx.to === "0x0000000000000000000000000000000000000000";
+    if (isContractDeployment) {
+      tx.to = "0x";
+    } else if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        'Transaction must have "to" field'
+      );
+    }
+    const pinHash = getCredentialManager().getPinHash();
+    if (!pinHash) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "PIN hash not found. Please login again."
+      );
+    }
+    const hexValue = tx.value || "0x0";
+    const amountWei = BigInt(hexValue).toString();
+    const email = this.getRecoveryEmail();
+    const chainKey = getChainKey(this.chainId);
+    const showPending = getShowPendingTransaction();
+    if (showPending) {
+      showPending({
+        txHash: "",
+        network: chainKey,
+        chain: "evm",
+        explorerUrl: void 0
+      });
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.sendTransaction({
+        chainKey,
+        to: tx.to,
+        amountWei,
+        pin: pinHash,
+        data: tx.data || "0x",
+        gasLimit: tx.gas || tx.gasLimit,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        waitForReceipt: true,
+        ...email && { email }
+      })
+    );
+    const updateResult = getUpdateTransactionResult();
+    if (updateResult) {
+      updateResult({
+        txHash: result.txHash,
+        network: chainKey,
+        chain: "evm",
+        receipt: result.receipt ?? null,
+        explorerUrl: getExplorerTxUrl(this.chainId, result.txHash)
+      });
+    }
+    return result.txHash;
+  }
+  /**
+   * Sign transaction (without sending)
+   */
+  async eth_signTransaction(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid transaction params"
+      );
+    }
+    const resolved = await this.callInterceptor("eth_signTransaction", params);
+    const tx = params[0];
+    if (resolved) {
+      if (resolved.data) {
+        tx.data = resolved.data;
+      }
+      if (resolved.gasFee?.maxFeePerGas) {
+        try {
+          const maxFeeWei = parseGwei(resolved.gasFee.maxFeePerGas);
+          tx.maxFeePerGas = `0x${maxFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxFeePerGas:",
+            error
+          );
+        }
+      }
+      if (resolved.gasFee?.maxPriorityFeePerGas) {
+        try {
+          const priorityFeeWei = parseGwei(
+            resolved.gasFee.maxPriorityFeePerGas
+          );
+          tx.maxPriorityFeePerGas = `0x${priorityFeeWei.toString(16)}`;
+        } catch (error) {
+          console.error(
+            "[AbcProvider] \u274C Failed to parse maxPriorityFeePerGas:",
+            error
+          );
+        }
+      }
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signTransaction({
+        network: getNetworkName(this.chainId),
+        to: tx.to,
+        value: tx.value || "0x0",
+        data: tx.data || "0x",
+        gasLimit: tx.gas || tx.gasLimit,
+        maxFeePerGas: tx.maxFeePerGas,
+        maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        nonce: tx.nonce ? String(Number.parseInt(tx.nonce, 16)) : void 0,
+        ...pinHash && { pin: pinHash },
+        ...email && { email }
+      })
+    );
+    return result.signature;
+  }
+  /**
+   * Personal sign (EIP-191)
+   */
+  async personal_sign(params) {
+    if (!this.wallet) {
+      console.error("[AbcProvider] \u274C Wallet not connected");
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      console.error("[AbcProvider] \u274C Invalid params:", params);
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid personal_sign params"
+      );
+    }
+    await this.callInterceptor("personal_sign", params);
+    const [message, address] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      console.error("[AbcProvider] \u274C Address mismatch");
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signPersonal({
+        network,
+        message,
+        address,
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
+    return result.signature;
+  }
+  /**
+   * Eth sign
+   */
+  async eth_sign(params) {
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid eth_sign params"
+      );
+    }
+    const [address, message] = params;
+    return this.personal_sign([message, address]);
+  }
+  /**
+   * Sign typed data (EIP-712)
+   */
+  async eth_signTypedData(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signTypedData params"
+      );
+    }
+    await this.callInterceptor("eth_signTypedData_v4", params);
+    const [address, typedData] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signTypedData({
+        network,
+        typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
+    return result.signature;
+  }
+  /**
+   * Return normalized wallet capabilities for ABC embedded wallets.
+   * ABC supports EIP-7702 authorization signing via talken-api.
+   */
+  async wallet_getCapabilities() {
+    return {
+      supportsTypedDataV4: true,
+      supports7702Authorization: true,
+      supports5792Batch: false,
+      supportsPaymasterService: false,
+      supportsPermit2RelayHints: true,
+      walletType: "abc-embedded"
+    };
+  }
+  /**
+   * Sign EIP-7702 authorization via Talken API.
+   */
+  async eth_signAuthorization(params) {
+    if (!this.wallet) {
+      throw new ProviderRpcError(
+        ErrorCode.UNAUTHORIZED,
+        "Wallet not connected"
+      );
+    }
+    if (!Array.isArray(params) || params.length < 2) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid signAuthorization params"
+      );
+    }
+    const [address, authorization] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    if (!authorization?.address || authorization.chainId == null || authorization.nonce == null) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Authorization payload is incomplete"
+      );
+    }
+    await this.callInterceptor("eth_signAuthorization", params);
+    const api = this.getTalkenApiClientOrThrow();
+    const network = getNetworkName(this.chainId);
+    const pinHash = getCredentialManager().getPinHash() || void 0;
+    const email = this.getRecoveryEmail();
+    const chainIdValue = typeof authorization.chainId === "string" ? Number(BigInt(authorization.chainId)) : Number(authorization.chainId);
+    const nonceValue = typeof authorization.nonce === "string" ? BigInt(authorization.nonce).toString() : String(authorization.nonce);
+    const authAddress = authorization.address;
+    const result = await this.withSigningCredentialRetry(
+      () => api.evm.signAuthorization({
+        network,
+        authorization: {
+          chainId: chainIdValue,
+          address: authAddress,
+          nonce: nonceValue
+        },
+        pin: pinHash,
+        ...email && { email }
+      })
+    );
+    return result.authorization;
+  }
+  /**
+   * Switch Ethereum chain
+   */
+  async wallet_switchEthereumChain(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid switchEthereumChain params"
+      );
+    }
+    const { chainId } = params[0];
+    const newChainId = hexToNumber(chainId);
+    if (this.chainId === newChainId) {
+      return null;
+    }
+    const _previousChainId = this.chainId;
+    this.chainId = newChainId;
+    if (this.wallet) {
+      this.wallet.chainId = newChainId;
+    }
+    this.emit("chainChanged", numberToHex(newChainId));
+    return null;
+  }
+  /**
+   * Add Ethereum chain
+   */
+  async wallet_addEthereumChain(params) {
+    return this.wallet_switchEthereumChain(params);
+  }
+  /**
+   * Get transaction count (nonce) using ABC WaaS API
+   */
+  async eth_getTransactionCount(params) {
+    const address = params[0]?.toLowerCase();
+    if (!address) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing address parameter"
+      );
+    }
+    const currentChainId = this.chainId;
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.getNonce(
+        getNetworkName(currentChainId),
+        address
+      );
+      const nonce = response.result !== void 0 ? typeof response.result === "number" ? `0x${response.result.toString(16)}` : response.result : void 0;
+      if (!nonce) {
+        throw new Error("No result in nonce response");
+      }
+      return nonce;
+    } catch (error) {
+      console.error(
+        "[AbcEvmProvider] \u274C Failed to get transaction count from ABC WaaS:",
+        error
+      );
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        `Failed to get transaction count: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Estimate gas for transaction
+   * Uses ABC WaaS gas estimation API with fallback
+   */
+  async eth_estimateGas(params) {
+    if (!Array.isArray(params) || params.length === 0) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Invalid estimateGas params"
+      );
+    }
+    const tx = params[0];
+    if (!tx.to) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        'Transaction must have "to" field'
+      );
+    }
+    try {
+      const response = await this.getTalkenApiClientOrThrow().evm.estimateGas({
+        network: getNetworkName(this.chainId),
+        from: tx.from || this.wallet?.address || "",
+        to: tx.to,
+        value: tx.value,
+        data: tx.data
+      });
+      if (!response.result) {
+        throw new Error("No result in gas estimate response");
+      }
+      return response.result;
+    } catch (error) {
+      console.warn(
+        "[AbcEvmProvider] Gas estimation failed, using fallback:",
+        error
+      );
+      if (tx.data && tx.data !== "0x") {
+        return "0x493e0";
+      }
+      return "0x5208";
+    }
+  }
+  /**
+   * Execute read-only eth_call via talken-api
+   */
+  async eth_call(params) {
+    const p = Array.isArray(params) ? params : [];
+    const tx = p[0];
+    if (!tx?.to || !tx?.data) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "eth_call requires to and data"
+      );
+    }
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.ethCall({
+        network: getNetworkName(this.chainId),
+        to: tx.to,
+        data: tx.data,
+        from: tx.from || this.wallet?.address
+      });
+      return response?.result ?? response?.data ?? "0x";
+    } catch (error) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        `eth_call failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get native balance via talken-api
+   */
+  async eth_getBalance(params) {
+    const p = Array.isArray(params) ? params : [];
+    const address = p[0] || this.wallet?.address;
+    if (!address) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing address parameter"
+      );
+    }
+    try {
+      const api = this.getTalkenApiClientOrThrow();
+      const response = await api.evm.getBalance(
+        getNetworkName(this.chainId),
+        address
+      );
+      return response?.balance ?? "0x0";
+    } catch (error) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        `eth_getBalance failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get current chain ID
+   */
+  getChainId() {
+    return this.chainId;
+  }
+};
+function createAbcEvmProvider(talkenApi) {
+  return new AbcEvmProvider(talkenApi);
+}
+var createAbcProvider = createAbcEvmProvider;
+
+export {
+  AbcEvmProvider,
+  createAbcEvmProvider,
+  createAbcProvider
+};