@talken/talkenkit 2.3.4

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

@@ -0,0 +1,364 @@
+"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");
+    console.log("[AbcSolanaProvider] Sign transaction request:", {
+      transactionLength: transaction.length,
+      transactionHex: `${transactionHex.substring(0, 100)}...`,
+      hasWallet: !!this.wallet,
+      walletKeys: Object.keys(this.wallet)
+    });
+    const result = await this.client.signSolanaTransaction({
+      uid: this.wallet.uid,
+      shareId: this.wallet.shareId,
+      publicKey: this.wallet.publicKey,
+      message: transactionHex,
+      pin
+    });
+    console.log("[AbcSolanaProvider] Sign transaction response:", {
+      hasSignature: !!result.signature,
+      signatureLength: result.signature?.length
+    });
+    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");
+    console.log("[AbcSolanaProvider] Sign message request:", {
+      messageLength: message.length,
+      messageHex
+    });
+    const result = await this.client.signSolanaMessage({
+      uid: this.wallet.uid,
+      shareId: this.wallet.shareId,
+      publicKey: this.wallet.publicKey,
+      message: messageHex,
+      pin
+    });
+    console.log("[AbcSolanaProvider] Sign message response:", {
+      hasSignature: !!result.signature
+    });
+    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");
+    console.log("[AbcSolanaProvider] Send transaction request:", {
+      network: this.network.name,
+      txLength: transaction.length
+    });
+    const result = await this.client.sendSolanaTransaction({
+      network: this.network.chainId.split(":")[1],
+      // 'mainnet' or 'devnet'
+      serializedTX: serializedTxHex,
+      signatures: [signatureHex]
+    });
+    console.log("[AbcSolanaProvider] Send transaction response:", {
+      txHash: result.txHash
+    });
+    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-NHZMJSPE.js

@@ -0,0 +1,98 @@
+"use client";
+import {
+  isAndroid
+} from "./chunk-RETKWSKD.js";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/frontierWallet/frontierWallet.ts
+var frontierWallet = ({
+  projectId,
+  walletConnectParameters
+}) => {
+  const isFrontierInjected = hasInjectedProvider({
+    namespace: "frontier.ethereum",
+    flag: "isFrontier"
+  });
+  const shouldUseWalletConnect = !isFrontierInjected;
+  return {
+    id: "frontier",
+    name: "Frontier Wallet",
+    rdns: "xyz.frontier.wallet",
+    installed: isFrontierInjected,
+    iconUrl: async () => (await import("./frontierWallet-HNIG7QYQ.js")).default,
+    iconBackground: "#CC703C",
+    downloadUrls: {
+      android: "https://play.google.com/store/apps/details?id=com.frontierwallet",
+      ios: "https://apps.apple.com/us/app/frontier-crypto-defi-wallet/id1482380988",
+      qrCode: "https://www.frontier.xyz/download",
+      chrome: "https://chrome.google.com/webstore/detail/frontier-wallet/kppfdiipphfccemcignhifpjkapfbihd",
+      browserExtension: "https://www.frontier.xyz/download"
+    },
+    mobile: {
+      getUri: shouldUseWalletConnect ? (uri) => {
+        return isAndroid() ? `frontier://wc?uri=${encodeURIComponent(uri)}` : uri;
+      } : void 0
+    },
+    qrCode: shouldUseWalletConnect ? {
+      getUri: (uri) => {
+        return isAndroid() ? `frontier://wc?uri=${encodeURIComponent(uri)}` : uri;
+      },
+      instructions: {
+        learnMoreUrl: "https://help.frontier.xyz/en/",
+        steps: [
+          {
+            description: "wallet_connectors.im_token.qr_code.step1.description",
+            step: "install",
+            title: "wallet_connectors.im_token.qr_code.step1.title"
+          },
+          {
+            description: "wallet_connectors.im_token.qr_code.step2.description",
+            step: "create",
+            title: "wallet_connectors.im_token.qr_code.step2.title"
+          },
+          {
+            description: "wallet_connectors.im_token.qr_code.step3.description",
+            step: "scan",
+            title: "wallet_connectors.im_token.qr_code.step3.title"
+          }
+        ]
+      }
+    } : void 0,
+    extension: {
+      instructions: {
+        learnMoreUrl: "https://help.frontier.xyz/en/articles/6967236-setting-up-frontier-on-your-device",
+        steps: [
+          {
+            description: "wallet_connectors.frontier.extension.step1.description",
+            step: "install",
+            title: "wallet_connectors.frontier.extension.step1.title"
+          },
+          {
+            description: "wallet_connectors.frontier.extension.step2.description",
+            step: "create",
+            title: "wallet_connectors.frontier.extension.step2.title"
+          },
+          {
+            description: "wallet_connectors.frontier.extension.step3.description",
+            step: "refresh",
+            title: "wallet_connectors.frontier.extension.step3.title"
+          }
+        ]
+      }
+    },
+    createConnector: shouldUseWalletConnect ? getWalletConnectConnector({ projectId, walletConnectParameters }) : getInjectedConnector({
+      namespace: "frontier.ethereum",
+      flag: "isFrontier"
+    })
+  };
+};
+
+export {
+  frontierWallet
+};

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

