@talken/talkenkit 2.4.11 → 2.4.13

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

@@ -0,0 +1,513 @@
+"use client";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-5RSS3SRV.js";
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+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(client) {
+    super();
+    this.wallet = null;
+    this.chainId = 1;
+    // Default to Ethereum mainnet
+    this.connected = false;
+    this.client = client;
+  }
+  /**
+   * 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 PIN request callback
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user
+   */
+  async requestPin() {
+    if (!this.requestPinCallback) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "PIN request callback not configured"
+      );
+    }
+    return this.requestPinCallback();
+  }
+  /**
+   * 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_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_blockNumber":
+      case "eth_call":
+      case "eth_gasPrice":
+      case "eth_getBalance":
+      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 tx = params[0];
+    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 pin = await this.requestPin();
+    const signParams = {
+      chainId: this.chainId,
+      transaction: tx,
+      keyId: this.wallet.keyId,
+      encryptedShare: this.wallet.encryptedShare,
+      pin
+    };
+    const signResult = await this.client.signTransaction(signParams);
+    if (!signResult.signature) {
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Failed to get signed transaction from ABC WaaS"
+      );
+    }
+    const sendResult = await this.client.sendRawTransaction(
+      this.chainId,
+      signResult.signature
+      // serializedTx
+    );
+    return sendResult.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 tx = params[0];
+    const pin = await this.requestPin();
+    const signParams = {
+      chainId: this.chainId,
+      transaction: tx,
+      keyId: this.wallet.keyId,
+      encryptedShare: this.wallet.encryptedShare,
+      pin
+    };
+    const result = await this.client.signTransaction(signParams);
+    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"
+      );
+    }
+    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"
+      );
+    }
+    if (!this.wallet.sid) {
+      console.error("[AbcProvider] \u274C Missing sid");
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Wallet session ID (sid) is missing - please reconnect wallet"
+      );
+    }
+    if (!this.wallet.pvencstr) {
+      console.error("[AbcProvider] \u274C Missing pvencstr");
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Wallet pvencstr is missing - please reconnect wallet"
+      );
+    }
+    if (!this.wallet.wid) {
+      console.error("[AbcProvider] \u274C Missing wid");
+      throw new ProviderRpcError(
+        ErrorCode.INTERNAL_ERROR,
+        "Wallet wid is missing - please reconnect wallet"
+      );
+    }
+    const result = await this.client.signMessage({
+      message,
+      address: this.wallet.address,
+      // ciphertext removed - not needed for message signing
+      sid: this.wallet.sid,
+      uid: this.wallet.uid,
+      pvencstr: this.wallet.pvencstr,
+      wid: this.wallet.wid
+    });
+    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"
+      );
+    }
+    const [address, typedData] = params;
+    if (address.toLowerCase() !== this.wallet.address.toLowerCase()) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Address does not match connected wallet"
+      );
+    }
+    const result = await this.client.signTypedData({
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData)
+      // ciphertext removed - not needed for typed data signing
+    });
+    return result.signature;
+  }
+  /**
+   * 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) {
+    console.log("[AbcEvmProvider] \u{1F4CA} Getting transaction count for ABC Wallet");
+    const address = params[0]?.toLowerCase();
+    if (!address) {
+      throw new ProviderRpcError(
+        ErrorCode.INVALID_PARAMS,
+        "Missing address parameter"
+      );
+    }
+    const currentChainId = this.chainId;
+    console.log("[AbcEvmProvider] Transaction count for:", {
+      address,
+      chainId: currentChainId
+    });
+    try {
+      const nonce = await this.client.getTransactionCount({
+        chainId: currentChainId,
+        address
+      });
+      console.log(
+        `[AbcEvmProvider] \u2705 Transaction count from ABC WaaS: ${nonce}`
+      );
+      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 gasLimit = await this.client.estimateGas({
+        chainId: this.chainId,
+        from: tx.from || this.wallet?.address,
+        to: tx.to,
+        value: tx.value,
+        data: tx.data
+      });
+      return gasLimit;
+    } catch (error) {
+      console.warn(
+        "[AbcEvmProvider] Gas estimation failed, using fallback:",
+        error
+      );
+      if (tx.data && tx.data !== "0x") {
+        return "0x493e0";
+      }
+      return "0x5208";
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get current wallet
+   */
+  getWallet() {
+    return this.wallet;
+  }
+  /**
+   * Get current chain ID
+   */
+  getChainId() {
+    return this.chainId;
+  }
+};
+function createAbcEvmProvider(client) {
+  return new AbcEvmProvider(client);
+}
+var createAbcProvider = createAbcEvmProvider;
+
+export {
+  AbcEvmProvider,
+  createAbcEvmProvider,
+  createAbcProvider
+};