@talken/talkenkit 2.3.4

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

@@ -0,0 +1,71 @@
+"use client";
+import {
+  isAndroid
+} from "./chunk-RETKWSKD.js";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/bifrostWallet/bifrostWallet.ts
+var bifrostWallet = ({
+  projectId,
+  walletConnectParameters
+}) => {
+  const isBifrostInjected = hasInjectedProvider({ flag: "isBifrost" });
+  const shouldUseWalletConnect = !isBifrostInjected;
+  const getUri = (uri) => {
+    return isAndroid() ? uri : `https://app.bifrostwallet.com/wc?uri=${encodeURIComponent(uri)}`;
+  };
+  return {
+    id: "bifrostWallet",
+    name: "Bifrost Wallet",
+    iconUrl: async () => (await import("./bifrostWallet-ORF3DABG.js")).default,
+    iconBackground: "#fff",
+    installed: !shouldUseWalletConnect ? isBifrostInjected : void 0,
+    downloadUrls: {
+      android: "https://play.google.com/store/apps/details?id=com.bifrostwallet.app",
+      ios: "https://apps.apple.com/us/app/bifrost-wallet/id1577198351",
+      qrCode: "https://bifrostwallet.com/#download-app"
+    },
+    mobile: {
+      getUri: shouldUseWalletConnect ? getUri : void 0
+    },
+    qrCode: shouldUseWalletConnect ? {
+      getUri: (uri) => uri,
+      instructions: {
+        learnMoreUrl: "https://support.bifrostwallet.com/en/articles/6886814-how-to-use-walletconnect",
+        steps: [
+          {
+            description: "wallet_connectors.bifrost.qr_code.step1.description",
+            step: "install",
+            title: "wallet_connectors.bifrost.qr_code.step1.title"
+          },
+          {
+            description: "wallet_connectors.bifrost.qr_code.step2.description",
+            step: "create",
+            title: "wallet_connectors.bifrost.qr_code.step2.title"
+          },
+          {
+            description: "wallet_connectors.bifrost.qr_code.step3.description",
+            step: "scan",
+            title: "wallet_connectors.bifrost.qr_code.step3.title"
+          }
+        ]
+      }
+    } : void 0,
+    createConnector: shouldUseWalletConnect ? getWalletConnectConnector({
+      projectId,
+      walletConnectParameters
+    }) : getInjectedConnector({
+      flag: "isBifrost"
+    })
+  };
+};
+
+export {
+  bifrostWallet
+};

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

