@talken/talkenkit 2.3.4

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

@@ -0,0 +1,309 @@
+"use client";
+import {
+  BaseApiClient
+} from "./chunk-IOLHAU7H.js";
+import {
+  createAbcError
+} from "./chunk-W23N7VC4.js";
+import {
+  ABC_AUDIENCE,
+  ABC_ENDPOINTS
+} from "./chunk-VETRBBA2.js";
+
+// src/wallets/walletConnectors/abcWallet/api/AuthApi.ts
+var AuthApi = class extends BaseApiClient {
+  /**
+   * Login with email and password
+   */
+  async loginWithEmail(email, password) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: password,
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Email login failed",
+      response
+    );
+  }
+  /**
+   * Login with email and OTP (for PIN recovery)
+   */
+  async loginWithOtp(email, otpCode) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          email,
+          token: otpCode,
+          service: "email",
+          audience: ABC_AUDIENCE
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "OTP login failed",
+      response
+    );
+  }
+  /**
+   * Login with social provider
+   */
+  async loginWithSocial(provider, token, email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SNS_LOGIN,
+      {
+        method: "POST",
+        body: {
+          token,
+          service: provider,
+          audience: ABC_AUDIENCE,
+          email
+        },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      this.saveTokens(
+        response.data.accessToken,
+        response.data.refreshToken,
+        response.data.expiresIn
+      );
+      return response.data;
+    }
+    throw createAbcError(
+      "INVALID_CREDENTIALS" /* INVALID_CREDENTIALS */,
+      "Social login failed",
+      response
+    );
+  }
+  /**
+   * Request OTP code for email
+   */
+  async requestOtpCode(email) {
+    const response = await this.request(
+      ABC_ENDPOINTS.SEND_OTP,
+      {
+        method: "POST",
+        body: { email },
+        skipAuth: true
+      }
+    );
+    if (response.status === "success" && response.data) {
+      return response.data;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Failed to request OTP",
+      response
+    );
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtpCode(email, code) {
+    const response = await this.request(ABC_ENDPOINTS.VERIFY_OTP, {
+      method: "POST",
+      body: { email, code },
+      skipAuth: true
+    });
+    return response.status === "success";
+  }
+  /**
+   * Check if email already exists
+   */
+  async emailCheck(_email) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = `${_talkenApiUrl}/abc/emailCheck?email=${encodeURIComponent(_email)}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" }
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Email check failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Email check failed",
+        error
+      );
+    }
+  }
+  /**
+   * Send OTP code to email for signup
+   */
+  async sendOtpCode(_email) {
+    const endpoint = "/member/mail-service/${encodeURIComponent(email)}/sendcode";
+    const response = await this.request(endpoint, {
+      method: "GET",
+      skipAuth: true
+    });
+    if (response.status === "success") {
+      return response;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Failed to send OTP code",
+      response
+    );
+  }
+  /**
+   * Verify OTP code for signup
+   */
+  async verifyOtpCodeSignup(email, code) {
+    const endpoint = "/member/mail-service/${encodeURIComponent(email)}/verifycode";
+    const requestBody = {
+      email,
+      code,
+      serviceid: ABC_AUDIENCE
+    };
+    const response = await this.request(endpoint, {
+      method: "POST",
+      body: requestBody,
+      skipAuth: true
+    });
+    const isSuccess = response.status === "success" || response.status === 200 || response.message === "success";
+    if (isSuccess) {
+      return response;
+    }
+    throw createAbcError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      "Invalid or expired OTP code",
+      response
+    );
+  }
+  /**
+   * Register new user
+   */
+  async registerUser(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/adduser";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "User registration failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "User registration failed",
+        error
+      );
+    }
+  }
+  /**
+   * Register new SNS user (email-based registration with OTP)
+   */
+  async registerSnsUser(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/snsAdduser";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "SNS user registration failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "SNS user registration failed",
+        error
+      );
+    }
+  }
+  /**
+   * Reset/Set password for existing user
+   */
+  async resetPassword(params) {
+    const _talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
+    const url = "${talkenApiUrl}/abc/initpassword";
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        credentials: "include",
+        body: new URLSearchParams(params).toString()
+      });
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : { status: "success" };
+      if (!response.ok) {
+        throw createAbcError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "Password reset failed",
+          data
+        );
+      }
+      return data;
+    } catch (error) {
+      throw createAbcError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "Password reset failed",
+        error
+      );
+    }
+  }
+};
+
+export {
+  AuthApi
+};

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

@@ -0,0 +1,50 @@
+"use client";
+import {
+  getInjectedConnector,
+  hasInjectedProvider
+} from "./chunk-MBBGZGXF.js";
+
+// src/wallets/walletConnectors/magicEdenWallet/magicEdenWallet.ts
+var magicEdenWallet = () => {
+  return {
+    id: "magicEden",
+    name: "Magic Eden Wallet",
+    rdns: "io.magiceden.wallet",
+    iconUrl: async () => (await import("./magicEden-PKT2ZXEQ.js")).default,
+    iconBackground: "#36114D",
+    installed: hasInjectedProvider({ namespace: "magicEden.ethereum" }),
+    downloadUrls: {
+      chrome: "https://chromewebstore.google.com/detail/magic-eden-wallet/mkpegjkblkkefacfnmkajcjmabijhclg",
+      browserExtension: "https://wallet.magiceden.io/"
+    },
+    extension: {
+      instructions: {
+        steps: [
+          {
+            description: "wallet_connectors.magicEden.extension.step1.description",
+            step: "install",
+            title: "wallet_connectors.magicEden.extension.step1.title"
+          },
+          {
+            description: "wallet_connectors.magicEden.extension.step2.description",
+            step: "create",
+            title: "wallet_connectors.magicEden.extension.step2.title"
+          },
+          {
+            description: "wallet_connectors.magicEden.extension.step3.description",
+            step: "refresh",
+            title: "wallet_connectors.magicEden.extension.step3.title"
+          }
+        ],
+        learnMoreUrl: "https://wallet.magiceden.io/support"
+      }
+    },
+    createConnector: getInjectedConnector({
+      namespace: "magicEden.ethereum"
+    })
+  };
+};
+
+export {
+  magicEdenWallet
+};

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

@@ -0,0 +1,318 @@
+"use client";
+import {
+  AbcError
+} from "./chunk-5UEBEMEE.js";
+
+// src/wallets/walletConnectors/abcWallet/walletGeneration.ts
+async function generateMpcWallets(client, uid, hashedPin, evmChainId = 1, bitcoinNetwork = "bitcoin") {
+  try {
+    console.log("[MpcWallets] \u{1F680} Starting wallet generation...");
+    const evmWallet = await generateEvmWallet(
+      client,
+      uid,
+      hashedPin,
+      evmChainId
+    );
+    console.log("[MpcWallets] \u2705 EVM wallet generated");
+    const [solanaWallet, bitcoinWallet] = await Promise.all([
+      // Solana wallet (Ed25519) - separate V3 wallet
+      generateSolanaWallet(client, hashedPin),
+      // Bitcoin wallet - converts EVM pubkey to Bitcoin address
+      generateBitcoinWallet(evmWallet, client, bitcoinNetwork)
+    ]);
+    console.log("[MpcWallets] \u2705 All wallets generated successfully");
+    return { evmWallet, solanaWallet, bitcoinWallet };
+  } catch (error) {
+    console.error("[MpcWallets] \u274C Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to generate MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverMpcWallets(client, uid, hashedPin, evmChainId = 1, bitcoinNetwork = "bitcoin") {
+  try {
+    console.log("[MpcWallets] \u{1F527} Starting wallet recovery...");
+    const evmWallet = await recoverEvmWallet(
+      client,
+      uid,
+      hashedPin,
+      evmChainId
+    );
+    console.log("[MpcWallets] \u2705 EVM wallet recovered");
+    const [solanaWallet, bitcoinWallet] = await Promise.all([
+      // Solana wallet (Ed25519) - separate V3 wallet
+      recoverSolanaWallet(client, hashedPin),
+      // Bitcoin wallet - converts EVM pubkey to Bitcoin address
+      recoverBitcoinWallet(evmWallet, client, bitcoinNetwork)
+    ]);
+    console.log("[MpcWallets] \u2705 All wallets recovered successfully");
+    return { evmWallet, solanaWallet, bitcoinWallet };
+  } catch (error) {
+    console.error("[MpcWallets] \u274C Recovery failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Failed to recover MPC wallets: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function generateEvmWallet(client, uid, hashedPin, chainId) {
+  try {
+    let wallet;
+    if ("generateOrRecoverWallet" in client) {
+      wallet = await client.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    } else {
+      const walletApi = client.wallet;
+      if (!walletApi) {
+        throw new Error("Wallet API not available in client");
+      }
+      wallet = await walletApi.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    }
+    return wallet;
+  } catch (error) {
+    console.error("[EVM] Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `EVM wallet generation failed: ${error.message}`,
+      { chainId, originalError: error }
+    );
+  }
+}
+async function generateSolanaWallet(client, hashedPin) {
+  try {
+    let wallet;
+    if ("generateSolanaWallet" in client) {
+      wallet = await client.generateSolanaWallet(hashedPin);
+    } else {
+      const solanaApi = client.solana;
+      if (!solanaApi) {
+        throw new Error("Solana API not available in client");
+      }
+      wallet = await solanaApi.generateSolanaWallet(hashedPin);
+    }
+    return wallet;
+  } catch (error) {
+    const errorMessage = error.message || "";
+    const errorDetails = JSON.stringify(error.details || {});
+    const isConflict = errorMessage.includes("409") || errorMessage.includes("already exists") || errorMessage.includes("duplicate key") || errorDetails.includes("409") || errorDetails.includes("already exists") || errorDetails.includes("duplicate key");
+    if (isConflict) {
+      console.log("[Solana] Wallet already exists, recovering...");
+      return recoverSolanaWallet(client, hashedPin);
+    }
+    console.error("[Solana] Generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Solana wallet generation failed: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function generateBitcoinWallet(evmWallet, client, network) {
+  try {
+    console.log("[Bitcoin] \u{1F527} Converting EVM pubkey to Bitcoin address...");
+    const bitcoinApi = "bitcoin" in client ? client.bitcoin : null;
+    if (!bitcoinApi) {
+      throw new Error("Bitcoin API not available in client");
+    }
+    const publicKey = evmWallet.pubkey || "";
+    if (!publicKey) {
+      throw new Error("Public key not found in EVM wallet");
+    }
+    const bitcoinAddress = await bitcoinApi.getBitcoinAddress(
+      publicKey,
+      network,
+      "bech32"
+      // Native SegWit (recommended)
+    );
+    console.log("[Bitcoin] \u2705 Address generated:", bitcoinAddress);
+    return {
+      uid: evmWallet.uid,
+      sessionId: evmWallet.keyId,
+      // Use keyId as sessionId
+      shareId: evmWallet.keyId,
+      // Use keyId as shareId
+      publicKey,
+      address: bitcoinAddress,
+      addressType: "bech32",
+      keyId: evmWallet.keyId,
+      encryptedShare: evmWallet.encryptedShare,
+      network
+    };
+  } catch (error) {
+    console.error("[Bitcoin] \u274C Address generation failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Bitcoin address generation failed: ${error.message}`,
+      { network, originalError: error }
+    );
+  }
+}
+async function recoverEvmWallet(client, uid, hashedPin, chainId) {
+  console.log("\u{1F527} [EVM] Recovering EVM wallet...");
+  try {
+    let wallet;
+    if ("generateOrRecoverWallet" in client) {
+      wallet = await client.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    } else {
+      const walletApi = client.wallet;
+      if (!walletApi) {
+        throw new Error("Wallet API not available in client");
+      }
+      wallet = await walletApi.generateOrRecoverWallet({
+        uid,
+        pin: hashedPin,
+        chainId
+      });
+    }
+    console.log("\u2705 [EVM] Wallet recovered:", wallet.address);
+    return wallet;
+  } catch (error) {
+    console.error("\u274C [EVM] Recovery failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `EVM wallet recovery failed: ${error.message}`,
+      { chainId, originalError: error }
+    );
+  }
+}
+async function recoverSolanaWallet(client, hashedPin) {
+  console.log("\u{1F527} [Solana] Recovering Solana wallet...");
+  try {
+    let wallet;
+    if ("generateSolanaWallet" in client) {
+      wallet = await client.generateSolanaWallet(hashedPin, true);
+    } else {
+      const solanaApi = client.solana;
+      if (!solanaApi) {
+        throw new Error("Solana API not available in client");
+      }
+      wallet = await solanaApi.recoverSolanaWallet(hashedPin);
+    }
+    console.log("\u2705 [Solana] Wallet recovered:", wallet.address);
+    return wallet;
+  } catch (error) {
+    console.error("\u274C [Solana] Recovery failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Solana wallet recovery failed: ${error.message}`,
+      { originalError: error }
+    );
+  }
+}
+async function recoverBitcoinWallet(evmWallet, client, network) {
+  try {
+    console.log("[Bitcoin] \u{1F527} Converting EVM pubkey to Bitcoin address...");
+    const bitcoinApi = "bitcoin" in client ? client.bitcoin : null;
+    if (!bitcoinApi) {
+      throw new Error("Bitcoin API not available in client");
+    }
+    const publicKey = evmWallet.pubkey || "";
+    if (!publicKey) {
+      throw new Error("Public key not found in EVM wallet");
+    }
+    const bitcoinAddress = await bitcoinApi.getBitcoinAddress(
+      publicKey,
+      network,
+      "bech32"
+      // Native SegWit (recommended)
+    );
+    console.log("[Bitcoin] \u2705 Address recovered:", bitcoinAddress);
+    return {
+      uid: evmWallet.uid,
+      sessionId: evmWallet.keyId,
+      // Use keyId as sessionId
+      shareId: evmWallet.keyId,
+      // Use keyId as shareId
+      publicKey,
+      address: bitcoinAddress,
+      addressType: "bech32",
+      keyId: evmWallet.keyId,
+      encryptedShare: evmWallet.encryptedShare,
+      network
+    };
+  } catch (error) {
+    console.error("[Bitcoin] \u274C Address recovery failed:", error.message);
+    throw new AbcError(
+      "WALLET_NOT_FOUND" /* WALLET_NOT_FOUND */,
+      `Bitcoin address recovery failed: ${error.message}`,
+      { network, originalError: error }
+    );
+  }
+}
+function validateMpcWallets(result) {
+  const errors = [];
+  if (!result.evmWallet) {
+    errors.push("EVM wallet is missing");
+  } else {
+    if (!result.evmWallet.address || !result.evmWallet.address.startsWith("0x")) {
+      errors.push("Invalid EVM wallet address");
+    }
+    if (!result.evmWallet.keyId) {
+      errors.push("EVM wallet missing keyId");
+    }
+    if (!result.evmWallet.encryptedShare) {
+      errors.push("EVM wallet missing encryptedShare");
+    }
+  }
+  if (!result.solanaWallet) {
+    errors.push("Solana wallet is missing");
+  } else {
+    if (!result.solanaWallet.address) {
+      errors.push("Invalid Solana wallet address");
+    }
+    if (!result.solanaWallet.publicKey) {
+      errors.push("Solana wallet missing publicKey");
+    }
+    if (!result.solanaWallet.keyId) {
+      errors.push("Solana wallet missing keyId");
+    }
+  }
+  if (!result.bitcoinWallet) {
+    errors.push("Bitcoin wallet is missing");
+  } else {
+    const addr = result.bitcoinWallet.address;
+    const type = result.bitcoinWallet.addressType;
+    if (!addr) {
+      errors.push("Invalid Bitcoin wallet address");
+    }
+    if (!result.bitcoinWallet.publicKey) {
+      errors.push("Bitcoin wallet missing publicKey");
+    }
+    if (!result.bitcoinWallet.keyId) {
+      errors.push("Bitcoin wallet missing keyId");
+    }
+    if (type === "bech32" && !addr.startsWith("bc1q")) {
+      errors.push("Invalid Bech32 address format (expected bc1q prefix)");
+    } else if (type === "p2pkh" && !addr.startsWith("1")) {
+      errors.push("Invalid P2PKH address format (expected 1 prefix)");
+    } else if (type === "p2sh" && !addr.startsWith("3")) {
+      errors.push("Invalid P2SH address format (expected 3 prefix)");
+    } else if (type === "taproot" && !addr.startsWith("bc1p")) {
+      errors.push("Invalid Taproot address format (expected bc1p prefix)");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+export {
+  generateMpcWallets,
+  recoverMpcWallets,
+  validateMpcWallets
+};