@talken/talkenkit 2.3.14 → 2.4.4

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

@@ -1,269 +0,0 @@
-"use client";
-import {
-  createAbcEvmProvider
-} from "./chunk-ZIYAL44B.js";
-import {
-  createAbcWaasClient
-} from "./chunk-SKBQVOZL.js";
-import {
-  clearAuthState,
-  clearEncryptedTokens,
-  clearStorage,
-  loadAuthState,
-  loadFromStorage,
-  saveAuthState
-} from "./chunk-UV5HHESJ.js";
-
-// src/wallets/walletConnectors/abcWallet/abcConnector.ts
-import { createConnector } from "wagmi";
-function abcConnector(options) {
-  const { config } = options;
-  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();
-          console.log("\u{1F527} ABC Connector connect() called:", {
-            hasAuthState: !!authState,
-            isAuthenticated: authState?.isAuthenticated,
-            hasWallet: !!authState?.wallet,
-            walletAddress: authState?.wallet?.address
-          });
-          if (!authState || !authState.isAuthenticated || !authState.wallet) {
-            throw new Error("ABC_LOGIN_REQUIRED");
-          }
-          provider.setWallet(authState.wallet);
-          console.log("\u2705 Provider wallet set:", {
-            address: authState.wallet.address,
-            hasPIN: !!authState.pin
-          });
-          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);
-          console.log("\u2705 ABC Connector connected successfully:", {
-            accounts: accounts.length,
-            chainId: Number(currentChainId)
-          });
-          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-FROV5VDF.js

@@ -1,346 +0,0 @@
-"use client";
-
-// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.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 SolanaErrorCode = {
-  USER_REJECTED: 4001,
-  UNAUTHORIZED: 4100,
-  UNSUPPORTED_METHOD: 4200,
-  DISCONNECTED: 4900,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603
-};
-var SolanaProviderError = class extends Error {
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-    this.name = "SolanaProviderError";
-  }
-};
-var SOLANA_NETWORKS = {
-  mainnet: {
-    name: "Solana Mainnet",
-    rpc: "https://api.mainnet-beta.solana.com",
-    chainId: "solana:mainnet"
-  },
-  devnet: {
-    name: "Solana Devnet",
-    rpc: "https://api.devnet.solana.com",
-    chainId: "solana:devnet"
-  },
-  testnet: {
-    name: "Solana Testnet",
-    rpc: "https://api.testnet.solana.com",
-    chainId: "solana:testnet"
-  }
-};
-var AbcSolanaProvider = class extends EventEmitter {
-  constructor(client) {
-    super();
-    this.wallet = null;
-    this.network = SOLANA_NETWORKS.devnet;
-    this.connected = false;
-    this.client = client;
-  }
-  /**
-   * Set wallet information
-   */
-  setWallet(wallet) {
-    const previousAddress = this.wallet?.address;
-    this.wallet = wallet;
-    this.connected = true;
-    if (previousAddress !== wallet.address) {
-      this.emit("accountsChanged", [wallet.address]);
-    }
-    this.emit("connect", { address: wallet.address });
-  }
-  /**
-   * Clear wallet (disconnect)
-   */
-  clearWallet() {
-    this.wallet = null;
-    this.connected = false;
-    this.emit("disconnect");
-    this.emit("accountsChanged", []);
-  }
-  /**
-   * Set PIN request callback
-   */
-  setRequestPinCallback(callback) {
-    this.requestPinCallback = callback;
-  }
-  /**
-   * Request PIN from user
-   */
-  async requestPin() {
-    if (!this.requestPinCallback) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "PIN request callback not configured"
-      );
-    }
-    return this.requestPinCallback();
-  }
-  /**
-   * Set network
-   */
-  setNetwork(networkKey) {
-    const newNetwork = SOLANA_NETWORKS[networkKey];
-    if (!newNetwork) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INVALID_PARAMS,
-        `Unknown network: ${networkKey}`
-      );
-    }
-    const previousChainId = this.network.chainId;
-    this.network = newNetwork;
-    if (previousChainId !== newNetwork.chainId) {
-      this.emit("chainChanged", newNetwork.chainId);
-    }
-  }
-  /**
-   * Get current network
-   */
-  getNetwork() {
-    return this.network;
-  }
-  /**
-   * Connect wallet
-   */
-  async connect() {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    this.connected = true;
-    this.emit("connect", { address: this.wallet.address });
-    return {
-      publicKey: this.wallet.publicKey,
-      address: this.wallet.address
-    };
-  }
-  /**
-   * Disconnect wallet
-   */
-  async disconnect() {
-    this.clearWallet();
-  }
-  /**
-   * Sign transaction
-   * @param transaction - Serialized transaction bytes
-   * @returns Signed transaction with signature inserted
-   */
-  async signTransaction(transaction) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    const pin = await this.requestPin();
-    const transactionHex = Buffer.from(transaction).toString("hex");
-    const result = await this.client.signSolanaTransaction({
-      uid: this.wallet.uid,
-      shareId: this.wallet.shareId,
-      keyId: this.wallet.keyId,
-      encryptedShare: this.wallet.encryptedShare,
-      secretStore: this.wallet.secretStore,
-      publicKey: this.wallet.publicKey,
-      message: transactionHex,
-      pin
-    });
-    if (!result.signature) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "ABC WaaS returned no signature"
-      );
-    }
-    const signature = new Uint8Array(Buffer.from(result.signature, "hex"));
-    return this.insertSignatureIntoTransaction(transaction, signature);
-  }
-  /**
-   * Sign all transactions
-   */
-  async signAllTransactions(transactions) {
-    const signedTransactions = [];
-    for (const tx of transactions) {
-      const signedTx = await this.signTransaction(tx);
-      signedTransactions.push(signedTx);
-    }
-    return signedTransactions;
-  }
-  /**
-   * Sign message
-   * @param message - Message bytes to sign
-   * @returns Signature bytes
-   */
-  async signMessage(message) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    const pin = await this.requestPin();
-    const messageHex = Buffer.from(message).toString("hex");
-    const result = await this.client.signSolanaMessage({
-      uid: this.wallet.uid,
-      shareId: this.wallet.shareId,
-      keyId: this.wallet.keyId,
-      encryptedShare: this.wallet.encryptedShare,
-      secretStore: this.wallet.secretStore,
-      publicKey: this.wallet.publicKey,
-      message: messageHex,
-      pin
-    });
-    if (!result.signature) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INTERNAL_ERROR,
-        "ABC WaaS returned no signature"
-      );
-    }
-    return new Uint8Array(Buffer.from(result.signature, "hex"));
-  }
-  /**
-   * Send transaction
-   * @param transaction - Signed transaction bytes
-   * @returns Transaction hash
-   */
-  async sendTransaction(transaction) {
-    if (!this.wallet) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.UNAUTHORIZED,
-        "Wallet not connected"
-      );
-    }
-    const signature = this.extractSignatureFromTransaction(transaction);
-    const serializedTxHex = Buffer.from(transaction).toString("hex");
-    const signatureHex = Buffer.from(signature).toString("hex");
-    const result = await this.client.sendSolanaTransaction({
-      network: this.network.chainId.split(":")[1],
-      // 'mainnet' or 'devnet'
-      serializedTX: serializedTxHex,
-      signatures: [signatureHex]
-    });
-    return result.txHash;
-  }
-  /**
-   * Sign and send transaction (convenience method)
-   */
-  async signAndSendTransaction(transaction) {
-    const signedTx = await this.signTransaction(transaction);
-    return this.sendTransaction(signedTx);
-  }
-  /**
-   * Get accounts
-   */
-  async getAccounts() {
-    if (!this.wallet) {
-      return [];
-    }
-    return [this.wallet.address];
-  }
-  /**
-   * Get public key
-   */
-  getPublicKey() {
-    return this.wallet?.publicKey ?? null;
-  }
-  /**
-   * Get address
-   */
-  getAddress() {
-    return this.wallet?.address ?? null;
-  }
-  /**
-   * Check if connected
-   */
-  isConnected() {
-    return this.connected && this.wallet !== null;
-  }
-  /**
-   * Get current wallet
-   */
-  getWallet() {
-    return this.wallet;
-  }
-  /**
-   * Insert signature into Solana transaction
-   * Solana transactions have signature slots at the beginning
-   */
-  insertSignatureIntoTransaction(transaction, signature) {
-    const result = new Uint8Array(1 + signature.length + transaction.length);
-    result[0] = 1;
-    result.set(signature, 1);
-    result.set(transaction, 1 + signature.length);
-    return result;
-  }
-  /**
-   * Extract signature from signed Solana transaction
-   */
-  extractSignatureFromTransaction(transaction) {
-    const numSignatures = transaction[0];
-    if (numSignatures === 0) {
-      throw new SolanaProviderError(
-        SolanaErrorCode.INVALID_PARAMS,
-        "Transaction has no signatures"
-      );
-    }
-    return transaction.slice(1, 1 + 64);
-  }
-};
-function createAbcSolanaProvider(client) {
-  return new AbcSolanaProvider(client);
-}
-
-export {
-  SolanaProviderError,
-  SOLANA_NETWORKS,
-  AbcSolanaProvider,
-  createAbcSolanaProvider
-};

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

