@talken/talkenkit 2.4.17 → 2.4.19

package/dist/wallets/walletConnectors/chunk-2NHQTZGS.js

@@ -1,276 +0,0 @@
-"use client";
-import {
-  createAbcEvmProvider
-} from "./chunk-Z2IWGNDA.js";
-import {
-  createAbcWaasClient
-} from "./chunk-HIRSPIIU.js";
-import {
-  setGlobalDefaultBitcoinNetwork,
-  setGlobalDefaultChainId,
-  setGlobalDefaultSolanaNetwork
-} from "./chunk-A7FIBI6X.js";
-import {
-  clearAuthState,
-  clearEncryptedTokens,
-  clearStorage,
-  loadAuthState,
-  loadFromStorage,
-  saveAuthState
-} from "./chunk-TYUEB4VT.js";
-
-// src/wallets/walletConnectors/abcWallet/abcConnector.ts
-import { createConnector } from "wagmi";
-function abcConnector(options) {
-  const { config } = options;
-  if (config.defaultChainId) {
-    setGlobalDefaultChainId(config.defaultChainId);
-  }
-  if (config.defaultSolanaNetwork) {
-    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
-  }
-  if (config.defaultBitcoinNetwork) {
-    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
-  }
-  return createConnector((wagmiConfig) => {
-    const client = createAbcWaasClient(config);
-    const provider = createAbcEvmProvider(client);
-    let accountsChangedHandler;
-    let chainChangedHandler;
-    let disconnectHandler;
-    return {
-      id: "abc",
-      name: "ABC Wallet",
-      type: "abc",
-      /**
-       * Connect wallet
-       */
-      async connect() {
-        try {
-          const authState = loadAuthState();
-          if (!authState || !authState.isAuthenticated || !authState.wallet) {
-            throw new Error("ABC_LOGIN_REQUIRED");
-          }
-          provider.setWallet(authState.wallet);
-          if (authState.accessToken && authState.refreshToken && authState.expiresAt) {
-            client.setTokens(
-              authState.accessToken,
-              authState.refreshToken,
-              authState.expiresAt
-            );
-          }
-          const accounts = await provider.request({
-            method: "eth_requestAccounts"
-          });
-          const currentChainId = await provider.request({
-            method: "eth_chainId"
-          });
-          if (accountsChangedHandler) {
-            provider.removeListener("accountsChanged", accountsChangedHandler);
-          }
-          accountsChangedHandler = (accounts2) => {
-            wagmiConfig.emitter.emit("change", {
-              accounts: accounts2
-            });
-          };
-          provider.on("accountsChanged", accountsChangedHandler);
-          if (chainChangedHandler) {
-            provider.removeListener("chainChanged", chainChangedHandler);
-          }
-          chainChangedHandler = (chainId) => {
-            wagmiConfig.emitter.emit("change", {
-              chainId: Number(chainId)
-            });
-          };
-          provider.on("chainChanged", chainChangedHandler);
-          if (disconnectHandler) {
-            provider.removeListener("disconnect", disconnectHandler);
-          }
-          disconnectHandler = () => {
-            wagmiConfig.emitter.emit("disconnect");
-            this.onDisconnect();
-          };
-          provider.on("disconnect", disconnectHandler);
-          wagmiConfig.emitter.emit("connect", {
-            accounts,
-            chainId: Number(currentChainId)
-          });
-          return {
-            accounts,
-            chainId: Number(currentChainId)
-          };
-        } catch (error) {
-          console.error("\u274C ABC Connector connect() failed:", {
-            message: error.message,
-            code: error.code,
-            error
-          });
-          if (error.message === "ABC_LOGIN_REQUIRED") {
-            throw error;
-          }
-          throw error;
-        }
-      },
-      /**
-       * Disconnect wallet
-       */
-      async disconnect() {
-        if (accountsChangedHandler) {
-          provider.removeListener("accountsChanged", accountsChangedHandler);
-          accountsChangedHandler = void 0;
-        }
-        if (chainChangedHandler) {
-          provider.removeListener("chainChanged", chainChangedHandler);
-          chainChangedHandler = void 0;
-        }
-        if (disconnectHandler) {
-          provider.removeListener("disconnect", disconnectHandler);
-          disconnectHandler = void 0;
-        }
-        provider.clearWallet();
-        await client.logout();
-        let savedPinHash = null;
-        let savedEmail = null;
-        if (typeof window !== "undefined") {
-          savedPinHash = localStorage.getItem("talkenkit_abc_pin_hash");
-          savedEmail = localStorage.getItem("talkenkit_abc_saved_email");
-        }
-        clearAuthState();
-        clearEncryptedTokens();
-        if (typeof window !== "undefined") {
-          localStorage.removeItem("talkenkit_abc_enc_salt");
-          localStorage.removeItem("talkenkit_abc_enc_tokens");
-          if (savedPinHash) {
-            localStorage.setItem("talkenkit_abc_pin_hash", savedPinHash);
-          }
-          if (savedEmail) {
-            localStorage.setItem("talkenkit_abc_saved_email", savedEmail);
-          }
-        }
-        console.log("\u2705 ABC Wallet disconnected (PIN preserved)");
-      },
-      /**
-       * Get accounts
-       */
-      async getAccounts() {
-        const accounts = await provider.request({
-          method: "eth_accounts"
-        });
-        return accounts.map((account) => account);
-      },
-      /**
-       * Get chain ID
-       */
-      async getChainId() {
-        const chainId = await provider.request({
-          method: "eth_chainId"
-        });
-        return Number(chainId);
-      },
-      /**
-       * Get provider
-       */
-      async getProvider() {
-        return provider;
-      },
-      /**
-       * Check if authorized (has valid session)
-       * Auto-refreshes access token if expired but refresh token is valid
-       */
-      async isAuthorized() {
-        try {
-          const authState = loadAuthState();
-          if (!authState || !authState.isAuthenticated) {
-            return false;
-          }
-          if (!authState.wallet) {
-            return false;
-          }
-          if (client.isAuthenticated()) {
-            return true;
-          }
-          const refreshToken = loadFromStorage(
-            "refresh_token" /* REFRESH_TOKEN */
-          );
-          if (!refreshToken) {
-            clearStorage();
-            return false;
-          }
-          try {
-            await client.refreshTokens(refreshToken);
-            const updatedState = loadAuthState();
-            return updatedState?.isAuthenticated ?? false;
-          } catch (error) {
-            console.error("[AbcConnector] Token refresh failed:", error);
-            clearStorage();
-            return false;
-          }
-        } catch (error) {
-          console.error(
-            "[AbcConnector] Unexpected error in isAuthorized:",
-            error
-          );
-          return false;
-        }
-      },
-      /**
-       * Switch chain
-       */
-      async switchChain({ chainId }) {
-        await provider.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId: `0x${chainId.toString(16)}` }]
-        });
-        const newChainId = await this.getChainId();
-        const authState = loadAuthState();
-        if (authState?.wallet) {
-          authState.wallet.chainId = newChainId;
-          saveAuthState(authState);
-        }
-        return wagmiConfig.chains.find((x) => x.id === chainId) ?? {
-          id: chainId,
-          name: `Chain ${chainId}`,
-          nativeCurrency: {
-            name: "Ether",
-            decimals: 18,
-            symbol: "ETH"
-          },
-          rpcUrls: {
-            default: { http: [""] }
-          }
-        };
-      },
-      /**
-       * Handle accounts changed
-       */
-      onAccountsChanged(accounts) {
-        if (accounts.length === 0) {
-          this.onDisconnect();
-        } else {
-          wagmiConfig.emitter.emit("change", {
-            accounts
-          });
-        }
-      },
-      /**
-       * Handle chain changed
-       */
-      onChainChanged(chain) {
-        const chainId = Number(chain);
-        wagmiConfig.emitter.emit("change", { chainId });
-      },
-      /**
-       * Handle disconnect
-       */
-      onDisconnect(_error) {
-        provider.clearWallet();
-        clearAuthState();
-        wagmiConfig.emitter.emit("disconnect");
-      }
-    };
-  });
-}
-
-export {
-  abcConnector
-};

package/dist/wallets/walletConnectors/chunk-2NVHWZUE.js

@@ -1,436 +0,0 @@
-"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_blockNumber":
-      case "eth_call":
-      case "eth_estimateGas":
-      case "eth_gasPrice":
-      case "eth_getBalance":
-      case "eth_getBlockByHash":
-      case "eth_getBlockByNumber":
-      case "eth_getCode":
-      case "eth_getStorageAt":
-      case "eth_getTransactionByHash":
-      case "eth_getTransactionCount":
-      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);
-  }
-  /**
-   * 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
-};