@talken/talkenkit 2.4.28 → 2.4.29

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

@@ -0,0 +1,640 @@
+"use client";
+import {
+  getChainKey,
+  getNetworkName
+} from "./chunk-7QHCSJDN.js";
+import {
+  hexToNumber,
+  numberToHex
+} from "./chunk-LOSXI36Y.js";
+
+// src/wallets/walletConnectors/abcWallet/abcProvider.ts
+import { getTalkenApiClient } 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(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 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;
+  }
+  /**
+   * 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_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 resolved = await this.callInterceptor("eth_sendTransaction", 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 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 = localStorage.getItem("talkenkit_abc_pin_hash");
+    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 api = this.talkenApi || getTalkenApiClient();
+    const result = await api.evm.sendTransaction({
+      chainKey: getChainKey(this.chainId),
+      to: tx.to,
+      amountWei,
+      pin: pinHash,
+      data: tx.data || "0x",
+      gasLimit: tx.gas || tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+    });
+    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.talkenApi || getTalkenApiClient();
+    const result = await 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
+    });
+    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.talkenApi || getTalkenApiClient();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    const result = await api.evm.signPersonal({
+      network,
+      message,
+      address,
+      pin: pinHash
+    });
+    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.talkenApi || getTalkenApiClient();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    const result = await api.evm.signTypedData({
+      network,
+      typedData: typeof typedData === "string" ? typedData : JSON.stringify(typedData),
+      pin: pinHash
+    });
+    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"
+      );
+    }
+    const api = this.talkenApi || getTalkenApiClient();
+    const network = getNetworkName(this.chainId);
+    const pinHash = localStorage.getItem("talkenkit_abc_pin_hash") || void 0;
+    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 result = await api.evm.signAuthorization({
+      network,
+      authorization: {
+        chainId: chainIdValue,
+        address: authorization.address,
+        nonce: nonceValue
+      },
+      pin: pinHash
+    });
+    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 nonce = await this.client.getTransactionCount({
+        chainId: currentChainId,
+        address
+      });
+      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, talkenApi) {
+  const provider = new AbcEvmProvider(client);
+  if (talkenApi) {
+    provider.setTalkenApi(talkenApi);
+  }
+  return provider;
+}
+var createAbcProvider = createAbcEvmProvider;
+
+export {
+  AbcEvmProvider,
+  createAbcEvmProvider,
+  createAbcProvider
+};

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

@@ -0,0 +1,52 @@
+"use client";
+import {
+  createTalkenApiClient
+} from "./chunk-JVT7R2GZ.js";
+import {
+  abcConnector
+} from "./chunk-BLO7E54F.js";
+import {
+  ABC_WALLET_METADATA
+} from "./chunk-M2U5QGM7.js";
+
+// src/wallets/walletConnectors/abcWallet/abcWallet.ts
+import { setTalkenApiClient } from "@talken/talkenkit";
+var abcWallet = (specificOptions) => ({ projectId }) => {
+  const talkenApiUrl = specificOptions?.talkenApiUrl || process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001/api/v1";
+  const talkenApi = createTalkenApiClient({
+    baseUrl: talkenApiUrl,
+    debug: specificOptions?.environment === "development"
+  });
+  setTalkenApiClient(talkenApi);
+  const waasUrl = specificOptions?.waasUrl || process.env.NEXT_PUBLIC_ABC_WAAS_URL || process.env.VITE_ABC_WAAS_URL || "";
+  const config = {
+    waasUrl,
+    apiKey: specificOptions?.apiKey,
+    plain: specificOptions?.plain || "",
+    // Deprecated - not used (secure.ts uses random generation)
+    environment: specificOptions?.environment || "development",
+    defaultChainId: specificOptions?.defaultChainId,
+    defaultSolanaNetwork: specificOptions?.defaultSolanaNetwork,
+    defaultBitcoinNetwork: specificOptions?.defaultBitcoinNetwork,
+    projectId
+  };
+  return {
+    id: ABC_WALLET_METADATA.id,
+    name: ABC_WALLET_METADATA.name,
+    rdns: ABC_WALLET_METADATA.rdns,
+    iconUrl: async () => (await import("./abcWallet-AYWSIGAG.js")).default,
+    iconBackground: ABC_WALLET_METADATA.iconBackground,
+    // Embedded wallet - no installation required
+    installed: void 0,
+    // No download URLs for embedded wallet
+    downloadUrls: void 0,
+    // Create connector - wrapper function required by Wallet type
+    createConnector: (_walletDetails) => abcConnector({ config }),
+    // Embedded wallet always available
+    hidden: () => false
+  };
+};
+
+export {
+  abcWallet
+};