mainnet-js 3.1.7 → 4.0.0-next.10

package/src/network/NetworkProvider.ts

@@ -1,180 +0,0 @@
-import { TxI, Utxo, Network, HexHeaderI, HeaderI } from "../interface.js";
-import {
-  ElectrumRawTransaction,
-  ElectrumRawTransactionWithInputValues,
-} from "./interface.js";
-import { CancelFn } from "../wallet/interface.js";
-
-export default interface NetworkProvider {
-  /**
-   * Variable indicating the network that this provider connects to.
-   */
-  network: Network;
-
-  /**
-   * Retrieve all UTXOs (confirmed and unconfirmed) for a given address.
-   * @param cashaddr The CashAddress for which we wish to retrieve UTXOs.
-   * @returns List of UTXOs spendable by the provided address.
-   */
-  getUtxos(cashaddr: string): Promise<Utxo[]>;
-
-  /**
-   * Retrieve all balance of an address in satoshi
-   * @param cashaddr The CashAddress for which we wish to retrieve UTXOs.
-   * @returns the balance.
-   */
-  getBalance(cashaddr: string): Promise<bigint>;
-
-  /**
-   * @returns The block header fetched at blockheight @param height.
-   * @param verbose steers the response type. If true, a verbose response is returned.
-   */
-  getHeader(height: number, verbose: boolean): Promise<HeaderI | HexHeaderI>;
-
-  /**
-   * @returns The current block height.
-   */
-  getBlockHeight(): Promise<number>;
-
-  /**
-   * @returns The current minimum relay fee per kb
-   */
-  getRelayFee(): Promise<number>;
-
-  /**
-   * Retrieve transaction details for a given transaction ID.
-   * @param txHash Hex of transaction hash.
-   * @param verbose When true, returns a decoded transaction object instead of hex.
-   * @param loadInputValues When true (requires verbose), each vin is enriched with value, address and tokenData from the parent output.
-   * @throws {Error} If the transaction does not exist
-   * @returns The hex string (non-verbose) or decoded transaction object (verbose).
-   */
-  getRawTransaction(
-    txHash: string,
-    verbose: true,
-    loadInputValues: true
-  ): Promise<ElectrumRawTransactionWithInputValues>;
-  getRawTransaction(
-    txHash: string,
-    verbose: true,
-    loadInputValues?: false
-  ): Promise<ElectrumRawTransaction>;
-  getRawTransaction(
-    txHash: string,
-    verbose?: false,
-    loadInputValues?: false
-  ): Promise<string>;
-  getRawTransaction(
-    txHash: string,
-    verbose?: boolean,
-    loadInputValues?: boolean
-  ): Promise<
-    string | ElectrumRawTransaction | ElectrumRawTransactionWithInputValues
-  >;
-
-  /**
-   * Batch retrieve raw transactions by their hashes.
-   * @param hashes Array of transaction hashes.
-   * @returns Map from hash to hex transaction string.
-   */
-  getRawTransactions(hashes: string[]): Promise<Map<string, string>>;
-
-  /**
-   * Batch retrieve block headers by their heights.
-   * @param heights Array of block heights.
-   * @returns Map from height to decoded header.
-   */
-  getHeaders(heights: number[]): Promise<Map<number, HeaderI>>;
-
-  /**
-   * Retrieve a verbose coin-specific response transaction details for a given transaction ID.
-   * @param txHash Hex of transaction hash.
-   * @param loadInputValues When true, each vin is enriched with value, address and tokenData from the parent output.
-   * @throws {Error} If the transaction does not exist
-   * @returns The decoded transaction object.
-   */
-  getRawTransactionObject(
-    txHash: string,
-    loadInputValues: true
-  ): Promise<ElectrumRawTransactionWithInputValues>;
-  getRawTransactionObject(
-    txHash: string,
-    loadInputValues?: false
-  ): Promise<ElectrumRawTransaction>;
-  getRawTransactionObject(
-    txHash: string,
-    loadInputValues?: boolean
-  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues>;
-
-  /**
-   * Broadcast a raw hex transaction to the Bitcoin Cash network.
-   * @param txHex The raw transaction hex to be broadcast.
-   * @param awaitPropagation Wait for transaction to be registered in the bitcoind or indexer. If set to false, function returns computed transaction hash immediately.
-   * @throws {Error} If the transaction was not accepted by the network.
-   * @returns The transaction ID (hash) corresponding to the broadcast transaction.
-   */
-  sendRawTransaction(
-    txHex: string,
-    awaitPropagation?: boolean
-  ): Promise<string>;
-
-  /**
-   * Return the confirmed and unconfirmed history of a Bitcoin Cash address.
-   * @param cashaddr The CashAddress for which we wish to retrieve history.
-   * @throws {Error} When failing to get history.
-   * @returns Array of transactions.
-   */
-  getHistory(
-    cashaddr: string,
-    fromHeight?: number,
-    toHeight?: number
-  ): Promise<TxI[]>;
-
-  /**
-   * Wait for the next block or a block at given blockchain height.
-   * @param height If specified, waits for blockchain to reach this height.
-   * @returns Block header.
-   */
-  waitForBlock(height?: number): Promise<HexHeaderI>;
-
-  /**
-   * Subscribe to the address change events
-   * @param cashaddr The CashAddress for which we wish to retrieve history.
-   * @throws {Error} If the subscription failed.
-   * @returns nothing.
-   */
-  subscribeToAddress(
-    cashaddr: string,
-    callback: (data: any) => void
-  ): Promise<CancelFn>;
-
-  /**
-   * Subscribe to a transaction in order to receive future notifications if its confirmation status changes.
-   * @param txHash The transaction hash as a hexadecimal string.
-   * @throws {Error} If the subscription failed.
-   * @returns nothing.
-   */
-  subscribeToTransaction(
-    txHash: string,
-    callback: (data: any) => void
-  ): Promise<CancelFn>;
-
-  /**
-   * Function to wait for connection to be ready
-   * @param timeout number of milliseconds to wait before throwing error
-   * @returns true when ready, or an error
-   */
-  ready(timeout?: number): Promise<boolean | unknown>;
-
-  /**
-   * Function to connect manually if using persistent connection
-   * @returns a promise resolving when the connection is established.
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Function to disconnect manually if using persistent connection
-   * @returns true if successfully disconnected, or false if there was no connection
-   */
-  disconnect(): Promise<boolean>;
-}

package/src/network/Rpc.test.ts

@@ -1,130 +0,0 @@
-import { disconnectProviders, initProviders } from "./Connection";
-import { RegTestWallet } from "../wallet/Wif";
-import { getNetworkProvider } from "../network/default";
-import { mine } from "../mine";
-import { Network } from "../interface";
-
-const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
-
-beforeAll(async () => {
-  await initProviders();
-});
-
-afterAll(async () => {
-  await disconnectProviders();
-});
-
-describe("Rpc tests", () => {
-  test("get utxos", async () => {
-    const provider = getNetworkProvider(Network.REGTEST);
-    expect(
-      await provider.getUtxos(
-        "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0"
-      )
-    ).not.toHaveLength(0);
-  });
-
-  test("subcribe to address", async () => {
-    const provider = getNetworkProvider(Network.REGTEST);
-    try {
-      await provider.subscribeToAddress(
-        "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0",
-        async (data) => {
-          expect(data).not.toBe("");
-        }
-      );
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    } catch (e: any) {
-      console.log(e, e.message, e.stack);
-    }
-  });
-
-  test("subcribe to muliple addresses bug", async () => {
-    const provider = getNetworkProvider(Network.REGTEST);
-
-    try {
-      await provider.subscribeToAddress(
-        "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0",
-        async (data) => {
-          // console.log("First", data);
-          expect(data).not.toBe("");
-          data;
-        }
-      );
-
-      await provider.subscribeToAddress(
-        "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0",
-        async (data) => {
-          // console.log("Second", data);
-          expect(data).not.toBe("");
-          data;
-        }
-      );
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    } catch (e: any) {
-      console.log(e, e.message, e.stack);
-    }
-  });
-
-  test("Watch wallet balance", async () => {
-    const aliceWallet = await RegTestWallet.fromId(aliceWif);
-
-    let result = false;
-    aliceWallet.watchBalance((balance) => {
-      expect(balance).toBeGreaterThan(0);
-      result = true;
-      // stop watching
-      return true;
-    });
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    // we do not trigger the callback upon subscription anymore
-    expect(result).toBe(true);
-  });
-
-  test("Wait for block timeout", async () => {
-    const provider = getNetworkProvider(Network.REGTEST);
-    let promiseResult;
-    const timeout = new Promise((resolve) =>
-      setTimeout(resolve, 1000, "timeout")
-    );
-    await Promise.race([provider.waitForBlock(), timeout]).then(
-      (result) => (promiseResult = result)
-    );
-    expect(promiseResult).toBe("timeout");
-  });
-
-  test("Wait for block success", async () => {
-    const provider = getNetworkProvider(Network.REGTEST);
-
-    const aliceWallet = await RegTestWallet.fromId(aliceWif);
-    const bobWallet = await RegTestWallet.newRandom();
-    const minerWallet = await RegTestWallet.newRandom();
-
-    await aliceWallet.send([
-      {
-        cashaddr: bobWallet.cashaddr!,
-        value: 1000n,
-      },
-    ]);
-
-    const height = await provider.getBlockHeight();
-
-    setTimeout(
-      async () => await mine({ cashaddr: minerWallet.cashaddr!, blocks: 1 }),
-      2000
-    );
-
-    let header = await provider.waitForBlock();
-    expect(header.height).toBe(height + 1);
-
-    setTimeout(
-      async () => await mine({ cashaddr: minerWallet.cashaddr!, blocks: 1 }),
-      2000
-    );
-
-    header = await provider.waitForBlock(height + 2);
-    expect(header.height).toBe(height + 2);
-  }, 20000);
-});

package/src/network/configuration.test.ts

@@ -1,59 +0,0 @@
-import { Network } from "../interface";
-import * as config from "./configuration";
-import * as primary from "./constant";
-
-test("Should get electrum settings from defaults", async () => {
-  expect(config.getDefaultServers(Network.MAINNET)).toBe(
-    primary.mainnetServers
-  );
-  expect(config.getDefaultServers(Network.TESTNET)).toBe(
-    primary.testnetServers
-  );
-  expect(config.getDefaultServers(Network.REGTEST)).toBe(
-    primary.regtestServers
-  );
-});
-
-test("Should get electrum settings from DefaultProvider", async () => {
-  config.DefaultProvider.servers.mainnet = ["wss://example.com:777"];
-
-  expect(config.getDefaultServers(Network.MAINNET)).toStrictEqual([
-    "wss://example.com:777",
-  ]);
-  expect(config.getDefaultServers(Network.TESTNET)).toBe(
-    primary.testnetServers
-  );
-  expect(config.getDefaultServers(Network.REGTEST)).toBe(
-    primary.regtestServers
-  );
-
-  config.DefaultProvider.servers.mainnet = [];
-});
-
-test("Should get electrum settings from env", async () => {
-  process.env.ELECTRUM = "https://example.com:1234";
-  process.env.ELECTRUM_TESTNET =
-    "https://test.example.com:1234,https://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",
-  ]);
-});
-
-test("Should get electrum cluster confidence from defaults", async () => {
-  let c = config.getConfidence();
-  expect(c).toStrictEqual(1);
-});
-
-test("Should get electrum cluster confidence from env", async () => {
-  process.env.ELECTRUM_CONFIDENCE = "2";
-  let c = config.getConfidence();
-  expect(c).toStrictEqual(2);
-});

