@talken/talkenkit 2.4.21 → 2.4.23

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

@@ -0,0 +1,421 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcSolanaProvider.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+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 AbcSolanaProvider = class extends EventEmitter {
+  constructor(client) {
+    super();
+    this.wallet = null;
+    this.connected = false;
+    this.client = client;
+  }
+  /**
+   * Set request interceptor for sign/transfer confirmation modals
+   */
+  setRequestInterceptor(interceptor) {
+    this.requestInterceptor = interceptor;
+  }
+  /**
+   * Call request interceptor if set (throws on user cancel)
+   */
+  async callInterceptor(request) {
+    if (this.requestInterceptor) {
+      await this.requestInterceptor(request);
+    }
+  }
+  /**
+   * 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,
+      network: wallet.network
+    });
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.emit("disconnect");
+    this.emit("accountsChanged", []);
+  }
+  /**
+   * Set TalkenApiClient for backend-proxied transaction flow
+   * When set, native SOL transfers will use a single API call instead of multi-step WaaS
+   */
+  setTalkenApi(talkenApi) {
+    this.talkenApi = talkenApi;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.wallet !== null;
+  }
+  /**
+   * Get Solana address
+   */
+  async getAddress() {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.address;
+  }
+  /**
+   * Get public key
+   */
+  async getPublicKey() {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.publicKey;
+  }
+  /**
+   * Sign Solana message (no PIN required)
+   * Uses encrypted_share which doesn't require PIN
+   */
+  async signMessage(encodedMessage, _display) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const decodedText = new TextDecoder().decode(encodedMessage);
+      await this.callInterceptor({
+        chain: "solana",
+        method: "signMessage",
+        address: this.wallet.address,
+        network: this.wallet.network,
+        message: decodedText
+      });
+      const messageHex = `0x${Array.from(encodedMessage).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+      const result = await this.client.solana.signSolanaMessage({
+        message: messageHex,
+        encryptedShare: this.wallet.encryptedShare,
+        keyId: this.wallet.keyId,
+        secretStore: this.wallet.secretStore || ""
+      });
+      const signatureHex = result.signature.startsWith("0x") ? result.signature.slice(2) : result.signature;
+      const signatureBytes = new Uint8Array(
+        signatureHex.match(/.{1,2}/g)?.map((byte) => Number.parseInt(byte, 16)) || []
+      );
+      return { signature: signatureBytes };
+    } catch (error) {
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to sign message",
+        error
+      );
+    }
+  }
+  /**
+   * Sign arbitrary Solana transaction (requires PIN)
+   * Supports both Legacy Transaction and VersionedTransaction
+   * Used for custom transactions, dApp interactions, and protocol integrations
+   */
+  async signTransaction(transaction) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      let txMessage = "";
+      try {
+        txMessage = JSON.stringify(transaction, null, 2);
+      } catch {
+        txMessage = String(transaction);
+      }
+      await this.callInterceptor({
+        chain: "solana",
+        method: "signTransaction",
+        address: this.wallet.address,
+        network: this.wallet.network,
+        message: txMessage,
+        isTransaction: true
+      });
+      const { VersionedTransaction, PublicKey } = await import("@solana/web3.js");
+      const isVersioned = transaction instanceof VersionedTransaction;
+      let serialized;
+      if (isVersioned) {
+        serialized = transaction.message.serialize();
+      } else {
+        serialized = transaction.serializeMessage();
+      }
+      const messageHex = Buffer.from(serialized).toString("hex");
+      const signatureResponse = await this.client.solana.signSolanaTransaction({
+        keyId: this.wallet.keyId,
+        encryptedShare: this.wallet.encryptedShare,
+        secretStore: this.wallet.secretStore || "",
+        message: messageHex
+      });
+      const signatureHex = signatureResponse.signature.startsWith("0x") ? signatureResponse.signature.slice(2) : signatureResponse.signature;
+      const signatureBytes = Buffer.from(signatureHex, "hex");
+      const publicKey = new PublicKey(this.wallet.address);
+      if (isVersioned) {
+        transaction.addSignature(publicKey, signatureBytes);
+      } else {
+        transaction.addSignature(publicKey, signatureBytes);
+      }
+      return transaction;
+    } catch (error) {
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to sign transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Sign multiple transactions (batch signing)
+   */
+  async signAllTransactions(transactions) {
+    const signedTransactions = [];
+    for (const transaction of transactions) {
+      const signed = await this.signTransaction(transaction);
+      signedTransactions.push(signed);
+    }
+    return signedTransactions;
+  }
+  /**
+   * Unified transfer: SOL, SPL token, or NFT
+   * - No mintAddress → native SOL transfer (kind='native')
+   * - With mintAddress → SPL/NFT transfer (kind='spl')
+   * - NFT = transfer({ mintAddress, toAddress, amount: 1 })
+   */
+  async transfer(params) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const symbol = params.mintAddress ? "SPL" : "SOL";
+      await this.callInterceptor({
+        chain: "solana",
+        method: "transfer",
+        fromAddress: this.wallet.address,
+        toAddress: params.toAddress,
+        amount: String(params.amount),
+        symbol,
+        network: this.wallet.network,
+        tokenAddress: params.mintAddress,
+        isNativeToken: !params.mintAddress,
+        feeSymbol: "SOL"
+      });
+      const pinHash = localStorage.getItem("talkenkit_abc_pin_hash");
+      if (!pinHash) {
+        throw new SolanaProviderError(
+          SolanaErrorCode.INTERNAL_ERROR,
+          "PIN hash not found. Please login again."
+        );
+      }
+      console.log("[AbcSolanaProvider] transfer START", {
+        kind: params.mintAddress ? "spl" : "native",
+        toAddress: params.toAddress,
+        amount: params.amount,
+        mintAddress: params.mintAddress || null,
+        network: this.wallet.network,
+        hasPinHash: !!pinHash
+      });
+      const api = this.talkenApi || getTalkenApiClient();
+      if (params.mintAddress) {
+        const apiNetwork = this.wallet.network === "solana" ? "solana_mainnet" : this.wallet.network;
+        const { PublicKey, Connection } = await import("@solana/web3.js");
+        const connection = new Connection(this.getRpcUrl(), "confirmed");
+        const mintPubkey = new PublicKey(params.mintAddress);
+        const mintInfo = await connection.getParsedAccountInfo(mintPubkey);
+        const decimals = mintInfo.value?.data?.parsed?.info?.decimals || 9;
+        const rawAmount = Math.floor(params.amount * 10 ** decimals);
+        const result2 = await api.solana.transfer({
+          kind: "spl",
+          toAddress: params.toAddress,
+          mintAddress: params.mintAddress,
+          amount: String(rawAmount),
+          decimals,
+          network: apiNetwork,
+          pin: pinHash
+        });
+        console.log("[AbcSolanaProvider] SPL transfer result:", result2);
+        return { signature: result2.txHash };
+      }
+      const { LAMPORTS_PER_SOL } = await import("@solana/web3.js");
+      const amountLamports = params.amount * LAMPORTS_PER_SOL;
+      console.log("[AbcSolanaProvider] native transfer request:", {
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        amountSOL: params.amount
+      });
+      const result = await api.solana.transfer({
+        kind: "native",
+        toAddress: params.toAddress,
+        amountLamports: String(amountLamports),
+        pin: pinHash
+      });
+      console.log("[AbcSolanaProvider] native transfer result:", result);
+      return { signature: result.txHash };
+    } catch (error) {
+      console.error("[AbcSolanaProvider] transfer FAILED:", {
+        message: error.message,
+        code: error.code,
+        status: error.status,
+        details: error.details || error.data
+      });
+      if (error.code === 4001 || error.cancelled) {
+        throw error;
+      }
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to transfer",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      network: this.wallet.network
+    };
+  }
+  /**
+   * Get SPL token balance
+   *
+   * @param mintAddress - Token mint address
+   * @returns Token balance information
+   */
+  async getTokenBalance(mintAddress) {
+    if (!this.wallet) {
+      throw new SolanaProviderError(
+        SolanaErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      const { PublicKey, Connection } = await import("@solana/web3.js");
+      const { getAssociatedTokenAddress, TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
+      const connection = new Connection(this.getRpcUrl(), "confirmed");
+      const mintPubkey = new PublicKey(mintAddress);
+      const ownerPubkey = new PublicKey(this.wallet.address);
+      const tokenAccount = await getAssociatedTokenAddress(
+        mintPubkey,
+        ownerPubkey,
+        false,
+        TOKEN_PROGRAM_ID
+      );
+      const balance = await connection.getTokenAccountBalance(tokenAccount);
+      return {
+        amount: balance.value.amount,
+        decimals: balance.value.decimals,
+        uiAmount: balance.value.uiAmount || 0
+      };
+    } catch (error) {
+      this.emit("error", error);
+      throw new SolanaProviderError(
+        SolanaErrorCode.INTERNAL_ERROR,
+        "Failed to get token balance",
+        error
+      );
+    }
+  }
+  /**
+   * Get RPC URL based on network
+   */
+  getRpcUrl() {
+    const isMainnet = this.wallet?.network === "solana";
+    return isMainnet ? process.env.NEXT_PUBLIC_SOLANA_RPC_MAINNET || "https://api.mainnet-beta.solana.com" : process.env.NEXT_PUBLIC_SOLANA_RPC_DEVNET || "https://api.devnet.solana.com";
+  }
+};
+
+export {
+  SolanaProviderError,
+  AbcSolanaProvider
+};

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

@@ -0,0 +1,204 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-MBRXYEQC.js";
+import {
+  createAbcError
+} from "./chunk-LOSXI36Y.js";
+
+// src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
+import { getTalkenApiClient } from "@talken/talkenkit";
+var AuthApi = class extends BaseApiClient {
+  /**
+   * Login with email and password
+   */
+  async loginWithEmail(email, password) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithPassword(email, password);
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Login with email and OTP
+   * NOTE: OTP login removed from server — use password login instead.
+   * This method kept for backward compatibility, delegates to loginWithEmail.
+   */
+  async loginWithOtp(email, otpCode) {
+    return this.loginWithEmail(email, otpCode);
+  }
+  /**
+   * Login with social provider (Google, Apple, Kakao)
+   * Routes through TalkenApiClient → POST /wallet/auth { action: 'login', method: 'sns' }
+   */
+  async loginWithSocial(provider, token, _email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.loginWithSns({
+        token,
+        service: provider
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return {
+        uid: res.uid,
+        email: res.email,
+        accessToken: res.accessToken,
+        refreshToken: res.refreshToken,
+        expiresIn: res.expiresIn
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(email);
+      return { sent: true, expiresIn: 300 };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return true;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Check if email already exists
+   */
+  async emailCheck(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.checkEmail(_email);
+      return {
+        status: "success",
+        message: { code: res.code || 0, text: res.message || "" }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Send OTP code to email for signup
+   */
+  async sendOtpCode(_email) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.sendOtp(_email);
+      return { status: "success", data: { sent: true } };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Verify OTP code for signup
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const api = getTalkenApiClient();
+    if (api) {
+      await api.auth.verifyOtp(email, code);
+      return {
+        status: "success",
+        data: { verified: true }
+      };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new user with password
+   */
+  async registerUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: params.password,
+        otpCode: params.emailCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP, no password)
+   */
+  async registerSnsUser(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.register({
+        email: params.username,
+        password: "",
+        otpCode: params.sixCode,
+        name: params.name
+      });
+      this.saveTokens(res.accessToken, res.refreshToken, res.expiresIn);
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+  /**
+   * Reset/Set password for existing user
+   */
+  async resetPassword(params) {
+    const api = getTalkenApiClient();
+    if (api) {
+      const res = await api.auth.resetPassword(
+        params.username,
+        params.password,
+        params.emailCode
+      );
+      return { status: "success", data: res };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "TalkenApiClient not initialized"
+    );
+  }
+};
+
+export {
+  AuthApi
+};