mainnet-js 2.6.7 → 2.7.0

package/src/network/constant.ts

@@ -1,5 +1,3 @@
-import { ClusterOrder } from "electrum-cash";
-
 export const ELECTRUM_CASH_PROTOCOL_VERSION = "1.5";
 
 export const networkTickerMap = {
@@ -43,24 +41,3 @@ export const defaultServers = {
   testnet: testnetServers,
   regtest: regtestServers,
 };
-
-export const clusterParams = {
-  mainnet: {
-    confidence: 1,
-    distribution: 1,
-    order: ClusterOrder.RANDOM,
-    timeout: 45000,
-  },
-  testnet: {
-    confidence: 1,
-    distribution: 1,
-    order: ClusterOrder.RANDOM,
-    timeout: 30000,
-  },
-  regtest: {
-    confidence: 1,
-    distribution: 1,
-    order: ClusterOrder.PRIORITY,
-    timeout: 3000,
-  },
-};

package/src/network/default.ts

@@ -1,17 +1,13 @@
 import { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
-import { ElectrumCluster, ElectrumClient } from "electrum-cash";
+import { ElectrumClient } from "@electrum-cash/network";
+import { ElectrumWebSocket } from "@electrum-cash/web-socket";
 import { default as NetworkProvider } from "./NetworkProvider.js";
-import {
-  getConfidence,
-  getDefaultServers,
-  getUserAgent,
-} from "./configuration.js";
+import { getDefaultServers, getUserAgent } from "./configuration.js";
 import { parseElectrumUrl } from "./util.js";
-import { ElectrumHostParams, ElectrumClusterParams } from "./interface.js";
+import { ElectrumHostParams } from "./interface.js";
 import { Network } from "../interface.js";
 import {
   networkTickerMap,
-  clusterParams,
   ELECTRUM_CASH_PROTOCOL_VERSION,
 } from "./constant.js";
 
@@ -42,7 +38,7 @@ export function getNetworkProvider(
   network: Network = Network.MAINNET,
   servers?: string[] | string,
   manualConnectionManagement?: boolean,
-  options?: ElectrumClusterParams
+  options?: ElectrumHostParams
 ): NetworkProvider {
   const globalContext =
     servers === undefined &&
@@ -55,7 +51,6 @@ export function getNetworkProvider(
     }
   }
 
-  let useCluster;
   manualConnectionManagement = manualConnectionManagement
     ? manualConnectionManagement
     : false;
@@ -63,31 +58,13 @@ export function getNetworkProvider(
   // If the user has passed a single string, assume a single client connection
   if (typeof servers === "string") {
     servers = [servers as string];
-    useCluster = false;
-  }
-
-  // Otherwise, assume a list of servers has been passed
-  else {
-    servers = servers;
-    useCluster = servers.length > 1;
   }
 
   // There were server(s)
   if (servers) {
-    let clusterOrClient;
-    // There were multiple servers
-    if (useCluster) {
-      let clusterParam = clusterParams[network];
-      clusterParam["confidence"] = getConfidence();
-      clusterParam = Object.assign({}, clusterParam, options);
-      clusterOrClient = getCluster(servers, clusterParam, network);
-    }
-    // The server is a single string in an array
-    else {
-      clusterOrClient = getClient(servers, network);
-    }
+    const client = getClient(servers[0], network, options);
     let provider = new ElectrumNetworkProvider(
-      clusterOrClient,
+      client,
       network,
       manualConnectionManagement
     );
@@ -102,38 +79,14 @@ export function getNetworkProvider(
   }
 }
 
-// Create a cluster give a list of servers and parameters
-function getCluster(servers: string[], params, network: Network) {
-  let electrum = getElectrumCluster(params, network);
-
-  for (const s of servers) {
-    let url = parseElectrumUrl(s);
-    try {
-      electrum.addServer(url.host, url.port, url.scheme, false);
-    } catch (error) {
-      console.log(
-        `Error connecting ${url.host}:${url.port} over ${url.scheme}`
-      );
-    }
-  }
-  return electrum;
-}
-
-// create a client with a list of servers
-function getClient(servers: string[], network: Network) {
-  let url = parseElectrumUrl(servers[0]);
-  return getElectrumClient(url, 120000, network);
-}
-
-function getElectrumCluster(params: ElectrumClusterParams, network: Network) {
-  return new ElectrumCluster(
-    getUserAgent(),
-    ELECTRUM_CASH_PROTOCOL_VERSION,
-    params.confidence,
-    params.distribution,
-    params.order,
-    params.timeout
-  );
+// create a client with a server
+function getClient(
+  server: string,
+  network: Network,
+  options?: ElectrumHostParams
+) {
+  let url = parseElectrumUrl(server);
+  return getElectrumClient(url, options?.timeout ?? 120000, network);
 }
 
 function getElectrumClient(
@@ -141,12 +94,19 @@ function getElectrumClient(
   timeout: number,
   network: Network
 ) {
-  return new ElectrumClient(
-    getUserAgent(),
-    ELECTRUM_CASH_PROTOCOL_VERSION,
+  if (params.scheme?.includes("tcp")) {
+    throw Error("TCP connections are not supported.");
+  }
+
+  const webSocket = new ElectrumWebSocket(
     params.host,
     params.port,
-    params.scheme,
+    params.scheme === "wss",
     timeout
   );
+  return new ElectrumClient(
+    getUserAgent(),
+    ELECTRUM_CASH_PROTOCOL_VERSION,
+    webSocket
+  );
 }

package/src/network/electrum.test.ts

@@ -1,4 +1,4 @@
-import { ElectrumClient } from "electrum-cash";
+import { ElectrumClient } from "@electrum-cash/network";
 import { getNetworkProvider } from ".";
 import { Network } from "../interface";
 
@@ -6,9 +6,7 @@ test("Should get a transaction with bare electrum", async () => {
   const electrum = new ElectrumClient(
     "Electrum client example",
     "1.4.1",
-    "bch.imaginary.cash",
-    50004,
-    "wss"
+    "bch.imaginary.cash"
   );
   await electrum.connect();
   const transactionID =

package/src/network/interface.ts

@@ -1,4 +1,3 @@
-import { ClusterOrder } from "electrum-cash";
 import { NFTCapability } from "../interface.js";
 
 export interface BlockHeader {
@@ -9,14 +8,8 @@ export interface BlockHeader {
 export interface ElectrumHostParams {
   host: string;
   port: number;
-  scheme: "tcp" | "tcp_tls" | "ws" | "wss" | undefined;
-}
-
-export interface ElectrumClusterParams {
-  confidence: number;
-  distribution: number;
-  order: ClusterOrder;
-  timeout: number;
+  timeout?: number;
+  scheme: "tcp" | "tcp_tls" | "ws" | "wss";
 }
 
 export interface ElectrumTokenData {

package/src/network/util.ts

@@ -1,4 +1,3 @@
-import { ElectrumTransport, TransportScheme } from "electrum-cash";
 import { ElectrumHostParams } from "./interface.js";
 
 export function parseElectrumUrl(givenUrl: string): ElectrumHostParams {
@@ -10,22 +9,22 @@ export function parseElectrumUrl(givenUrl: string): ElectrumHostParams {
 }
 
 function getElectrumScheme(protocol: string) {
-  let transport: TransportScheme;
+  let transport: string;
   switch (protocol) {
     case "http:":
-      transport = ElectrumTransport.TCP.Scheme;
+      transport = "tcp";
       break;
     case "https:":
-      transport = ElectrumTransport.TCP_TLS.Scheme;
+      transport = "tcp_tls";
       break;
     case "ws:":
-      transport = ElectrumTransport.WS.Scheme;
+      transport = "ws";
       break;
     case "wss:":
-      transport = ElectrumTransport.WSS.Scheme;
+      transport = "wss";
       break;
     default:
       throw Error("Electrum transport protocol not understood.");
   }
-  return transport as "tcp" | "tcp_tls" | "ws" | "wss" | undefined;
+  return transport as "tcp" | "tcp_tls" | "ws" | "wss";
 }

package/src/rate/ExchangeRate.test.ts

@@ -35,7 +35,7 @@ describe("Exchange rate tests", () => {
     const bob = await RegTestWallet.newRandom();
     const balance = (await alice.getBalance()) as BalanceResponse;
     let cbCounter = 0;
-    const cancelWatchFn = alice.watchBalanceUsd(async (newBalance) => {
+    const cancelWatchFn = await alice.watchBalanceUsd(async (newBalance) => {
       cbCounter++;
       if (cbCounter === 1) {
         expect(newBalance.usd!).toBeGreaterThan(balance.usd!);

package/src/rate/ExchangeRate.ts

@@ -130,4 +130,5 @@ export async function getRateFromExchange(symbol: string): Promise<number> {
   throw Error(`Currency '${symbol}' is not supported.`);
 }
 
-await ExchangeRate.get("usd");
+// do not await and do not throw in case we are offline
+ExchangeRate.get("usd").catch(() => {});

package/{polyfill/json.js → src/test/json.test.ts}

@@ -1,7 +1,13 @@
-const json = (param) => {
+export const json = (param: any) => {
   return JSON.stringify(
     param,
     (key, value) => (typeof value === "bigint" ? value.toString() : value) // return everything else unchanged
   );
 };
 export default json;
+
+describe("json tests", () => {
+  test("Should serialize bigint", async () => {
+    expect(json(1n)).toBe('"1"');
+  });
+});

package/src/transaction/Wif.ts

@@ -107,7 +107,8 @@ export async function buildP2pkhNonHdTransaction({
 
   const tokenValidationResult = verifyTransactionTokens(
     result.transaction,
-    sourceOutputs
+    sourceOutputs,
+    { maximumTokenCommitmentLength: 40 }
   );
   if (tokenValidationResult !== true && fee > 0) {
     throw tokenValidationResult;