@talken/talkenkit 2.3.14 → 2.4.4

package/dist/wallets/walletConnectors/{chunk-5UEBEMEE.js → chunk-RQIUWXDF.js}

@@ -29,11 +29,12 @@ var AbcErrorCode = /* @__PURE__ */ ((AbcErrorCode2) => {
   return AbcErrorCode2;
 })(AbcErrorCode || {});
 var AbcError = class extends Error {
-  constructor(code, message, details) {
+  constructor(code, message, details, statusCode) {
     super(message);
     this.name = "AbcError";
     this.code = code;
     this.details = details;
+    this.statusCode = statusCode;
   }
 };
 

package/dist/wallets/walletConnectors/{chunk-75W4VLFA.js → chunk-SCD35IRD.js}

@@ -106,7 +106,10 @@ var AbcBitcoinProvider = class extends EventEmitter {
       address: wallet.address,
       network: this.network.type
     });
-    console.log("[BitcoinProvider] \u2705 Wallet connected:", wallet.address);
+    console.log(
+      "[BitcoinProvider] \u2705 Wallet connected:",
+      `${wallet.address.substring(0, 6)}...${wallet.address.substring(wallet.address.length - 4)}`
+    );
   }
   /**
    * Clear wallet (disconnect)

package/dist/wallets/walletConnectors/{chunk-DPL5VRGJ.js → chunk-SOCVQ5N3.js}

@@ -1,13 +1,13 @@
 "use client";
 import {
   BaseApiClient
-} from "./chunk-KJHOGJ3A.js";
-import {
-  createAbcError
-} from "./chunk-UV5HHESJ.js";
+} from "./chunk-J6VUIOSE.js";
 import {
   getSolanaNetwork
-} from "./chunk-ZX6LABEF.js";
+} from "./chunk-A7FIBI6X.js";
+import {
+  createAbcError
+} from "./chunk-5RSS3SRV.js";
 import {
   ABC_ENDPOINTS,
   DEFAULT_HEADERS

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

@@ -0,0 +1,194 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-LQ2U33WM.js";
+import {
+  createAbcError
+} from "./chunk-TYUEB4VT.js";
+
+// src/wallets/walletConnectors/abcWallet/api/TransactionApi.ts
+var TransactionApi = class extends BaseApiClient {
+  /**
+   * Send raw transaction
+   */
+  async sendRawTransaction(chainId, signedTransaction) {
+    const network = this.getNetworkName(chainId);
+    const secureChannelId = await this.secure.getSecureChannelId();
+    const bodyData = {
+      signedSerializeTx: signedTransaction,
+      network
+    };
+    const bodyString = new URLSearchParams(bodyData).toString();
+    const url = "${this.baseURL}${ABC_ENDPOINTS.SEND_RAW_TX}";
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        "Secure-Channel": secureChannelId,
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: bodyString
+    });
+    const text = await response.text();
+    if (!text) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Empty response from sendRawTx API (status: ${response.status})",
+        { status: response.status }
+      );
+    }
+    const res = JSON.parse(text);
+    if (response.status === 401 && this.refreshToken) {
+      try {
+        await this.refreshAccessToken();
+        const retryResponse = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Secure-Channel": secureChannelId,
+            ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+          },
+          body: bodyString
+        });
+        const retryText = await retryResponse.text();
+        if (!retryText) {
+          throw createAbcError(
+            "NETWORK_ERROR" /* NETWORK_ERROR */,
+            "Empty response after retry (status: ${retryResponse.status})",
+            { status: retryResponse.status }
+          );
+        }
+        const retryRes = JSON.parse(retryText);
+        if (retryRes.item || retryRes.txHash || retryRes.result?.txHash) {
+          const txHash = retryRes.item || retryRes.txHash || retryRes.result.txHash;
+          return { txHash };
+        }
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Failed to send transaction after token refresh",
+          retryRes
+        );
+      } catch (refreshError) {
+        console.error(
+          "Token refresh failed in sendRawTransaction:",
+          refreshError
+        );
+        throw refreshError;
+      }
+    }
+    if (res.result) {
+      if (typeof res.result === "string") {
+        return { txHash: res.result };
+      }
+      if (res.result.txHash) {
+        return { txHash: res.result.txHash };
+      }
+    }
+    if (res.item) {
+      return { txHash: res.item };
+    }
+    if (res.txHash) {
+      return { txHash: res.txHash };
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to send transaction",
+      res
+    );
+  }
+  /**
+   * Get transaction count (nonce)
+   */
+  async getTransactionCount(_address, _network, _block = "latest") {
+    const nonceUrl = "${this.baseURL}${ABC_ENDPOINTS.TRANSACTION_COUNT}?address=${address}&network=${network}&block=${block}";
+    const response = await fetch(nonceUrl, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return Number.parseInt(data.result, 16);
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get transaction count"
+    );
+  }
+  /**
+   * Get suggested gas fees for EIP-1559
+   */
+  async getSuggestedGasFees(_network) {
+    const url = "${this.baseURL}${ABC_ENDPOINTS.GAS_SUGGESTED_FEES}?network=${network}";
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data;
+    }
+    throw createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Failed to get suggested gas fees"
+    );
+  }
+  /**
+   * Estimate gas limit for EIP-1559 transaction
+   */
+  async estimateGas(params) {
+    const estimateBody = new URLSearchParams({
+      network: params.network,
+      to: params.to || "0x",
+      ...params.from ? { from: params.from } : {},
+      ...params.value ? { value: params.value } : {},
+      ...params.data && params.data !== "0x" ? { data: params.data } : {},
+      ...params.maxFeePerGas ? { maxFeePerGas: params.maxFeePerGas } : {},
+      ...params.maxPriorityFeePerGas ? { maxPriorityFeePerGas: params.maxPriorityFeePerGas } : {}
+    });
+    const url = "${this.baseURL}${ABC_ENDPOINTS.GAS_ESTIMATE_EIP1559}";
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...this.accessToken ? { Authorization: "Bearer ${this.accessToken}" } : {}
+      },
+      body: estimateBody.toString()
+    });
+    const data = await response.json();
+    if (response.ok && data.result) {
+      return data.result;
+    }
+    const fallbackGasLimit = "0x2dc6c0";
+    console.warn("\u26A0\uFE0F Gas estimate failed, using fallback:", {
+      error: data.errorMessage || data.msg,
+      fallbackGasLimit
+    });
+    return fallbackGasLimit;
+  }
+  /**
+   * Convert chainId to network name
+   */
+  getNetworkName(chainId) {
+    const networkMap = {
+      1: "ethereum",
+      11155111: "ethereum_sepolia",
+      8217: "klaytn",
+      1001: "klaytn_baobab",
+      137: "polygon",
+      80002: "polygon_amoy",
+      42161: "arbitrum",
+      421614: "arbitrum_sepolia",
+      5e3: "mantle",
+      5003: "mantle_testnet"
+    };
+    return networkMap[chainId] || "ethereum";
+  }
+};
+
+export {
+  TransactionApi
+};

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