package/src/network/configuration.ts

@@ -1,72 +0,0 @@
-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[],
-  };
-}
-
-export function getDefaultServers(network: Network) {
-  let env: any;
-  if (getRuntimePlatform() == "node") {
-    env = process.env;
-  } else {
-    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;
-}
-
-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;
-}

package/src/network/constant.ts

@@ -1,43 +0,0 @@
-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",
-];
-
-// export const testnetServers = [
-//   // "wss://tbch.loping.net:60004",
-//   "wss://blackie.c3-soft.com:60004",
-//   // "wss://testnet.bitcoincash.network:60004",
-//   //,"wss://unavailable.invalid:50004"
-// ];
-
-// testnet4
-// export const testnetServers = [
-//   //"wss://t4fork.c3-soft.com:61004",
-//   "wss://testnet4.imaginary.cash:50004",
-//   //,"wss://unavailable.invalid:50004"
-// ];
-
-// chipnet
-export const testnetServers = [
-  "wss://chipnet.imaginary.cash:50004",
-  //"wss://blackie.c3-soft.com:64004", // chipnet with protocol 1.5.0
-  // "wss://chipnet.bch.ninja:50004",
-];
-
-export const regtestServers = ["ws://127.0.0.1:60003"];
-
-export const defaultServers = {
-  mainnet: mainnetServers,
-  testnet: testnetServers,
-  regtest: regtestServers,
-};