@@ -0,0 +1,45 @@
+"use client";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/nestWallet/nestWallet.ts
+var nestWallet = () => ({
+  id: "nest",
+  name: "Nest",
+  rdns: "xyz.nestwallet",
+  iconUrl: async () => (await import("./nestWallet-BFZZZYLV.js")).default,
+  iconBackground: "#fff0",
+  installed: hasInjectedProvider({ flag: "isNestWallet" }),
+  downloadUrls: {
+    browserExtension: "https://nestwallet.xyz"
+  },
+  extension: {
+    instructions: {
+      learnMoreUrl: "https://nestwallet.xyz",
+      steps: [
+        {
+          description: "wallet_connectors.nestwallet.extension.step1.description",
+          step: "install",
+          title: "wallet_connectors.nestwallet.extension.step1.title"
+        },
+        {
+          description: "wallet_connectors.nestwallet.extension.step2.description",
+          step: "create",
+          title: "wallet_connectors.nestwallet.extension.step2.title"
+        },
+        {
+          description: "wallet_connectors.nestwallet.extension.step3.description",
+          step: "refresh",
+          title: "wallet_connectors.nestwallet.extension.step3.title"
+        }
+      ]
+    }
+  },
+  createConnector: getInjectedConnector({ flag: "isNestWallet" })
+});
+
+export {
+  nestWallet
+};

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

@@ -0,0 +1,55 @@
+"use client";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+
+// src/wallets/walletConnectors/oneInchWallet/oneInchWallet.ts
+var oneInchWallet = ({
+  projectId,
+  walletConnectParameters
+}) => ({
+  id: "1inch",
+  name: "1inch Wallet",
+  iconUrl: async () => (await import("./oneInchWallet-D7BQOLOO.js")).default,
+  iconBackground: "#fff",
+  downloadUrls: {
+    android: "https://play.google.com/store/apps/details?id=io.oneinch.android",
+    ios: "https://apps.apple.com/us/app/1inch-crypto-defi-wallet/id1546049391",
+    mobile: "https://1inch.io/wallet",
+    qrCode: "https://1inch.io/wallet"
+  },
+  mobile: {
+    getUri: (uri) => `oneinch://wc?uri=${encodeURIComponent(uri)}`
+  },
+  qrCode: {
+    getUri: (uri) => uri,
+    instructions: {
+      learnMoreUrl: "https://1inch.io/wallet",
+      steps: [
+        {
+          description: "wallet_connectors.1inch.qr_code.step1.description",
+          step: "install",
+          title: "wallet_connectors.1inch.qr_code.step1.title"
+        },
+        {
+          description: "wallet_connectors.1inch.qr_code.step2.description",
+          step: "create",
+          title: "wallet_connectors.1inch.qr_code.step2.title"
+        },
+        {
+          description: "wallet_connectors.1inch.qr_code.step3.description",
+          step: "scan",
+          title: "wallet_connectors.1inch.qr_code.step3.title"
+        }
+      ]
+    }
+  },
+  createConnector: getWalletConnectConnector({
+    projectId,
+    walletConnectParameters
+  })
+});
+
+export {
+  oneInchWallet
+};

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

@@ -0,0 +1,57 @@
+"use client";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+
+// src/wallets/walletConnectors/bestWallet/bestWallet.ts
+var bestWallet = ({
+  projectId,
+  walletConnectParameters
+}) => ({
+  id: "bestWallet",
+  name: "Best Wallet",
+  iconUrl: async () => (await import("./bestWallet-XRIABRUE.js")).default,
+  iconBackground: "#5961FF",
+  downloadUrls: {
+    android: "https://best.sng.link/Dnio2/rto7?_smtype=3",
+    ios: "https://best.sng.link/Dnio2/rto7?_smtype=3",
+    mobile: "https://best.sng.link/Dnio2/rto7?_smtype=3",
+    qrCode: "https://best.sng.link/Dnio2/rto7?_smtype=3"
+  },
+  mobile: {
+    getUri: (uri) => {
+      return `bw://connect/wc?uri=${encodeURIComponent(uri)}`;
+    }
+  },
+  qrCode: {
+    getUri: (uri) => uri,
+    instructions: {
+      learnMoreUrl: "https://best.sng.link/Dnio2/rto7?_smtype=3",
+      steps: [
+        {
+          description: "wallet_connectors.best.qr_code.step1.description",
+          step: "install",
+          title: "wallet_connectors.best.qr_code.step1.title"
+        },
+        {
+          description: "wallet_connectors.best.qr_code.step2.description",
+          step: "create",
+          title: "wallet_connectors.best.qr_code.step2.title"
+        },
+        {
+          description: "wallet_connectors.best.qr_code.step3.description",
+          step: "scan",
+          title: "wallet_connectors.best.qr_code.step3.title"
+        }
+      ]
+    }
+  },
+  createConnector: getWalletConnectConnector({
+    projectId,
+    walletConnectParameters
+  })
+});
+
+export {
+  bestWallet
+};