@talken/talkenkit 2.3.14 → 2.3.15

package/dist/wallets/walletConnectors/{chunk-LOP2R3QJ.js → chunk-JR2C4XXX.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-G2LI5MVX.js";
 import {
   getSolanaNetwork
-} from "./chunk-ZX6LABEF.js";
+} from "./chunk-A7FIBI6X.js";
 import {
   calculateExpiryTimestamp,
   createAbcError,
@@ -412,11 +412,6 @@ var AbcWaasClient = class {
     const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
     const url = `${talkenApiUrl}/abc/emailCheck?email=${encodeURIComponent(email)}`;
     const method = "GET";
-    console.log("[AbcWaasClient] \u{1F4EC} Checking email:", {
-      email,
-      url,
-      apiServer: talkenApiUrl
-    });
     try {
       const response = await fetch(url, {
         method,
@@ -458,11 +453,6 @@ var AbcWaasClient = class {
    */
   async sendOtpCode(email) {
     const endpoint = `/member/mail-service/${encodeURIComponent(email)}/sendcode`;
-    console.log("[AbcWaasClient] \u{1F4E7} Sending OTP code:", {
-      email,
-      endpoint,
-      fullUrl: `${this.baseURL}${endpoint}`
-    });
     const response = await this.request(endpoint, {
       method: "GET",
       skipAuth: true
@@ -489,21 +479,11 @@ var AbcWaasClient = class {
       serviceid: ABC_AUDIENCE
       // 'https://mw.myabcwallet.com'
     };
-    console.log("[AbcWaasClient] \u{1F510} Verifying OTP code:", {
-      email,
-      code: `${code.substring(0, 2)}****`,
-      // Mask OTP for security
-      serviceid: ABC_AUDIENCE,
-      endpoint,
-      fullUrl: `${this.baseURL}${endpoint}`,
-      requestBody
-    });
     const response = await this.request(endpoint, {
       method: "POST",
       body: requestBody,
       skipAuth: true
     });
-    console.log("[verifyOtpCodeSignup] Response:", response);
     const isSuccess = response.status === "success" || response.status === 200 || response.message === "success";
     if (isSuccess) {
       return response;
@@ -523,13 +503,6 @@ var AbcWaasClient = class {
   async snsLogin(params) {
     const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
     const url = `${talkenApiUrl}/abc/snsLogin`;
-    console.log("[AbcWaasClient] \u{1F510} SNS Login:", {
-      service: params.service,
-      email: params.email,
-      audience: params.audience,
-      hasToken: !!params.token,
-      url
-    });
     try {
       const response = await fetch(url, {
         method: "POST",
@@ -562,7 +535,6 @@ var AbcWaasClient = class {
           { service: params.service, response: data }
         );
       }
-      console.log("[AbcWaasClient] \u2705 SNS login successful:", params.email);
       return {
         uid: "",
         // Will be fetched later via info() API
@@ -592,14 +564,6 @@ var AbcWaasClient = class {
     const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
     const url = `${talkenApiUrl}/abc/adduser`;
     const method = "POST";
-    console.log("[AbcWaasClient] \u{1F4DD} Registering user:", {
-      username: params.username,
-      name: params.name,
-      hasPassword: !!params.password,
-      hasSecureChannel: !!params.secureChannel,
-      hasEmailCode: !!params.emailCode,
-      url
-    });
     try {
       const response = await fetch(url, {
         method,
@@ -648,12 +612,6 @@ var AbcWaasClient = class {
     const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
     const url = `${talkenApiUrl}/abc/snsAdduser`;
     const method = "POST";
-    console.log("[AbcWaasClient] \u{1F4DD} Registering SNS user:", {
-      username: params.username,
-      name: params.name,
-      hasOtp: !!params.sixCode,
-      url
-    });
     try {
       const response = await fetch(url, {
         method,
@@ -681,7 +639,6 @@ var AbcWaasClient = class {
           }
         });
       }
-      console.log("[AbcWaasClient] \u2705 SNS user registered successfully");
       return data;
     } catch (error) {
       if (error.name === "AbortError") {
@@ -703,13 +660,6 @@ var AbcWaasClient = class {
     const talkenApiUrl = process.env.NEXT_PUBLIC_API_SERVER || "https://dev.walletapi.talken.io";
     const url = `${talkenApiUrl}/abc/initpassword`;
     const method = "POST";
-    console.log("[AbcWaasClient] \u{1F510} Setting password:", {
-      username: params.username,
-      hasPassword: !!params.password,
-      hasSecureChannel: !!params.secureChannel,
-      hasEmailCode: !!params.emailCode,
-      url
-    });
     try {
       const response = await fetch(url, {
         method,
@@ -1100,7 +1050,7 @@ var AbcWaasClient = class {
       );
     }
     const ethers = await import("ethers");
-    const messageHash = ethers.ethers.utils.hashMessage(params.message);
+    const messageHash = ethers.utils.hashMessage(params.message);
     const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
     const encryptedDevicePassword = await this.secure.getEncryptPlain(
       wallet.encryptDevicePassword

package/dist/wallets/walletConnectors/{chunk-V3XKL7AD.js → chunk-KKPINUPY.js}

@@ -140,7 +140,7 @@ var SigningApi = class extends BaseApiClient {
       );
     }
     const ethers = await import("ethers");
-    const messageHash = ethers.ethers.utils.hashMessage(params.message);
+    const messageHash = ethers.utils.hashMessage(params.message);
     const hash = messageHash.startsWith("0x") ? messageHash.slice(2) : messageHash;
     const encryptedDevicePassword = await this.secure.getEncryptPlain(
       wallet.encryptDevicePassword

package/dist/wallets/walletConnectors/{chunk-5VL7T6AY.js → chunk-LENPUTNQ.js}

@@ -1,10 +1,15 @@
 "use client";
-import {
-  createAbcWaasClient
-} from "./chunk-AKYC5VZG.js";
 import {
   createAbcEvmProvider
 } from "./chunk-ZIYAL44B.js";
+import {
+  createAbcWaasClient
+} from "./chunk-PPIFAF7N.js";
+import {
+  setGlobalDefaultBitcoinNetwork,
+  setGlobalDefaultChainId,
+  setGlobalDefaultSolanaNetwork
+} from "./chunk-A7FIBI6X.js";
 import {
   clearAuthState,
   clearEncryptedTokens,
@@ -18,6 +23,15 @@ import {
 import { createConnector } from "wagmi";
 function abcConnector(options) {
   const { config } = options;
+  if (config.defaultChainId) {
+    setGlobalDefaultChainId(config.defaultChainId);
+  }
+  if (config.defaultSolanaNetwork) {
+    setGlobalDefaultSolanaNetwork(config.defaultSolanaNetwork);
+  }
+  if (config.defaultBitcoinNetwork) {
+    setGlobalDefaultBitcoinNetwork(config.defaultBitcoinNetwork);
+  }
   return createConnector((wagmiConfig) => {
     const client = createAbcWaasClient(config);
     const provider = createAbcEvmProvider(client);
@@ -46,6 +60,7 @@ function abcConnector(options) {
           provider.setWallet(authState.wallet);
           console.log("\u2705 Provider wallet set:", {
             address: authState.wallet.address,
+            chainId: authState.wallet.chainId,
             hasPIN: !!authState.pin
           });
           const accounts = await provider.request({

package/dist/wallets/walletConnectors/{chunk-25LLSYLN.js → chunk-N4FOYXQD.js}

@@ -1,10 +1,10 @@
 "use client";
-import {
-  SolanaApi
-} from "./chunk-A7KV643A.js";
 import {
   TransactionApi
 } from "./chunk-FGBDWBWQ.js";
+import {
+  SolanaApi
+} from "./chunk-GHLLVM7O.js";
 import {
   AuthApi
 } from "./chunk-MZOFZ2NQ.js";
@@ -13,10 +13,10 @@ import {
 } from "./chunk-BNSBK5PQ.js";
 import {
   SigningApi
-} from "./chunk-KZG5KU7A.js";
+} from "./chunk-OC2O4BHA.js";
 import {
   WalletApi
-} from "./chunk-DPL5VRGJ.js";
+} from "./chunk-CYYBGUSO.js";
 
 // src/wallets/walletConnectors/abcWallet/api/index.ts
 var AbcWaasApiClient = class {

package/dist/wallets/walletConnectors/{chunk-CNI3U6UK.js → chunk-NEXFU6BZ.js}

@@ -1,13 +1,13 @@
 "use client";
-import {
-  createAbcSolanaConnector
-} from "./chunk-RY4RAB3D.js";
 import {
   createAbcSolanaProvider
 } from "./chunk-FROV5VDF.js";
+import {
+  createAbcSolanaConnector
+} from "./chunk-RY4RAB3D.js";
 import {
   createAbcWaasClient
-} from "./chunk-AKYC5VZG.js";
+} from "./chunk-PPIFAF7N.js";
 
 // src/wallets/walletConnectors/abcWallet/abcSolanaWallet.ts
 var abcSolanaWallet = (options) => ({

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

@@ -0,0 +1,482 @@
+"use client";
+
+// src/wallets/walletConnectors/abcWallet/abcBitcoinProvider.ts
+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 BitcoinErrorCode = {
+  USER_REJECTED: 4001,
+  UNAUTHORIZED: 4100,
+  UNSUPPORTED_METHOD: 4200,
+  DISCONNECTED: 4900,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  INSUFFICIENT_FUNDS: 5001,
+  UTXO_NOT_FOUND: 5002
+};
+var BitcoinProviderError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "BitcoinProviderError";
+  }
+};
+var BITCOIN_NETWORKS = {
+  mainnet: {
+    name: "Bitcoin Mainnet",
+    type: "bitcoin",
+    explorer: "https://blockstream.info"
+  },
+  testnet: {
+    name: "Bitcoin Testnet",
+    type: "bitcoin_testnet",
+    explorer: "https://blockstream.info/testnet"
+  }
+};
+var AbcBitcoinProvider = class extends EventEmitter {
+  // 1 minute
+  constructor(client) {
+    super();
+    this.wallet = null;
+    this.network = BITCOIN_NETWORKS.testnet;
+    this.connected = false;
+    this.utxoCache = /* @__PURE__ */ new Map();
+    this.cacheExpiry = /* @__PURE__ */ new Map();
+    this.CACHE_TTL = 6e4;
+    this.client = client;
+  }
+  /**
+   * Set wallet information
+   */
+  setWallet(wallet) {
+    const previousAddress = this.wallet?.address;
+    this.wallet = wallet;
+    this.connected = true;
+    if (wallet.network === "bitcoin") {
+      this.network = BITCOIN_NETWORKS.mainnet;
+    } else {
+      this.network = BITCOIN_NETWORKS.testnet;
+    }
+    if (previousAddress !== wallet.address) {
+      this.emit("accountsChanged", [wallet.address]);
+      this.clearUtxoCache();
+    }
+    this.emit("connect", {
+      address: wallet.address,
+      network: this.network.type
+    });
+    console.log("[BitcoinProvider] \u2705 Wallet restored:", wallet.address);
+  }
+  /**
+   * Clear wallet (disconnect)
+   */
+  clearWallet() {
+    this.wallet = null;
+    this.connected = false;
+    this.clearUtxoCache();
+    this.emit("disconnect");
+    this.emit("accountsChanged", []);
+    console.log("[BitcoinProvider] \u{1F50C} Wallet disconnected");
+  }
+  /**
+   * Set PIN request callback for transaction signing
+   */
+  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 BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "PIN request callback not configured. Make sure RainbowKitProvider is rendered."
+      );
+    }
+    return this.requestPinCallback();
+  }
+  /**
+   * Set network
+   */
+  setNetwork(networkKey) {
+    const newNetwork = BITCOIN_NETWORKS[networkKey];
+    if (!newNetwork) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INVALID_PARAMS,
+        `Unknown network: ${networkKey}`
+      );
+    }
+    const previousType = this.network.type;
+    this.network = newNetwork;
+    if (previousType !== newNetwork.type) {
+      this.emit("networkChanged", newNetwork.type);
+      this.clearUtxoCache();
+    }
+  }
+  /**
+   * Get current network
+   */
+  getNetwork() {
+    return this.network;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected && this.wallet !== null;
+  }
+  /**
+   * Get Bitcoin address
+   */
+  async getAddress() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.address;
+  }
+  /**
+   * Get compressed public key (33 bytes)
+   */
+  async getPublicKey() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.publicKey;
+  }
+  /**
+   * Get address type (bech32, p2pkh, etc.)
+   */
+  getAddressType() {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    return this.wallet.addressType;
+  }
+  /**
+   * Clear UTXO cache
+   */
+  clearUtxoCache() {
+    this.utxoCache.clear();
+    this.cacheExpiry.clear();
+  }
+  /**
+   * Check if cache is valid
+   */
+  isCacheValid(address) {
+    const expiry = this.cacheExpiry.get(address);
+    if (!expiry)
+      return false;
+    return Date.now() < expiry;
+  }
+  /**
+   * Get UTXOs for address (with caching)
+   */
+  async getUtxos(forceRefresh = false) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    const address = this.wallet.address;
+    if (!forceRefresh && this.isCacheValid(address)) {
+      const cached = this.utxoCache.get(address);
+      if (cached) {
+        console.log(
+          `[BitcoinProvider] \u{1F4E6} Using cached UTXOs (${cached.length} items)`
+        );
+        return cached;
+      }
+    }
+    try {
+      console.log("[BitcoinProvider] \u{1F50D} Fetching UTXOs from network...");
+      const utxos = await this.client.bitcoin.getUtxos(
+        address,
+        this.network.type
+      );
+      this.utxoCache.set(address, utxos);
+      this.cacheExpiry.set(address, Date.now() + this.CACHE_TTL);
+      console.log(`[BitcoinProvider] \u2705 Fetched ${utxos.length} UTXOs`);
+      return utxos;
+    } catch (error) {
+      console.error(
+        "[BitcoinProvider] \u274C Failed to fetch UTXOs:",
+        error.message
+      );
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to fetch UTXOs",
+        error
+      );
+    }
+  }
+  /**
+   * Get total balance (sum of all UTXOs)
+   * Returns balance in satoshis
+   */
+  async getBalance(forceRefresh = false) {
+    const utxos = await this.getUtxos(forceRefresh);
+    const balance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+    console.log(
+      `[BitcoinProvider] \u{1F4B0} Balance: ${balance} satoshis (${balance / 1e8} BTC)`
+    );
+    return balance;
+  }
+  /**
+   * Estimate transaction fee
+   * Returns fee rate in satoshis per byte
+   */
+  async estimateFee(targetBlocks = 6) {
+    try {
+      const feeRate = await this.client.bitcoin.estimateFee(
+        this.network.type,
+        targetBlocks
+      );
+      console.log(`[BitcoinProvider] \u26FD Fee rate: ${feeRate} sat/byte`);
+      return feeRate;
+    } catch (_error) {
+      console.error("[BitcoinProvider] \u26A0\uFE0F Fee estimation failed, using default");
+      return 1;
+    }
+  }
+  /**
+   * Sign Bitcoin message (BIP-322)
+   * NOTE: Currently not supported - Bitcoin uses v2 API which doesn't have message signing endpoint
+   * Only transaction signing is supported via PSBT
+   *
+   * @param _message - Message to sign (string) - unused, always throws error
+   * @returns Signature in base64 format
+   */
+  async signMessage(_message) {
+    console.log("[BitcoinProvider] \u26A0\uFE0F Bitcoin message signing requested");
+    throw new BitcoinProviderError(
+      BitcoinErrorCode.UNSUPPORTED_METHOD,
+      "Bitcoin message signing is not supported. Bitcoin uses v2 API which only supports transaction signing (PSBT). Use signTransaction() instead."
+    );
+  }
+  /**
+   * High-level transaction sending (like Solana pattern)
+   * Creates, signs, and broadcasts transaction
+   *
+   * @param params - Transaction parameters
+   * @param params.toAddress - Recipient Bitcoin address
+   * @param params.amount - Amount in BTC (will be converted to satoshis)
+   * @returns Transaction hash
+   */
+  async sendTransaction(params) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      console.log("[BitcoinProvider] \u{1F4B8} Starting high-level transaction...");
+      const authStateKey = "talkenkit_abc_auth_state";
+      const authState = typeof window !== "undefined" ? localStorage.getItem(authStateKey) : null;
+      if (!authState) {
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.UNAUTHORIZED,
+          "Not authenticated - auth state not found"
+        );
+      }
+      const parsed = JSON.parse(authState);
+      const evmWallet = parsed.wallet;
+      if (!evmWallet?.uid || !evmWallet?.sid || !evmWallet?.pvencstr || !evmWallet?.wid) {
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.UNAUTHORIZED,
+          "EVM wallet data not found (required for Bitcoin signing)"
+        );
+      }
+      console.log(
+        "[BitcoinProvider] \u{1F510} Requesting PIN for Bitcoin transaction..."
+      );
+      const pin = await this.requestPin();
+      const encoder = new TextEncoder();
+      const data = encoder.encode(pin);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const pinHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+      const satoshis = Math.floor(params.amount * 1e8);
+      const SecureService = (await import("./abcWallet/secure.js")).default;
+      const secureService = new SecureService(this.client.bitcoin.getBaseURL());
+      const walletData = {
+        address: evmWallet.address,
+        keyId: evmWallet.keyId,
+        encryptedShare: evmWallet.encryptedShare,
+        uid: evmWallet.uid,
+        sid: evmWallet.sid,
+        wid: evmWallet.wid,
+        pvencstr: evmWallet.pvencstr,
+        encryptDevicePassword: evmWallet.encryptDevicePassword,
+        pubkey: evmWallet.pubkey
+      };
+      const txHash = await this.client.bitcoin.sendTransaction(
+        {
+          amount: satoshis.toString(),
+          to: params.toAddress,
+          pubkey: this.wallet.publicKey,
+          network: this.network.type
+        },
+        walletData,
+        pinHash,
+        secureService
+      );
+      console.log("[BitcoinProvider] \u2705 Transaction complete:", txHash);
+      this.emit("transactionBroadcasted", {
+        txHash,
+        explorerUrl: `${this.network.explorer}/tx/${txHash}`
+      });
+      this.clearUtxoCache();
+      return txHash;
+    } catch (error) {
+      if (error.message?.includes("cancelled") || error.message?.includes("rejected")) {
+        console.log("[BitcoinProvider] \u2139\uFE0F User cancelled transaction");
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.USER_REJECTED,
+          "User rejected transaction",
+          error
+        );
+      }
+      console.error("[BitcoinProvider] \u274C Transaction failed:", error.message);
+      if (error.message?.includes("insufficient")) {
+        throw new BitcoinProviderError(
+          BitcoinErrorCode.INSUFFICIENT_FUNDS,
+          "Insufficient BTC balance",
+          error
+        );
+      }
+      this.emit("error", error);
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to send transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Broadcast signed transaction to network
+   *
+   * @param rawTransaction - Raw transaction in hex format
+   * @param psbt - Optional finalized PSBT
+   * @returns Transaction hash
+   */
+  async broadcastTransaction(rawTransaction, psbt) {
+    if (!this.wallet) {
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.DISCONNECTED,
+        "Wallet not connected"
+      );
+    }
+    try {
+      console.log("[BitcoinProvider] \u{1F4E1} Broadcasting transaction...");
+      const result = await this.client.bitcoin.sendBitcoinTransaction({
+        network: this.network.type,
+        rawTransaction,
+        ...psbt && { psbt }
+      });
+      console.log(
+        "[BitcoinProvider] \u2705 Transaction broadcasted:",
+        result.txHash
+      );
+      this.emit("transactionBroadcasted", {
+        txHash: result.txHash,
+        explorerUrl: `${this.network.explorer}/tx/${result.txHash}`
+      });
+      this.clearUtxoCache();
+      return result.txHash;
+    } catch (error) {
+      console.error(
+        "[BitcoinProvider] \u274C Transaction broadcast failed:",
+        error.message
+      );
+      this.emit("error", error);
+      throw new BitcoinProviderError(
+        BitcoinErrorCode.INTERNAL_ERROR,
+        "Failed to broadcast transaction",
+        error
+      );
+    }
+  }
+  /**
+   * Get wallet info
+   */
+  getWalletInfo() {
+    if (!this.wallet)
+      return null;
+    return {
+      address: this.wallet.address,
+      publicKey: this.wallet.publicKey,
+      addressType: this.wallet.addressType,
+      network: this.network.type
+    };
+  }
+  /**
+   * Refresh UTXO cache
+   */
+  async refreshUtxos() {
+    return this.getUtxos(true);
+  }
+};
+
+export {
+  BitcoinProviderError,
+  BITCOIN_NETWORKS,
+  AbcBitcoinProvider
+};