package/src/network/default.ts

@@ -1,120 +0,0 @@
-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 { Network } from "../interface.js";
-import {
-  networkTickerMap,
-  ELECTRUM_CASH_PROTOCOL_VERSION,
-} from "./constant.js";
-
-export function setGlobalProvider(
-  network: Network,
-  provider: NetworkProvider
-): NetworkProvider {
-  const accessor = networkTickerMap[network];
-  globalThis[accessor] = provider;
-  return provider;
-}
-
-export function getGlobalProvider(
-  network: Network
-): NetworkProvider | undefined {
-  const accessor = networkTickerMap[network];
-  return globalThis[accessor];
-}
-
-export function removeGlobalProvider(network: Network): void {
-  const accessor = networkTickerMap[network];
-  if (accessor in globalThis) {
-    delete globalThis[accessor];
-  }
-}
-
-export function getNetworkProvider(
-  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);
-}
-
-function getElectrumClient(
-  params: ElectrumHostParams,
-  timeout: number,
-  network: Network
-) {
-  if (params.scheme?.includes("tcp")) {
-    throw Error("TCP connections are not supported.");
-  }
-
-  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,
-    }
-  );
-}

package/src/network/electrum.test.ts

@@ -1,28 +0,0 @@
-import { ElectrumClient } from "@electrum-cash/network";
-import { getNetworkProvider } 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();
-  const transactionID =
-    "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
-  const transactionHex = await electrum.request(
-    "blockchain.transaction.get",
-    transactionID
-  );
-  await electrum.disconnect();
-});
-
-test("Should get a transaction with provider", async () => {
-  const provider = getNetworkProvider(Network.MAINNET);
-  const transactionID =
-    "4db095f34d632a4daf942142c291f1f2abb5ba2e1ccac919d85bdc2f671fb251";
-  const transactionHex = await provider.getRawTransaction(transactionID);
-  //console.log(transactionHex);
-  await provider.disconnect();
-});

