@talken/talkenkit 2.4.15 → 2.4.17

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

@@ -0,0 +1,181 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/networkConfig.ts
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["EVM"] = "evm";
+  ChainType2["Solana"] = "solana";
+  ChainType2["Bitcoin"] = "bitcoin";
+  ChainType2["Tron"] = "tron";
+  return ChainType2;
+})(ChainType || {});
+var SolanaNetwork = /* @__PURE__ */ ((SolanaNetwork2) => {
+  SolanaNetwork2["Mainnet"] = "solana";
+  SolanaNetwork2["Devnet"] = "solana_devnet";
+  SolanaNetwork2["Testnet"] = "solana_testnet";
+  return SolanaNetwork2;
+})(SolanaNetwork || {});
+var BitcoinNetwork = /* @__PURE__ */ ((BitcoinNetwork2) => {
+  BitcoinNetwork2["Mainnet"] = "bitcoin";
+  BitcoinNetwork2["Testnet"] = "bitcoin_testnet";
+  return BitcoinNetwork2;
+})(BitcoinNetwork || {});
+var TronNetwork = /* @__PURE__ */ ((TronNetwork2) => {
+  TronNetwork2["Mainnet"] = "tron";
+  TronNetwork2["Nile"] = "tron_nile";
+  return TronNetwork2;
+})(TronNetwork || {});
+var DEFAULT_NETWORK_CONFIG = {
+  evm: {
+    mainnet: 1,
+    // Ethereum Mainnet
+    testnet: 11155111
+    // Sepolia Testnet
+  },
+  solana: {
+    mainnet: "solana" /* Mainnet */,
+    devnet: "solana_devnet" /* Devnet */
+  },
+  bitcoin: {
+    mainnet: "bitcoin" /* Mainnet */,
+    testnet: "bitcoin_testnet" /* Testnet */
+  },
+  tron: {
+    mainnet: "tron" /* Mainnet */,
+    testnet: "tron_nile" /* Nile */
+  }
+};
+var globalDefaultChainId;
+var globalDefaultSolanaNetwork;
+var globalDefaultBitcoinNetwork;
+var globalDefaultTronNetwork;
+function setGlobalDefaultChainId(chainId) {
+  globalDefaultChainId = chainId;
+}
+function setGlobalDefaultSolanaNetwork(network) {
+  globalDefaultSolanaNetwork = network;
+}
+function setGlobalDefaultBitcoinNetwork(network) {
+  globalDefaultBitcoinNetwork = network;
+}
+function setGlobalDefaultTronNetwork(network) {
+  globalDefaultTronNetwork = network;
+}
+function getEvmNetwork(customChainId) {
+  if (customChainId !== void 0) {
+    return customChainId;
+  }
+  if (globalDefaultChainId !== void 0) {
+    return globalDefaultChainId;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  const fallbackChainId = isProduction ? DEFAULT_NETWORK_CONFIG.evm.mainnet : DEFAULT_NETWORK_CONFIG.evm.testnet;
+  return fallbackChainId;
+}
+function getSolanaNetwork() {
+  if (globalDefaultSolanaNetwork !== void 0) {
+    return globalDefaultSolanaNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.solana.mainnet : DEFAULT_NETWORK_CONFIG.solana.devnet;
+}
+function getBitcoinNetwork() {
+  if (globalDefaultBitcoinNetwork !== void 0) {
+    return globalDefaultBitcoinNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.bitcoin.mainnet : DEFAULT_NETWORK_CONFIG.bitcoin.testnet;
+}
+function getTronNetwork() {
+  if (globalDefaultTronNetwork !== void 0) {
+    return globalDefaultTronNetwork;
+  }
+  const isProduction = typeof process !== "undefined" && process.env.NEXT_PUBLIC_ENVIRONMENT === "production";
+  return isProduction ? DEFAULT_NETWORK_CONFIG.tron.mainnet : DEFAULT_NETWORK_CONFIG.tron.testnet;
+}
+function getNetworkForChain(chainType) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      return getSolanaNetwork();
+    case "bitcoin" /* Bitcoin */:
+      return getBitcoinNetwork();
+    case "tron" /* Tron */:
+      return getTronNetwork();
+    case "evm" /* EVM */:
+      return getEvmNetwork();
+  }
+}
+function isMainnet(chainType, network) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      return network === DEFAULT_NETWORK_CONFIG.solana.mainnet;
+    case "bitcoin" /* Bitcoin */:
+      return network === DEFAULT_NETWORK_CONFIG.bitcoin.mainnet;
+    case "tron" /* Tron */:
+      return network === DEFAULT_NETWORK_CONFIG.tron.mainnet;
+    case "evm" /* EVM */:
+      return network !== DEFAULT_NETWORK_CONFIG.evm.testnet;
+  }
+}
+function getNetworkDisplayName(chainType, network) {
+  switch (chainType) {
+    case "solana" /* Solana */:
+      if (network === "solana" /* Mainnet */)
+        return "Solana Mainnet";
+      if (network === "solana_devnet" /* Devnet */)
+        return "Solana Devnet";
+      if (network === "solana_testnet" /* Testnet */)
+        return "Solana Testnet";
+      return `Solana ${network}`;
+    case "bitcoin" /* Bitcoin */:
+      return network === "bitcoin" /* Mainnet */ ? "Bitcoin Mainnet" : "Bitcoin Testnet";
+    case "tron" /* Tron */:
+      return network === "tron" /* Mainnet */ ? "TRON Mainnet" : "TRON Nile Testnet";
+    case "evm" /* EVM */: {
+      const evmNetwork = network;
+      if (evmNetwork === 1)
+        return "Ethereum Mainnet";
+      if (evmNetwork === 11155111)
+        return "Ethereum Sepolia";
+      if (evmNetwork === 137)
+        return "Polygon Mainnet";
+      if (evmNetwork === 80001)
+        return "Polygon Mumbai";
+      return `EVM Chain ${evmNetwork}`;
+    }
+  }
+}
+function isSolanaNetwork(value) {
+  return value === "solana" /* Mainnet */ || value === "solana_devnet" /* Devnet */ || value === "solana_testnet" /* Testnet */;
+}
+function isBitcoinNetwork(value) {
+  return value === "bitcoin" /* Mainnet */ || value === "bitcoin_testnet" /* Testnet */;
+}
+function isTronNetwork(value) {
+  return value === "tron" /* Mainnet */ || value === "tron_nile" /* Nile */;
+}
+function isEvmNetwork(value) {
+  return typeof value === "number" && value > 0;
+}
+
+export {
+  ChainType,
+  SolanaNetwork,
+  BitcoinNetwork,
+  TronNetwork,
+  DEFAULT_NETWORK_CONFIG,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork,
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultTronNetwork,
+  getEvmNetwork,
+  getSolanaNetwork,
+  getBitcoinNetwork,
+  getTronNetwork,
+  getNetworkForChain,
+  isMainnet,
+  getNetworkDisplayName,
+  isSolanaNetwork,
+  isBitcoinNetwork,
+  isTronNetwork,
+  isEvmNetwork
+};

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