@@ -0,0 +1,361 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcSolProvider.ts
+import {
+  PublicKey
+} from "@solana/web3.js";
+var DEBUG = true;
+var AbcSolProvider = class {
+  // Store wallet data internally
+  constructor(address, walletData) {
+    this.name = "ABC WaaS";
+    this.publicKey = null;
+    this.walletData = null;
+    if (address) {
+      this.publicKey = new PublicKey(address);
+    }
+    if (walletData) {
+      this.walletData = walletData;
+    } else if (address) {
+      this.loadWalletDataFromStorage();
+    }
+    this.setupGlobalPinCallback();
+  }
+  /**
+   * Load wallet data from localStorage
+   */
+  loadWalletDataFromStorage() {
+    try {
+      const authState = localStorage.getItem("talkenkit_abc_auth_state");
+      if (authState) {
+        const parsed = JSON.parse(authState);
+        if (parsed.solanaWallet) {
+          this.walletData = parsed.solanaWallet;
+          if (DEBUG) {
+            console.log(
+              "[AbcSolProvider] \u2705 Wallet data loaded from localStorage"
+            );
+          }
+        }
+      }
+    } catch (error) {
+      if (DEBUG) {
+        console.error("[AbcSolProvider] Failed to load wallet data:", error);
+      }
+    }
+  }
+  /**
+   * Get wallet data (from internal storage or localStorage)
+   */
+  getWalletData() {
+    if (this.walletData) {
+      return this.walletData;
+    }
+    const authState = localStorage.getItem("talkenkit_abc_auth_state");
+    if (authState) {
+      const parsed = JSON.parse(authState);
+      if (parsed.solanaWallet) {
+        this.walletData = parsed.solanaWallet;
+        return this.walletData;
+      }
+    }
+    throw new Error("No Solana wallet data available");
+  }
+  /**
+   * Auto-setup PIN callback from global provider (InternalPinProvider)
+   * This allows Solana to use the same PIN modal as EVM
+   */
+  setupGlobalPinCallback() {
+    const globalRequestPin = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalRequestPin && typeof globalRequestPin === "function") {
+      this.requestPinCallback = globalRequestPin;
+      if (DEBUG) {
+        console.log("[AbcSolProvider] \u2705 Global PIN callback configured");
+      }
+    } else if (DEBUG) {
+      console.warn("[AbcSolProvider] \u26A0\uFE0F Global PIN callback not found");
+    }
+  }
+  /**
+   * Set PIN request callback (manual override if needed)
+   */
+  setRequestPinCallback(callback) {
+    this.requestPinCallback = callback;
+  }
+  /**
+   * Request PIN from user
+   * First tries global callback, then falls back to manual callback
+   */
+  async requestPin() {
+    const globalRequestPin = window.__TALKENKIT_REQUEST_PIN__;
+    if (globalRequestPin && typeof globalRequestPin === "function") {
+      return globalRequestPin("transaction");
+    }
+    if (!this.requestPinCallback) {
+      throw new Error(
+        "PIN request callback not configured. Make sure RainbowKitProvider is rendered."
+      );
+    }
+    return this.requestPinCallback();
+  }
+  async signMessage(message, _encoding) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    const messageStr = new TextDecoder().decode(message);
+    const messageHex = Buffer.from(messageStr, "utf8").toString("hex");
+    const response = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ ...walletData, message: messageHex })
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`ABC WaaS sign failed: ${errorText}`);
+    }
+    const result = await response.json();
+    const signatureHex = result.signature || result.result?.signature;
+    if (!signatureHex) {
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    return { signature: signatureBytes };
+  }
+  async signTransaction(transaction, params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    let toAddress;
+    let amount;
+    if (params) {
+      toAddress = params.toAddress;
+      amount = params.amount * 1e9;
+    } else {
+      const transferInstruction = transaction.instructions[0];
+      toAddress = transferInstruction.keys[1]?.pubkey.toString();
+      amount = 1e5;
+    }
+    const requestBody = {
+      network: "solana_devnet",
+      fromAddress: walletData.address,
+      toAddress,
+      amount
+    };
+    const txResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      }
+    );
+    if (!txResponse.ok) {
+      const errorText = await txResponse.text();
+      console.error("[AbcSolProvider] \u274C API error:", errorText);
+      throw new Error(
+        `Transaction generation failed (${txResponse.status}): ${errorText}`
+      );
+    }
+    const txData = await txResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx;
+    if (!serializedTxHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No serialized_tx in response:",
+        txData
+      );
+      throw new Error("No serialized transaction in response");
+    }
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          ...walletData,
+          message: serializedTxHex
+        })
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign API error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature;
+    if (!signatureHex) {
+      console.error(
+        "[AbcSolProvider] \u274C No signature in response:",
+        signResult
+      );
+      throw new Error("No signature in ABC WaaS response");
+    }
+    const signatureBytes = new Uint8Array(
+      signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const mockTransaction = transaction;
+    mockTransaction.signatures = [
+      {
+        signature: Buffer.from(signatureBytes),
+        publicKey: this.publicKey
+      }
+    ];
+    const serializedTxBytes = new Uint8Array(
+      serializedTxHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+    );
+    const serializedTxBase64 = Buffer.from(serializedTxBytes).toString("base64");
+    mockTransaction._abcSerializedTx = serializedTxBase64;
+    return mockTransaction;
+  }
+  /**
+   * Send (broadcast) signed Solana transaction to network
+   * Reference: tg-wallet-frontend src/features/wallet/api/index.ts:181-189
+   * With PIN authentication (same pattern as EVM)
+   */
+  async sendTransaction(params) {
+    const walletData = this.getWalletData();
+    const accessToken = localStorage.getItem("talkenkit_abc_access_token");
+    if (!accessToken) {
+      throw new Error("No ABC WaaS access token");
+    }
+    if (DEBUG)
+      console.log(
+        "[AbcSolProvider] \u{1F510} Requesting PIN for Solana transaction..."
+      );
+    const pin = await this.requestPin();
+    if (DEBUG) {
+      console.log("[AbcSolProvider] \u{1F680} Sending Solana transaction:", {
+        from: walletData.address,
+        to: params.toAddress,
+        amount: params.amount,
+        network: "solana_devnet",
+        hasPin: !!pin
+      });
+    }
+    const generateResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/generateTransferSOLTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          network: "solana_devnet",
+          fromAddress: walletData.address,
+          toAddress: params.toAddress,
+          amount: params.amount * 1e9
+          // Convert SOL to lamports
+        })
+      }
+    );
+    if (!generateResponse.ok) {
+      const errorText = await generateResponse.text();
+      console.error("[AbcSolProvider] \u274C Generate TX error:", errorText);
+      throw new Error(`Transaction generation failed: ${errorText}`);
+    }
+    const txData = await generateResponse.json();
+    const serializedTxHex = txData.result?.data?.serialized_tx || txData.data?.serialized_tx;
+    if (!serializedTxHex) {
+      throw new Error("No serialized transaction in response");
+    }
+    const signResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/v3/wallet/sign`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          ...walletData,
+          message: serializedTxHex
+        })
+      }
+    );
+    if (!signResponse.ok) {
+      const errorText = await signResponse.text();
+      console.error("[AbcSolProvider] \u274C Sign error:", errorText);
+      throw new Error(`Sign failed: ${errorText}`);
+    }
+    const signResult = await signResponse.json();
+    const signatureHex = signResult.signature || signResult.result?.signature;
+    if (DEBUG) {
+      console.log("[AbcSolProvider] \u{1F50D} Sign result:", {
+        hasSignature: !!signatureHex,
+        hasSerialized: !!serializedTxHex
+      });
+    }
+    if (!signatureHex) {
+      throw new Error("No signature in ABC WaaS response");
+    }
+    if (DEBUG)
+      console.log(
+        "[AbcSolProvider] \u{1F4E1} Broadcasting with ABC WaaS sendTransaction API..."
+      );
+    const sendResponse = await fetch(
+      `${process.env.NEXT_PUBLIC_ABC_WAAS_URL}/wapi/v2/solana/tx/sendTransaction`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          network: "solana_devnet",
+          serializedTX: serializedTxHex,
+          signatures: [signatureHex]
+        })
+      }
+    );
+    if (!sendResponse.ok) {
+      const errorText = await sendResponse.text();
+      console.error("[AbcSolProvider] \u274C Broadcast error:", {
+        status: sendResponse.status,
+        statusText: sendResponse.statusText,
+        error: errorText
+      });
+      try {
+        const errorData = JSON.parse(errorText);
+        if (errorData.message?.includes("insufficient") || errorData.message?.includes("InsufficientFunds")) {
+          throw new Error("Insufficient SOL balance to send transaction");
+        }
+      } catch (_parseError) {
+      }
+      throw new Error(
+        `Transaction broadcast failed (${sendResponse.status}): ${errorText}`
+      );
+    }
+    const sendResult = await sendResponse.json();
+    const txHash = sendResult.result?.data || sendResult.data || sendResult.txHash;
+    if (DEBUG) {
+      console.log("[AbcSolProvider] \u2705 Transaction sent:", txHash);
+    }
+    return {
+      signature: signatureHex,
+      txHash: txHash || signatureHex
+    };
+  }
+};
+
+export {
+  AbcSolProvider
+};

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

@@ -0,0 +1,60 @@
+"use client";
+import {
+  isAndroid
+} from "./chunk-RETKWSKD.js";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+
+// src/wallets/walletConnectors/argentWallet/argentWallet.ts
+var argentWallet = ({
+  projectId,
+  walletConnectParameters
+}) => ({
+  id: "argent",
+  name: "Argent",
+  iconUrl: async () => (await import("./argentWallet-M6SBG4CU.js")).default,
+  iconBackground: "#fff",
+  downloadUrls: {
+    android: "https://play.google.com/store/apps/details?id=im.argent.contractwalletclient",
+    ios: "https://apps.apple.com/us/app/argent/id1358741926",
+    mobile: "https://argent.xyz/download-argent",
+    qrCode: "https://argent.link/app"
+  },
+  mobile: {
+    getUri: (uri) => {
+      return isAndroid() ? uri : `argent://app/wc?uri=${encodeURIComponent(uri)}`;
+    }
+  },
+  qrCode: {
+    getUri: (uri) => uri,
+    instructions: {
+      learnMoreUrl: "https://argent.xyz/learn/what-is-a-crypto-wallet/",
+      steps: [
+        {
+          description: "wallet_connectors.argent.qr_code.step1.description",
+          step: "install",
+          title: "wallet_connectors.argent.qr_code.step1.title"
+        },
+        {
+          description: "wallet_connectors.argent.qr_code.step2.description",
+          step: "create",
+          title: "wallet_connectors.argent.qr_code.step2.title"
+        },
+        {
+          description: "wallet_connectors.argent.qr_code.step3.description",
+          step: "scan",
+          title: "wallet_connectors.argent.qr_code.step3.title"
+        }
+      ]
+    }
+  },
+  createConnector: getWalletConnectConnector({
+    projectId,
+    walletConnectParameters
+  })
+});
+
+export {
+  argentWallet
+};

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

