mainnet-js 3.1.7 → 4.0.0-next.2

package/src/network/configuration.test.ts

@@ -1,4 +1,5 @@
 import { Network } from "../interface";
+import { Wallet } from "../wallet/Wif";
 import * as config from "./configuration";
 import * as primary from "./constant";
 
@@ -15,11 +16,11 @@ test("Should get electrum settings from defaults", async () => {
 });
 
 test("Should get electrum settings from DefaultProvider", async () => {
-  config.DefaultProvider.servers.mainnet = ["wss://example.com:777"];
+  config.DefaultProvider.servers.mainnet = "wss://example.com:777";
 
-  expect(config.getDefaultServers(Network.MAINNET)).toStrictEqual([
-    "wss://example.com:777",
-  ]);
+  expect(config.getDefaultServers(Network.MAINNET)).toBe(
+    "wss://example.com:777"
+  );
   expect(config.getDefaultServers(Network.TESTNET)).toBe(
     primary.testnetServers
   );
@@ -27,33 +28,30 @@ test("Should get electrum settings from DefaultProvider", async () => {
     primary.regtestServers
   );
 
-  config.DefaultProvider.servers.mainnet = [];
+  config.DefaultProvider.servers.mainnet = "";
 });
 
 test("Should get electrum settings from env", async () => {
-  process.env.ELECTRUM = "https://example.com:1234";
+  process.env.ELECTRUM = "wss://example.com:1234";
   process.env.ELECTRUM_TESTNET =
-    "https://test.example.com:1234,https://test.example.dk:1234";
+    "fallback(wss://test.example.com:1234,wss://test.example.dk:1234)";
   process.env.ELECTRUM_REGTEST = "ws://reg.example.com:1234";
-  expect(config.getDefaultServers(Network.MAINNET)).toStrictEqual([
-    "https://example.com:1234",
-  ]);
-  expect(config.getDefaultServers(Network.TESTNET)).toStrictEqual([
-    "https://test.example.com:1234",
-    "https://test.example.dk:1234",
-  ]);
-  expect(config.getDefaultServers(Network.REGTEST)).toStrictEqual([
-    "ws://reg.example.com:1234",
-  ]);
+  expect(config.getDefaultServers(Network.MAINNET)).toBe(
+    "wss://example.com:1234"
+  );
+  expect(config.getDefaultServers(Network.TESTNET)).toBe(
+    "fallback(wss://test.example.com:1234,wss://test.example.dk:1234)"
+  );
+  expect(config.getDefaultServers(Network.REGTEST)).toBe(
+    "ws://reg.example.com:1234"
+  );
 });
 
-test("Should get electrum cluster confidence from defaults", async () => {
-  let c = config.getConfidence();
-  expect(c).toStrictEqual(1);
-});
+test("Should get electrum settings from env, comma separated", async () => {
+  process.env.ELECTRUM =
+    "wss://bch.imaginary.cash:50004,wss://electrum.imaginary.cash:50004";
 
-test("Should get electrum cluster confidence from env", async () => {
-  process.env.ELECTRUM_CONFIDENCE = "2";
-  let c = config.getConfidence();
-  expect(c).toStrictEqual(2);
+  const wallet = await Wallet.newRandom();
+  expect(await wallet.getBalance()).toBe(0n);
+  await wallet.provider!.disconnect();
 });

package/src/network/configuration.ts

@@ -2,19 +2,24 @@ import { Network } from "../interface.js";
 import { getRuntimePlatform } from "../util/index.js";
 import * as primary from "./constant.js";
 
-let mainnetServers: string[],
-  testnetServers: string[],
-  regtestServers: string[];
-
 export class DefaultProvider {
-  static servers: { [name: string]: string[] } = {
-    mainnet: [] as string[],
-    testnet: [] as string[],
-    regtest: [] as string[],
+  static servers: { [name: string]: string } = {
+    mainnet: "",
+    testnet: "",
+    regtest: "",
   };
 }
 
-export function getDefaultServers(network: Network) {
+// Detect plain comma-separated URLs (not already in parse notation like "fallback(...)") and convert
+function normalizeServers(value: string): string {
+  if (!value) return value;
+  // Already parse notation (contains parens) or a single URL — pass through
+  if (value.includes("(") || !value.includes(",")) return value;
+  // Plain comma-separated URLs: convert to parse notation with fallback
+  return primary.toParseNotation(value.split(",").map((s) => s.trim()));
+}
+
+export function getDefaultServers(network: Network): string {
   let env: any;
   if (getRuntimePlatform() == "node") {
     env = process.env;
@@ -22,51 +27,20 @@ export function getDefaultServers(network: Network) {
     env = {};
   }
 
-  mainnetServers = DefaultProvider.servers.mainnet.length
-    ? DefaultProvider.servers.mainnet
-    : env.ELECTRUM
-    ? env.ELECTRUM.split(",")
-    : primary.mainnetServers;
-  testnetServers = DefaultProvider.servers.testnet.length
-    ? DefaultProvider.servers.testnet
-    : env.ELECTRUM_TESTNET
-    ? env.ELECTRUM_TESTNET.split(",")
-    : primary.testnetServers;
-  regtestServers = DefaultProvider.servers.regtest.length
-    ? DefaultProvider.servers.regtest
-    : env.ELECTRUM_REGTEST
-    ? env.ELECTRUM_REGTEST.split(",")
-    : primary.regtestServers;
-
-  return {
-    mainnet: mainnetServers,
-    testnet: testnetServers,
-    regtest: regtestServers,
-  }[network];
-}
-
-export function getUserAgent() {
-  // Allow users to configure the cluster confidence
-  let ua;
-  if (getRuntimePlatform() === "node") {
-    ua = process.env.ELECTRUM_USER_AGENT
-      ? process.env.ELECTRUM_USER_AGENT
-      : "mainnet-js-" + getRuntimePlatform();
-  } else {
-    ua = "mainnet-js-" + getRuntimePlatform();
-  }
-  return ua;
-}
+  const servers = {
+    mainnet:
+      DefaultProvider.servers.mainnet ||
+      normalizeServers(env.ELECTRUM) ||
+      primary.mainnetServers,
+    testnet:
+      DefaultProvider.servers.testnet ||
+      normalizeServers(env.ELECTRUM_TESTNET) ||
+      primary.testnetServers,
+    regtest:
+      DefaultProvider.servers.regtest ||
+      normalizeServers(env.ELECTRUM_REGTEST) ||
+      primary.regtestServers,
+  };
 
-export function getConfidence() {
-  // Allow users to configure the cluster confidence
-  let confidence;
-  if (getRuntimePlatform() === "node") {
-    confidence = process.env.ELECTRUM_CONFIDENCE
-      ? parseInt(process.env.ELECTRUM_CONFIDENCE)
-      : 1;
-  } else {
-    confidence = 1;
-  }
-  return confidence;
+  return servers[network];
 }

package/src/network/constant.ts

@@ -1,40 +1,35 @@
-export const ELECTRUM_CASH_PROTOCOL_VERSION = "1.5";
-
 export const networkTickerMap = {
   mainnet: "BCH",
   testnet: "tBCH",
   regtest: "rBCH",
 };
 
-export const mainnetServers = [
-  // "wss://bch.imaginary.cash:50004",
-  "wss://blackie.c3-soft.com:50004",
-  // "wss://electrum.imaginary.cash:50004",
-  // "wss://fulcrum.fountainhead.cash",
-];
+const opts =
+  "connectTimeout=5000&timeout=5000&keepAlive=60000&protocolVersion=1.6&batchSize=5";
 
-// export const testnetServers = [
-//   // "wss://tbch.loping.net:60004",
-//   "wss://blackie.c3-soft.com:60004",
-//   // "wss://testnet.bitcoincash.network:60004",
-//   //,"wss://unavailable.invalid:50004"
-// ];
+export function toParseNotation(urls: string[]): string {
+  const withOpts = urls.map((u) => `${u}?${opts}`);
+  if (withOpts.length === 1) return withOpts[0];
+  return `fallback(${withOpts.join(",")})?eagerConnect=true&rank=true`;
+}
 
-// testnet4
-// export const testnetServers = [
-//   //"wss://t4fork.c3-soft.com:61004",
-//   "wss://testnet4.imaginary.cash:50004",
-//   //,"wss://unavailable.invalid:50004"
-// ];
+export const mainnetServers = toParseNotation([
+  "wss://bch.imaginary.cash:50004",
+  "wss://electrum.imaginary.cash:50004",
+  "wss://fulcrum.pat.mn:50004",
+]);
 
 // chipnet
-export const testnetServers = [
+export const testnetServers = toParseNotation([
+  "wss://chipnet.bch.ninja:50004",
   "wss://chipnet.imaginary.cash:50004",
-  //"wss://blackie.c3-soft.com:64004", // chipnet with protocol 1.5.0
-  // "wss://chipnet.bch.ninja:50004",
-];
+  "wss://chipnet.c3-soft.com:64004",
+]);
 
-export const regtestServers = ["ws://127.0.0.1:60003"];
+export const regtestServers = toParseNotation([
+  "ws://127.0.0.1:60003",
+  "ws://host.docker.internal:60003",
+]);
 
 export const defaultServers = {
   mainnet: mainnetServers,

package/src/network/default.ts

@@ -1,15 +1,14 @@
 import { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
-import { ElectrumClient } from "@electrum-cash/network";
-import { ElectrumWebSocket } from "@electrum-cash/web-socket";
 import { default as NetworkProvider } from "./NetworkProvider.js";
-import { getDefaultServers, getUserAgent } from "./configuration.js";
-import { parseElectrumUrl } from "./util.js";
-import { ElectrumHostParams } from "./interface.js";
+import { getDefaultServers } from "./configuration.js";
 import { Network } from "../interface.js";
-import {
-  networkTickerMap,
-  ELECTRUM_CASH_PROTOCOL_VERSION,
-} from "./constant.js";
+import { networkTickerMap } from "./constant.js";
+import type { ElectrumCashSchema } from "@rpckit/core/electrum-cash";
+import { createParseSync } from "@rpckit/core";
+import { webSocket } from "@rpckit/websocket/electrum-cash";
+import { fallback } from "@rpckit/fallback/electrum-cash";
+
+const parseSync = createParseSync({ webSocket, fallback });
 
 export function setGlobalProvider(
   network: Network,
@@ -34,87 +33,26 @@ export function removeGlobalProvider(network: Network): void {
   }
 }
 
-export function getNetworkProvider(
+export async function createProvider(
   network: Network = Network.MAINNET,
-  servers?: string[] | string,
-  manualConnectionManagement?: boolean,
-  options?: ElectrumHostParams
-): NetworkProvider {
-  const globalContext =
-    servers === undefined &&
-    manualConnectionManagement === undefined &&
-    options === undefined;
-  if (globalContext) {
-    const globalProvider = getGlobalProvider(network);
-    if (globalProvider) {
-      return globalProvider;
-    }
-  }
-
-  manualConnectionManagement = manualConnectionManagement
-    ? manualConnectionManagement
-    : false;
-  servers = servers ? servers : getDefaultServers(network);
-  // If the user has passed a single string, assume a single client connection
-  if (typeof servers === "string") {
-    servers = [servers as string];
-  }
-
-  // There were server(s)
-  if (servers) {
-    const client = getClient(servers[0], network, options);
-    let provider = new ElectrumNetworkProvider(
-      client,
-      network,
-      manualConnectionManagement
-    );
-
-    if (globalContext) {
-      return setGlobalProvider(network, provider);
-    }
-
-    return provider;
-  } else {
-    throw Error("No servers provided, defaults not available.");
-  }
-}
-
-// 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);
+  servers?: string
+): Promise<ElectrumNetworkProvider> {
+  const serverStr = servers ?? getDefaultServers(network);
+  const transport = parseSync<ElectrumCashSchema>(serverStr);
+  return new ElectrumNetworkProvider(transport, network);
 }
 
-function getElectrumClient(
-  params: ElectrumHostParams,
-  timeout: number,
-  network: Network
-) {
-  if (params.scheme?.includes("tcp")) {
-    throw Error("TCP connections are not supported.");
+export function getNetworkProvider(
+  network: Network = Network.MAINNET
+): NetworkProvider {
+  const globalProvider = getGlobalProvider(network);
+  if (globalProvider) {
+    return globalProvider;
   }
 
-  const webSocket = new ElectrumWebSocket(
-    params.host,
-    params.port,
-    params.scheme === "wss",
-    timeout,
-    {
-      disableBrowserConnectivityHandling: true,
-      disableBrowserVisibilityHandling: true,
-    }
-  );
-  return new ElectrumClient(
-    getUserAgent(),
-    ELECTRUM_CASH_PROTOCOL_VERSION,
-    webSocket,
-    {
-      disableBrowserConnectivityHandling: true,
-      disableBrowserVisibilityHandling: true,
-    }
-  );
+  const serverStr = getDefaultServers(network);
+  const transport = parseSync<ElectrumCashSchema>(serverStr);
+  const provider = new ElectrumNetworkProvider(transport, network);
+  setGlobalProvider(network, provider);
+  return provider;
 }

package/src/network/electrum.test.ts

@@ -1,21 +1,19 @@
-import { ElectrumClient } from "@electrum-cash/network";
-import { getNetworkProvider } from ".";
+import { webSocket } from "@rpckit/websocket/electrum-cash";
+import { getNetworkProvider, createProvider } from ".";
 import { Network } from "../interface";
 
-test("Should get a transaction with bare electrum", async () => {
-  const electrum = new ElectrumClient(
-    "Electrum client example",
-    "1.4.1",
-    "bch.imaginary.cash"
-  );
-  await electrum.connect();
+test("Should get a transaction with bare rpckit transport", async () => {
+  const transport = webSocket("wss://fulcrum.pat.mn:50004");
+  await transport.connect();
   const transactionID =
     "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
-  const transactionHex = await electrum.request(
+  const transactionHex = await transport.request(
     "blockchain.transaction.get",
     transactionID
   );
-  await electrum.disconnect();
+  expect(typeof transactionHex).toBe("string");
+  expect((transactionHex as string).length).toBeGreaterThan(0);
+  await transport.close();
 });
 
 test("Should get a transaction with provider", async () => {
@@ -26,3 +24,41 @@ test("Should get a transaction with provider", async () => {
   //console.log(transactionHex);
   await provider.disconnect();
 });
+
+test("Should propagate electrum error for non-existent transaction", async () => {
+  const zeroTxId =
+    "0000000000000000000000000000000000000000000000000000000000000000";
+
+  // rpckit rejects with a plain object { code, message }, not an Error instance
+  const transport = webSocket("wss://fulcrum.pat.mn:50004");
+  await transport.connect();
+  try {
+    await transport.request("blockchain.transaction.get", zeroTxId);
+    fail("Expected request to throw");
+  } catch (error: any) {
+    expect(error.message).toContain(
+      "No such mempool or blockchain transaction"
+    );
+  } finally {
+    await transport.close();
+  }
+});
+
+test("Should throw user-friendly error for non-existent transaction via provider", async () => {
+  const zeroTxId =
+    "0000000000000000000000000000000000000000000000000000000000000000";
+  const provider = await createProvider(
+    Network.MAINNET,
+    "wss://fulcrum.pat.mn:50004"
+  );
+  try {
+    await provider.getRawTransaction(zeroTxId);
+    fail("Expected getRawTransaction to throw");
+  } catch (error: any) {
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toContain("Could not decode transaction");
+    expect(error.message).toContain("might not exist");
+  } finally {
+    await provider.disconnect();
+  }
+});

package/src/network/index.ts

@@ -1,6 +1,11 @@
-export { getNetworkProvider } from "./default.js";
 export {
-  Connection,
+  getNetworkProvider,
+  createProvider,
+  setGlobalProvider,
+  getGlobalProvider,
+  removeGlobalProvider,
+} from "./default.js";
+export {
   initProviders,
   initProvider,
   disconnectProviders,

package/src/network/interface.ts

@@ -5,13 +5,6 @@ export interface BlockHeader {
   hex: string;
 }
 
-export interface ElectrumHostParams {
-  host: string;
-  port: number;
-  timeout?: number;
-  scheme: "tcp" | "tcp_tls" | "ws" | "wss";
-}
-
 export interface ElectrumTokenData {
   amount: string;
   category: string;