@@ -0,0 +1,221 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/constants.ts
+var DEFAULT_ABC_CONFIG = {
+  environment: "development",
+  waasUrl: process.env.VITE_ABC_WAAS_URL || "https://api.abcwallet.com"
+};
+var TOKEN_EXPIRY = {
+  ACCESS_TOKEN: 10 * 60 * 1e3,
+  // 10 minutes
+  REFRESH_TOKEN: 60 * 60 * 1e3,
+  // 60 minutes
+  REFRESH_BUFFER: 60 * 1e3
+  // Refresh 60s before expiry (increased for network latency tolerance)
+};
+var ABC_ENDPOINTS = {
+  // Authentication
+  SNS_LOGIN: "/abc/snsLogin",
+  // Legacy - may need to update
+  REGISTER_SNS_USER: "/abc/registerSnsUser",
+  // Legacy - may need to update
+  // Secure channel
+  SECURE_CHANNEL_CREATE: "/secure/channel/create",
+  // Email OTP
+  SEND_OTP: "/member/mail-service/{email}/sendcode",
+  // {email} placeholder
+  VERIFY_OTP: "/member/mail-service/{email}/verifycode",
+  // {email} placeholder
+  // Wallet operations (EVM)
+  // Based on tg-wallet-frontend reference
+  MPC_WALLETS: "/wapi/v2/mpc/wallets",
+  // EVM wallet generation/recovery
+  MPC_WALLETS_INFO: "/wapi/v2/mpc/wallets/info",
+  // Get wallet info
+  // Signing operations
+  // Based on tg-wallet-frontend reference implementation
+  SIGN_HASH: "/wapi/v2/sign/hash",
+  // Personal sign with hash (EIP-191)
+  SIGN_TYPED: "/wapi/v2/sign/typed-data",
+  // Typed data sign (EIP-712)
+  SIGN_TRANSACTION: "/wapi/v2/sign",
+  // EVM transaction sign (LEGACY, EIP1559, PERSONAL)
+  // Transaction operations
+  SEND_RAW_TX: "/wapi/v2/transactions/raw-tx/send",
+  // Send signed transaction
+  TRANSACTION_COUNT: "/wapi/v2/transactions/count",
+  // Get transaction count (nonce)
+  // Gas estimation and fee data
+  GAS_SUGGESTED_FEES: "/wapi/v2/gas/suggestedGasFees",
+  // Get suggested gas fees for EIP-1559
+  GAS_ESTIMATE_EIP1559: "/wapi/v2/gas/estimate/eip1559",
+  // Estimate gas limit for EIP-1559
+  // Token info (Walletscan)
+  WALLETSCAN_TOKEN: "/wapi/v2/walletscan/token",
+  // GET /{contractAddress}?networks=xxx
+  WALLETSCAN_NATIVES: "/wapi/v2/walletscan/natives",
+  // GET ?walletAddress=xxx&networks=xxx
+  WALLETSCAN_NFTS: "/wapi/v2/walletscan/nfts",
+  // GET /{contractAddress}?walletAddress=xxx&networks=xxx
+  // Token refresh (based on tg-wallet-frontend reference)
+  REFRESH_TOKEN: "/abc/abcRefresh",
+  // Token refresh endpoint
+  // Legacy endpoints (kept for compatibility)
+  WALLETS_V3: "/abc/wallets/v3",
+  // Solana only
+  INFO: "/abc/info"
+};
+var AUTH_PROVIDERS = {
+  EMAIL: "email",
+  GOOGLE: "google",
+  APPLE: "apple",
+  TELEGRAM: "telegram",
+  TWITTER: "twitter"
+};
+var CHAIN_TYPES = {
+  EVM: "evm",
+  SOLANA: "solana",
+  BITCOIN: "bitcoin"
+};
+var SOLANA_CHAIN_ID = 900;
+var BITCOIN_CHAIN_ID = 800;
+var EVM_CHAINS = {
+  ETHEREUM_MAINNET: 1,
+  ETHEREUM_GOERLI: 5,
+  ETHEREUM_SEPOLIA: 11155111,
+  POLYGON_MAINNET: 137,
+  POLYGON_MUMBAI: 80001,
+  BSC_MAINNET: 56,
+  BSC_TESTNET: 97,
+  ARBITRUM_MAINNET: 42161,
+  ARBITRUM_GOERLI: 421613,
+  OPTIMISM_MAINNET: 10,
+  OPTIMISM_GOERLI: 420,
+  AVALANCHE_MAINNET: 43114,
+  AVALANCHE_FUJI: 43113,
+  KLAYTN_MAINNET: 8217,
+  KLAYTN_BAOBAB: 1001
+};
+var ABC_AUDIENCE = "https://mw.myabcwallet.com";
+var PIN_CONFIG = {
+  MIN_LENGTH: 6,
+  MAX_LENGTH: 6,
+  MAX_ATTEMPTS: 5,
+  LOCKOUT_DURATION: 15 * 60 * 1e3
+  // 15 minutes
+};
+var STORAGE_VERSION = "1.0.0";
+var REQUEST_TIMEOUT = 3e4;
+var RETRY_CONFIG = {
+  MAX_RETRIES: 3,
+  RETRY_DELAY: 1e3,
+  // 1 second
+  BACKOFF_MULTIPLIER: 2
+};
+var ABC_WALLET_METADATA = {
+  id: "abc",
+  name: "ABC Wallet",
+  iconBackground: "#ffffff",
+  rdns: "com.abcwallet"
+};
+var MODAL_CONFIG = {
+  WIDTH: 400,
+  MAX_WIDTH: "90vw",
+  BORDER_RADIUS: 16,
+  PADDING: 24
+};
+var SOCIAL_BUTTONS = [
+  {
+    provider: AUTH_PROVIDERS.GOOGLE,
+    label: "Google",
+    iconName: "google"
+  },
+  {
+    provider: AUTH_PROVIDERS.APPLE,
+    label: "Apple",
+    iconName: "apple"
+  },
+  {
+    provider: AUTH_PROVIDERS.TELEGRAM,
+    label: "Telegram",
+    iconName: "telegram"
+  },
+  {
+    provider: AUTH_PROVIDERS.TWITTER,
+    label: "X (Twitter)",
+    iconName: "twitter"
+  }
+];
+var ERROR_MESSAGES = {
+  INVALID_CREDENTIALS: "Invalid email or password",
+  TOKEN_EXPIRED: "Your session has expired. Please login again.",
+  WALLET_NOT_FOUND: "Wallet not found. Please create a new wallet.",
+  INVALID_PIN: "Invalid PIN code",
+  NETWORK_ERROR: "Network error. Please check your connection.",
+  SIGNATURE_FAILED: "Failed to sign transaction",
+  USER_CANCELLED: "User cancelled the operation",
+  UNKNOWN_ERROR: "An unknown error occurred",
+  INVALID_OTP: "Invalid or expired OTP code",
+  EMAIL_REQUIRED: "Email address is required",
+  PIN_REQUIRED: "PIN code is required",
+  WALLET_GENERATION_FAILED: "Failed to generate wallet"
+};
+var SUCCESS_MESSAGES = {
+  LOGIN_SUCCESS: "Successfully logged in",
+  WALLET_CREATED: "Wallet created successfully",
+  TRANSACTION_SENT: "Transaction sent successfully",
+  OTP_SENT: "OTP code sent to your email"
+};
+var ABC_EVENTS = {
+  CONNECT: "abc:connect",
+  DISCONNECT: "abc:disconnect",
+  ACCOUNTS_CHANGED: "abc:accountsChanged",
+  CHAIN_CHANGED: "abc:chainChanged",
+  ERROR: "abc:error",
+  AUTH_STATE_CHANGED: "abc:authStateChanged"
+};
+var STORAGE_PREFIX = "talkenkit_abc_";
+var DEBUG_MODE = true;
+var DEFAULT_HEADERS = {
+  "Content-Type": "application/x-www-form-urlencoded",
+  Accept: "application/json"
+};
+var ABC_FEATURES = {
+  EMAIL_LOGIN: true,
+  SOCIAL_LOGIN: true,
+  MULTI_CHAIN: true,
+  EVM_SUPPORT: true,
+  SOLANA_SUPPORT: true,
+  BITCOIN_SUPPORT: false,
+  // Future feature
+  GASLESS_TRANSACTIONS: false,
+  // Future feature
+  SOCIAL_RECOVERY: false
+  // Future feature
+};
+
+export {
+  DEFAULT_ABC_CONFIG,
+  TOKEN_EXPIRY,
+  ABC_ENDPOINTS,
+  AUTH_PROVIDERS,
+  CHAIN_TYPES,
+  SOLANA_CHAIN_ID,
+  BITCOIN_CHAIN_ID,
+  EVM_CHAINS,
+  ABC_AUDIENCE,
+  PIN_CONFIG,
+  STORAGE_VERSION,
+  REQUEST_TIMEOUT,
+  RETRY_CONFIG,
+  ABC_WALLET_METADATA,
+  MODAL_CONFIG,
+  SOCIAL_BUTTONS,
+  ERROR_MESSAGES,
+  SUCCESS_MESSAGES,
+  ABC_EVENTS,
+  STORAGE_PREFIX,
+  DEBUG_MODE,
+  DEFAULT_HEADERS,
+  ABC_FEATURES
+};

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