@@ -0,0 +1,30 @@
+"use client";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/seifWallet/seifWallet.ts
+function seifWallet() {
+  const injectedProvider = hasInjectedProvider({
+    namespace: "__seif"
+  });
+  return {
+    id: "seif",
+    name: "Seif",
+    installed: !!injectedProvider,
+    iconUrl: async () => (await import("./seifWallet-QATOS33A.js")).default,
+    iconBackground: "#fff",
+    downloadUrls: {
+      chrome: "https://chromewebstore.google.com/detail/seif/albakdmmdafeafbehmcpoejenbeojejl"
+    },
+    createConnector: getInjectedConnector({
+      namespace: "__seif"
+    }),
+    rdns: "com.passkeywallet.seif"
+  };
+}
+
+export {
+  seifWallet
+};

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

@@ -0,0 +1,27 @@
+"use client";
+import {
+  isIOS
+} from "./chunk-RETKWSKD.js";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/dawnWallet/dawnWallet.ts
+var dawnWallet = () => ({
+  id: "dawn",
+  name: "Dawn",
+  iconUrl: async () => (await import("./dawnWallet-ONVAA3S4.js")).default,
+  iconBackground: "#000000",
+  installed: hasInjectedProvider({ flag: "isDawn" }),
+  hidden: () => !isIOS(),
+  downloadUrls: {
+    ios: "https://apps.apple.com/us/app/dawn-ethereum-wallet/id1673143782",
+    mobile: "https://dawnwallet.xyz"
+  },
+  createConnector: getInjectedConnector({ flag: "isDawn" })
+});
+
+export {
+  dawnWallet
+};

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