@@ -1,63 +0,0 @@
-"use client";
-import {
-  WalletApi
-} from "./chunk-F5Q4VDER.js";
-import {
-  SolanaApi
-} from "./chunk-SGLHM6AU.js";
-import {
-  AuthApi
-} from "./chunk-YEHCPL4R.js";
-import {
-  BitcoinApi
-} from "./chunk-QKUFFUM5.js";
-import {
-  SigningApi
-} from "./chunk-V3XKL7AD.js";
-import {
-  TransactionApi
-} from "./chunk-ISAMATTH.js";
-
-// src/wallets/walletConnectors/abcWallet/api/index.ts
-var AbcWaasApiClient = class {
-  constructor(config) {
-    this.auth = new AuthApi(config);
-    this.wallet = new WalletApi(config);
-    this.transaction = new TransactionApi(config);
-    this.signing = new SigningApi(config);
-    this.solana = new SolanaApi(config);
-    this.bitcoin = new BitcoinApi(config);
-  }
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated() {
-    return this.auth.isAuthenticated();
-  }
-  /**
-   * Check if access token is expired
-   */
-  isTokenExpired() {
-    return this.auth.isTokenExpired();
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.auth.getAccessToken();
-  }
-  /**
-   * Logout (clear tokens)
-   */
-  async logout() {
-    await this.auth.logout();
-  }
-};
-function createAbcWaasApiClient(config) {
-  return new AbcWaasApiClient(config);
-}
-
-export {
-  AbcWaasApiClient,
-  createAbcWaasApiClient
-};