@@ -0,0 +1,115 @@
+"use client";
+import {
+  ABC_ENDPOINTS
+} from "./chunk-OBS74J5N.js";
+
+// src/wallets/walletConnectors/abcWallet/secure.ts
+import CryptoJS from "crypto-js";
+import elliptic from "elliptic";
+var EC = elliptic.ec;
+var SecureService = class {
+  constructor(baseURL) {
+    this.secureChannel = null;
+    this.channelExpiry = 0;
+    this.baseURL = baseURL;
+  }
+  async getSecureChannel() {
+    if (this.secureChannel && Date.now() < this.channelExpiry) {
+      return this.secureChannel;
+    }
+    const result = {};
+    const plain = Array.from(crypto.getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const ec = new EC("p256");
+    const myKey = ec.genKeyPair();
+    const pubkey = myKey.getPublic().encode("hex", false);
+    const url = `${this.baseURL}${ABC_ENDPOINTS.SECURE_CHANNEL_CREATE}`;
+    const bodyString = new URLSearchParams({ pubkey, plain }).toString();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: bodyString
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        `\u274C Secure channel HTTP error: ${response.status} ${response.statusText}`
+      );
+      console.error("Response body:", errorText);
+      throw new Error(
+        `Failed to create secure channel: HTTP ${response.status} - ${errorText}`
+      );
+    }
+    const res = await response.json();
+    const resData = res;
+    if (resData.channelid && resData.publickey) {
+      const serverKey = ec.keyFromPublic(resData.publickey, "hex");
+      const sharedSecret = serverKey.getPublic().mul(myKey.getPrivate()).getX();
+      const secretKey = sharedSecret.toString(16).padStart(64, "0");
+      result.response = resData;
+      result.myKey = myKey;
+      result.secretKey = secretKey;
+      this.secureChannel = result;
+      this.channelExpiry = Date.now() + 20 * 60 * 1e3;
+    } else if (res.status === "success" && res.result) {
+      const result_data = res.result;
+      const serverKey = ec.keyFromPublic(result_data.publickey, "hex");
+      const sharedSecret = serverKey.getPublic().mul(myKey.getPrivate()).getX();
+      const secretKey = sharedSecret.toString(16).padStart(64, "0");
+      result.response = result_data;
+      result.myKey = myKey;
+      result.secretKey = secretKey;
+      this.secureChannel = result;
+      this.channelExpiry = Date.now() + 20 * 60 * 1e3;
+      console.log("\u2705 Secure channel created successfully (wrapped format)");
+    } else {
+      const errorMsg = res.message || res.detail || "Unknown error";
+      console.error("\u274C Failed to create secure channel:", res);
+      throw new Error(`Failed to create secure channel: ${errorMsg}`);
+    }
+    return result;
+  }
+  async encrypt(plain) {
+    const secureChannel = await this.getSecureChannel();
+    if (!secureChannel.secretKey || !secureChannel.response) {
+      throw new Error("Secure channel not established");
+    }
+    const secretKey = secureChannel.secretKey;
+    const key = secretKey.substring(0, 32);
+    const iv = secretKey.substring(32);
+    const encrypted = CryptoJS.AES.encrypt(plain, CryptoJS.enc.Hex.parse(key), {
+      iv: CryptoJS.enc.Hex.parse(iv),
+      padding: CryptoJS.pad.Pkcs7,
+      mode: CryptoJS.mode.CBC
+    });
+    return {
+      encryptPlain: encrypted.toString(),
+      secureChannel: secureChannel.response.channelid
+    };
+  }
+  async getSecureChannelId() {
+    const channel = await this.getSecureChannel();
+    if (!channel.response?.channelid) {
+      throw new Error("Secure channel not established");
+    }
+    return channel.response.channelid;
+  }
+  async getEncryptPlain(plain) {
+    const result = await this.encrypt(plain);
+    return result.encryptPlain;
+  }
+  /**
+   * Clear cached secure channel (for testing or reset)
+   */
+  clearCache() {
+    this.secureChannel = null;
+    this.channelExpiry = 0;
+    console.log("\u{1F504} Secure channel cache cleared");
+  }
+};
+var secure_default = SecureService;
+
+export {
+  secure_default
+};