package/src/network/getRelayFeeCache.test.ts

@@ -1,15 +0,0 @@
-import { getRelayFeeCache } from "./getRelayFeeCache";
-import { getNetworkProvider } from "./default";
-
-test("Should return  ", async () => {
-  let provider = getNetworkProvider();
-  let fee = await getRelayFeeCache(provider);
-  expect(fee).toBe(1);
-});
-
-test("Should return  ", async () => {
-  let provider = getNetworkProvider();
-  globalThis.BCH_RELAY_FEE = 0.00005;
-  let fee2 = await getRelayFeeCache(provider);
-  expect(fee2).toBe(5);
-});

package/src/network/getRelayFeeCache.ts

@@ -1,23 +0,0 @@
-import { bchParam } from "../chain.js";
-import { networkTickerMap } from "./constant.js";
-import { default as NetworkProvider } from "./NetworkProvider.js";
-
-export async function getRelayFeeCache(provider: NetworkProvider) {
-  let relayFeePerKbInCoins;
-  if (networkTickerMap[provider.network] + "_RELAY_FEE" in globalThis) {
-    // Stores the fee in BCH_RELAY_FEE, tBCH_RELAY_FEE, etc
-    relayFeePerKbInCoins =
-      globalThis[networkTickerMap[provider.network] + "_RELAY_FEE"];
-  }
-  if (typeof relayFeePerKbInCoins !== "number") {
-    relayFeePerKbInCoins = await provider.getRelayFee();
-    globalThis[networkTickerMap[provider.network] + "_RELAY_FEE"] =
-      relayFeePerKbInCoins;
-  }
-  if (typeof relayFeePerKbInCoins === "number") {
-    return Math.round(relayFeePerKbInCoins * Number(bchParam.subUnits)) / 1000;
-  } else {
-    console.warn("Couldn't get min relay fee, using default instead");
-    return Math.round(0.00001 * Number(bchParam.subUnits)) / 1000;
-  }
-}

package/src/network/index.ts

@@ -1,14 +0,0 @@
-export { getNetworkProvider } from "./default.js";
-export {
-  Connection,
-  initProviders,
-  initProvider,
-  disconnectProviders,
-} from "./Connection.js";
-export { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
-export { default as NetworkProvider } from "./NetworkProvider.js";
-export {
-  ElectrumRawTransaction,
-  ElectrumRawTransactionWithInputValues,
-  ElectrumRawTransactionVinWithValues,
-} from "./interface.js";