@@ -0,0 +1,477 @@
+"use client";
+import {
+  PIN_CONFIG,
+  STORAGE_PREFIX,
+  TOKEN_EXPIRY
+} from "./chunk-VETRBBA2.js";
+import {
+  AbcError,
+  AbcStorageKey
+} from "./chunk-RQIUWXDF.js";
+
+// src/wallets/walletConnectors/abcWallet/utils.ts
+import CryptoJS from "crypto-js";
+async function hashPin(pin) {
+  if (typeof window === "undefined" || !window.crypto?.subtle) {
+    return btoa(pin);
+  }
+  const encoder = new TextEncoder();
+  const data = encoder.encode(pin);
+  const hashBuffer = await window.crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+function validatePin(pin) {
+  if (!pin || typeof pin !== "string") {
+    return false;
+  }
+  const pinLength = pin.length;
+  if (pinLength < PIN_CONFIG.MIN_LENGTH || pinLength > PIN_CONFIG.MAX_LENGTH) {
+    return false;
+  }
+  return /^\d+$/.test(pin);
+}
+function validateEmail(email) {
+  if (!email || typeof email !== "string") {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function getStorageKey(key) {
+  return `${STORAGE_PREFIX}${key}`;
+}
+function saveToStorage(key, value) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const storageKey = getStorageKey(key);
+    const serialized = JSON.stringify(value);
+    localStorage.setItem(storageKey, serialized);
+  } catch (error) {
+    console.error("Failed to save to storage:", error);
+  }
+}
+function loadFromStorage(key) {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const storageKey = getStorageKey(key);
+    const serialized = localStorage.getItem(storageKey);
+    if (!serialized)
+      return null;
+    try {
+      return JSON.parse(serialized);
+    } catch {
+      return serialized;
+    }
+  } catch (error) {
+    console.error("Failed to load from storage:", error);
+    return null;
+  }
+}
+function removeFromStorage(key) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const storageKey = getStorageKey(key);
+    localStorage.removeItem(storageKey);
+  } catch (error) {
+    console.error("Failed to remove from storage:", error);
+  }
+}
+function clearStorage() {
+  if (typeof window === "undefined")
+    return;
+  for (const key of Object.values(AbcStorageKey)) {
+    removeFromStorage(key);
+  }
+}
+function isTokenExpired(expiresAt) {
+  if (!expiresAt)
+    return true;
+  return Date.now() >= expiresAt - TOKEN_EXPIRY.REFRESH_BUFFER;
+}
+function calculateExpiryTimestamp(expiresIn) {
+  return Date.now() + expiresIn * 1e3;
+}
+function saveAuthState(state) {
+  saveToStorage("auth_state" /* AUTH_STATE */, state);
+  if (state.user) {
+    saveToStorage("user" /* USER */, state.user);
+  }
+  if (state.wallet) {
+    saveToStorage("wallet" /* WALLET */, state.wallet);
+  }
+  if (state.solanaWallet) {
+    saveToStorage("solana_wallet" /* SOLANA_WALLET */, state.solanaWallet);
+  }
+  if (state.bitcoinWallet) {
+    saveToStorage("bitcoin_wallet" /* BITCOIN_WALLET */, state.bitcoinWallet);
+  }
+  if (state.accessToken) {
+    saveToStorage("access_token" /* ACCESS_TOKEN */, state.accessToken);
+  }
+  if (state.refreshToken) {
+    saveToStorage("refresh_token" /* REFRESH_TOKEN */, state.refreshToken);
+  }
+  if (state.expiresAt) {
+    saveToStorage("expires_at" /* EXPIRES_AT */, state.expiresAt);
+  }
+}
+function loadAuthState() {
+  const state = loadFromStorage("auth_state" /* AUTH_STATE */);
+  if (state) {
+    if (state.accessToken && isTokenExpired(state.expiresAt)) {
+      clearStorage();
+      return null;
+    }
+    return state;
+  }
+  const user = loadFromStorage("user" /* USER */);
+  const wallet = loadFromStorage("wallet" /* WALLET */);
+  const solanaWallet = loadFromStorage("solana_wallet" /* SOLANA_WALLET */);
+  const accessToken = loadFromStorage("access_token" /* ACCESS_TOKEN */);
+  const refreshToken = loadFromStorage("refresh_token" /* REFRESH_TOKEN */);
+  const expiresAt = loadFromStorage("expires_at" /* EXPIRES_AT */);
+  if (!user || !accessToken) {
+    return null;
+  }
+  const bitcoinWallet = loadFromStorage("bitcoin_wallet" /* BITCOIN_WALLET */);
+  return {
+    isAuthenticated: true,
+    user,
+    wallet,
+    solanaWallet,
+    bitcoinWallet,
+    accessToken,
+    refreshToken,
+    expiresAt
+  };
+}
+function clearAuthState() {
+  clearStorage();
+}
+function getChainType(chainId) {
+  if (chainId === 900)
+    return "solana";
+  if (chainId === 800)
+    return "bitcoin";
+  return "evm";
+}
+function formatAddress(address, startLength = 6, endLength = 4) {
+  if (!address || address.length <= startLength + endLength) {
+    return address;
+  }
+  const start = address.substring(0, startLength);
+  const end = address.substring(address.length - endLength);
+  return `${start}...${end}`;
+}
+function createAbcError(code, message, details, statusCode) {
+  return new AbcError(code, message, details, statusCode);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, maxRetries = 3, delay = 1e3, backoffMultiplier = 2) {
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxRetries - 1) {
+        const waitTime = delay * backoffMultiplier ** attempt;
+        await sleep(waitTime);
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+function parseApiError(error) {
+  if (error instanceof AbcError) {
+    return error;
+  }
+  if (!error.response) {
+    return createAbcError(
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      "Network error occurred",
+      error
+    );
+  }
+  const response = error.response;
+  const data = response.data;
+  const statusCode = response.status;
+  if (statusCode === 401) {
+    return createAbcError(
+      "TOKEN_EXPIRED" /* TOKEN_EXPIRED */,
+      "Authentication token expired",
+      data,
+      401
+    );
+  }
+  if (statusCode === 409) {
+    return createAbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      // Will trigger recovery
+      data?.error || "Resource already exists",
+      data,
+      409
+    );
+  }
+  if (typeof data === "object" && "iserr" in data) {
+    const bitcoinData = data;
+    if (bitcoinData.iserr === true) {
+      return createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        bitcoinData.errmsg || "Bitcoin signature failed",
+        data,
+        statusCode
+      );
+    }
+    if (!bitcoinData.signstr) {
+      return createAbcError(
+        "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
+        "Bitcoin signature missing in response",
+        data,
+        statusCode
+      );
+    }
+    return createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Unexpected success response in error parser",
+      data,
+      statusCode
+    );
+  }
+  if (data?.error) {
+    return createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      data.error.message || data.error || "API error occurred",
+      data,
+      statusCode
+    );
+  }
+  if (data?.message) {
+    return createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      data.message.text || "API error occurred",
+      data,
+      statusCode
+    );
+  }
+  return createAbcError(
+    "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+    "An unknown error occurred",
+    error,
+    statusCode
+  );
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function isWeb3Available() {
+  return isBrowser() && typeof window.ethereum !== "undefined";
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+function isEmpty(obj) {
+  if (obj == null)
+    return true;
+  if (Array.isArray(obj))
+    return obj.length === 0;
+  if (typeof obj === "object")
+    return Object.keys(obj).length === 0;
+  return false;
+}
+function debounce(func, wait) {
+  let timeout = null;
+  return function(...args) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      func.apply(this, args);
+    }, wait);
+  };
+}
+function throttle(func, limit) {
+  let inThrottle = false;
+  return function(...args) {
+    if (!inThrottle) {
+      func.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => {
+        inThrottle = false;
+      }, limit);
+    }
+  };
+}
+function hexToNumber(hex) {
+  return Number.parseInt(hex, 16);
+}
+function numberToHex(num) {
+  return `0x${num.toString(16)}`;
+}
+function isValidEthereumAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function isValidSolanaAddress(address) {
+  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address);
+}
+function getExplorerUrl(chainId, txHash) {
+  const explorers = {
+    1: "https://etherscan.io/tx/",
+    5: "https://goerli.etherscan.io/tx/",
+    137: "https://polygonscan.com/tx/",
+    56: "https://bscscan.com/tx/",
+    900: "https://explorer.solana.com/tx/"
+    // Solana
+  };
+  const baseUrl = explorers[chainId];
+  return baseUrl ? `${baseUrl}${txHash}` : null;
+}
+function generateSalt() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function deriveKeyFromPin(pin, salt) {
+  return CryptoJS.PBKDF2(pin, salt, {
+    keySize: 256 / 32,
+    iterations: 1e5
+  }).toString();
+}
+function encryptWithPin(data, pin, salt) {
+  const key = deriveKeyFromPin(pin, salt);
+  const encrypted = CryptoJS.AES.encrypt(data, key).toString();
+  return encrypted;
+}
+function decryptWithPin(encrypted, pin, salt) {
+  try {
+    const key = deriveKeyFromPin(pin, salt);
+    const decrypted = CryptoJS.AES.decrypt(encrypted, key);
+    const decryptedText = decrypted.toString(CryptoJS.enc.Utf8);
+    if (!decryptedText) {
+      return null;
+    }
+    return decryptedText;
+  } catch (error) {
+    console.error("Decryption failed:", error);
+    return null;
+  }
+}
+function hasEncryptedTokens() {
+  if (typeof window === "undefined")
+    return false;
+  const encrypted = loadFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
+  const salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
+  return !!encrypted && !!salt;
+}
+function saveEncryptedTokens(accessToken, refreshToken, expiresIn, hashedPin) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    let salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
+    if (!salt) {
+      salt = generateSalt();
+      saveToStorage("token_salt" /* TOKEN_SALT */, salt);
+    }
+    const expiresAt = Date.now() + expiresIn * 1e3;
+    const tokenData = {
+      accessToken,
+      refreshToken,
+      expiresAt
+    };
+    const encrypted = encryptWithPin(
+      JSON.stringify(tokenData),
+      hashedPin,
+      salt
+    );
+    saveToStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */, encrypted);
+    removeFromStorage("access_token" /* ACCESS_TOKEN */);
+    removeFromStorage("refresh_token" /* REFRESH_TOKEN */);
+    removeFromStorage("expires_at" /* EXPIRES_AT */);
+  } catch (error) {
+    console.error("Failed to save encrypted tokens:", error);
+    throw new AbcError(
+      "ENCRYPTION_FAILED" /* ENCRYPTION_FAILED */,
+      "Failed to encrypt tokens"
+    );
+  }
+}
+function loadEncryptedTokens(hashedPin) {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const encrypted = loadFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
+    const salt = loadFromStorage("token_salt" /* TOKEN_SALT */);
+    if (!encrypted || !salt) {
+      return null;
+    }
+    const decrypted = decryptWithPin(encrypted, hashedPin, salt);
+    if (!decrypted) {
+      throw new AbcError("INVALID_PIN" /* INVALID_PIN */, "Incorrect PIN");
+    }
+    const tokenData = JSON.parse(decrypted);
+    return tokenData;
+  } catch (error) {
+    console.error("Failed to load encrypted tokens:", error);
+    if (error instanceof AbcError) {
+      throw error;
+    }
+    throw new AbcError(
+      "DECRYPTION_FAILED" /* DECRYPTION_FAILED */,
+      "Failed to decrypt tokens"
+    );
+  }
+}
+function clearEncryptedTokens() {
+  removeFromStorage("encrypted_tokens" /* ENCRYPTED_TOKENS */);
+  removeFromStorage("token_salt" /* TOKEN_SALT */);
+}
+
+export {
+  hashPin,
+  validatePin,
+  validateEmail,
+  getStorageKey,
+  saveToStorage,
+  loadFromStorage,
+  removeFromStorage,
+  clearStorage,
+  isTokenExpired,
+  calculateExpiryTimestamp,
+  saveAuthState,
+  loadAuthState,
+  clearAuthState,
+  getChainType,
+  formatAddress,
+  createAbcError,
+  sleep,
+  retry,
+  parseApiError,
+  isBrowser,
+  isWeb3Available,
+  generateId,
+  deepClone,
+  isEmpty,
+  debounce,
+  throttle,
+  hexToNumber,
+  numberToHex,
+  isValidEthereumAddress,
+  isValidSolanaAddress,
+  getExplorerUrl,
+  hasEncryptedTokens,
+  saveEncryptedTokens,
+  loadEncryptedTokens,
+  clearEncryptedTokens
+};