@@ -0,0 +1,32 @@
+"use client";
+
+// src/wallets/walletConnectors/safeWallet/safeWallet.ts
+import { createConnector } from "wagmi";
+import { safe } from "wagmi/connectors";
+var safeWallet = () => ({
+  id: "safe",
+  name: "Safe",
+  iconAccent: "#12ff80",
+  iconBackground: "#fff",
+  iconUrl: async () => (await import("./safeWallet-VUYZPLY4.js")).default,
+  installed: (
+    // Only allowed in iframe context
+    // borrowed from wagmi safe connector
+    !(typeof window === "undefined") && window?.parent !== window
+  ),
+  downloadUrls: {
+    // We're opting not to provide a download prompt if the application is not
+    // already running as a Safe App within the context of the Safe browser,
+    // since it's unlikely to be a desired behavior for users.
+  },
+  createConnector: (walletDetails) => {
+    return createConnector((config) => ({
+      ...safe()(config),
+      ...walletDetails
+    }));
+  }
+});
+
+export {
+  safeWallet
+};

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

@@ -0,0 +1,96 @@
+"use client";
+import {
+  getWalletConnectConnector
+} from "./chunk-PODFK4OS.js";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/coin98Wallet/coin98Wallet.ts
+var coin98Wallet = ({
+  projectId,
+  walletConnectParameters
+}) => {
+  const isCoin98WalletInjected = hasInjectedProvider({
+    namespace: "coin98.provider",
+    flag: "isCoin98"
+  });
+  const shouldUseWalletConnect = !isCoin98WalletInjected;
+  return {
+    id: "coin98",
+    name: "Coin98 Wallet",
+    iconUrl: async () => (await import("./coin98Wallet-RFXRNVWP.js")).default,
+    installed: isCoin98WalletInjected,
+    iconAccent: "#CDA349",
+    iconBackground: "#fff",
+    rdns: "coin98.com",
+    downloadUrls: {
+      android: "https://play.google.com/store/apps/details?id=coin98.crypto.finance.media",
+      ios: "https://apps.apple.com/vn/app/coin98-super-app/id1561969966",
+      mobile: "https://coin98.com/wallet",
+      qrCode: "https://coin98.com/wallet",
+      chrome: "https://chrome.google.com/webstore/detail/coin98-wallet/aeachknmefphepccionboohckonoeemg",
+      browserExtension: "https://coin98.com/wallet"
+    },
+    mobile: {
+      getUri: shouldUseWalletConnect ? (uri) => uri : void 0
+    },
+    qrCode: shouldUseWalletConnect ? {
+      getUri: (uri) => uri,
+      instructions: {
+        learnMoreUrl: "https://coin98.com/wallet",
+        steps: [
+          {
+            description: "wallet_connectors.coin98.qr_code.step1.description",
+            step: "install",
+            title: "wallet_connectors.coin98.qr_code.step1.title"
+          },
+          {
+            description: "wallet_connectors.coin98.qr_code.step2.description",
+            step: "create",
+            title: "wallet_connectors.coin98.qr_code.step2.title"
+          },
+          {
+            description: "wallet_connectors.coin98.qr_code.step3.description",
+            step: "scan",
+            title: "wallet_connectors.coin98.qr_code.step3.title"
+          }
+        ]
+      }
+    } : void 0,
+    extension: {
+      instructions: {
+        learnMoreUrl: "https://coin98.com/wallet",
+        steps: [
+          {
+            description: "wallet_connectors.coin98.extension.step1.description",
+            step: "install",
+            title: "wallet_connectors.coin98.extension.step1.title"
+          },
+          {
+            description: "wallet_connectors.coin98.extension.step2.description",
+            step: "create",
+            title: "wallet_connectors.coin98.extension.step2.title"
+          },
+          {
+            description: "wallet_connectors.coin98.extension.step3.description",
+            step: "refresh",
+            title: "wallet_connectors.coin98.extension.step3.title"
+          }
+        ]
+      }
+    },
+    createConnector: shouldUseWalletConnect ? getWalletConnectConnector({
+      projectId,
+      walletConnectParameters
+    }) : getInjectedConnector({
+      namespace: "coin98Wallet",
+      flag: "isCoin98"
+    })
+  };
+};
+
+export {
+  coin98Wallet
+};