mainnet-js 3.1.7 → 4.0.0-next.10

package/src/network/interface.ts

@@ -1,80 +0,0 @@
-import { NFTCapability } from "../interface.js";
-
-export interface BlockHeader {
-  height: number;
-  hex: string;
-}
-
-export interface ElectrumHostParams {
-  host: string;
-  port: number;
-  timeout?: number;
-  scheme: "tcp" | "tcp_tls" | "ws" | "wss";
-}
-
-export interface ElectrumTokenData {
-  amount: string;
-  category: string;
-  nft?: {
-    capability: NFTCapability;
-    commitment: string;
-  };
-}
-
-export interface ElectrumUtxo {
-  tx_pos: number;
-  value: number;
-  tx_hash: string;
-  height: number;
-  token_data?: ElectrumTokenData;
-}
-
-export interface ElectrumRawTransaction {
-  blockhash: string;
-  blocktime: number;
-  confirmations: number;
-  hash: string;
-  hex: string;
-  locktime: number;
-  size: number;
-  time: number;
-  txid: string;
-  version: number;
-  vin: ElectrumRawTransactionVin[];
-  vout: ElectrumRawTransactionVout[];
-}
-
-export interface ElectrumRawTransactionVinScriptSig {
-  asm: string;
-  hex: string;
-}
-
-export interface ElectrumRawTransactionVin {
-  scriptSig: ElectrumRawTransactionVinScriptSig;
-  sequence: number;
-  txid: string;
-  vout: number;
-}
-
-export type ElectrumRawTransactionVinWithValues = ElectrumRawTransactionVin &
-  ElectrumRawTransactionVout;
-
-export interface ElectrumRawTransactionWithInputValues
-  extends Omit<ElectrumRawTransaction, "vin"> {
-  vin: ElectrumRawTransactionVinWithValues[];
-}
-
-export interface ElectrumRawTransactionVout {
-  n: number;
-  scriptPubKey: ElectrumRawTransactionVoutScriptPubKey;
-  value: number;
-  tokenData?: ElectrumTokenData;
-}
-
-export interface ElectrumRawTransactionVoutScriptPubKey {
-  addresses: string[];
-  asm: string;
-  hex: string;
-  reqSigs: number;
-  type: string;
-}

package/src/network/util.test.ts

@@ -1,24 +0,0 @@
-import { parseElectrumUrl } from "./util";
-
-test("Should parse various electrum urls", async () => {
-  expect(parseElectrumUrl("https://localhost:1")).toEqual({
-    host: "localhost",
-    port: 1,
-    scheme: "tcp_tls",
-  });
-  expect(parseElectrumUrl("http://127.0.0.1:1")).toEqual({
-    host: "127.0.0.1",
-    port: 1,
-    scheme: "tcp",
-  });
-  expect(parseElectrumUrl("ws://1.2.3.4:10001")).toEqual({
-    host: "1.2.3.4",
-    port: 10001,
-    scheme: "ws",
-  });
-  expect(parseElectrumUrl("wss://example.space:1")).toEqual({
-    host: "example.space",
-    port: 1,
-    scheme: "wss",
-  });
-});

package/src/network/util.ts

@@ -1,30 +0,0 @@
-import { ElectrumHostParams } from "./interface.js";
-
-export function parseElectrumUrl(givenUrl: string): ElectrumHostParams {
-  let url = new URL(givenUrl);
-  let port = parseInt(url.port || "443");
-  let scheme = getElectrumScheme(url.protocol);
-
-  return { host: url.hostname, port: port, scheme: scheme };
-}
-
-function getElectrumScheme(protocol: string) {
-  let transport: string;
-  switch (protocol) {
-    case "http:":
-      transport = "tcp";
-      break;
-    case "https:":
-      transport = "tcp_tls";
-      break;
-    case "ws:":
-      transport = "ws";
-      break;
-    case "wss:":
-      transport = "wss";
-      break;
-    default:
-      throw Error("Electrum transport protocol not understood.");
-  }
-  return transport as "tcp" | "tcp_tls" | "ws" | "wss";
-}

package/src/rate/ExchangeRate.test.headless.js

@@ -1,35 +0,0 @@
-const playwright = require("playwright");
-const PAGE_URL = "http://localhost:8080";
-
-describe("Exchange rate tests", () => {
-  let browser;
-  let page;
-
-  /**
-   * Create the browser and page context
-   */
-  beforeAll(async () => {
-    browser = await playwright["chromium"].launch();
-    page = await browser.newPage();
-
-    if (!page) {
-      throw new Error("Connection wasn't established");
-    }
-
-    // Open the page
-    await page.goto(PAGE_URL, {
-      waitUntil: "networkidle0",
-    });
-  });
-
-  afterAll(async () => {
-    await browser.close();
-  });
-
-  test("Get price in usd", async () => {
-    await page.evaluate(async () => {
-      let rate = await ExchangeRate.get("usd");
-      expect(rate).toBeGreaterThan(0);
-    }, []);
-  });
-});

package/src/rate/ExchangeRate.test.ts

@@ -1,51 +0,0 @@
-import { setupFetchMock } from "../test/fetch";
-import { ExchangeRate } from "./ExchangeRate";
-import { initProviders, disconnectProviders } from "../network";
-import { Config } from "../config";
-
-beforeAll(async () => {
-  await initProviders();
-});
-afterAll(async () => {
-  await disconnectProviders();
-});
-
-describe("Exchange rate tests", () => {
-  test("Get price in usd", async () => {
-    setupFetchMock("https://markets.api.bitcoin.com/live/bitcoin", {
-      data: {
-        BCH: 1337.42,
-      },
-    });
-
-    let rate = await ExchangeRate.get("usd");
-    expect(rate).toBe(1337.42);
-  });
-
-  test("Test other currencies", async () => {
-    const eurRate = await ExchangeRate.get("eur");
-    expect(eurRate).toBeGreaterThan(0);
-  });
-
-  test("Test non-existing currency", async () => {
-    await expect(ExchangeRate.get("xyz")).rejects.toThrow();
-  });
-
-  test("Test custom exchange rate function", async () => {
-    Config.GetExchangeRateFn = async (symbol: string): Promise<number> => {
-      if (symbol === "usd") {
-        return 5555.55;
-      }
-      throw new Error("Unsupported currency");
-    };
-
-    const usdRate = await ExchangeRate.get("usd", false);
-    expect(usdRate).toBe(5555.55);
-
-    await expect(ExchangeRate.get("eur", false)).rejects.toThrow(
-      "Unsupported currency"
-    );
-
-    Config.GetExchangeRateFn = undefined;
-  });
-});

package/src/rate/ExchangeRate.ts

@@ -1,142 +0,0 @@
-import { EXCHANGE_RATE_TTL } from "../constant.js";
-import {
-  RuntimePlatform,
-  getRuntimePlatform,
-} from "../util/getRuntimePlatform.js";
-import ExchangeRateProvider from "../db/ExchangeRateProvider.js";
-import { Config } from "../config.js";
-
-export class ExchangeRate {
-  symbol: string;
-  rate: number;
-  ttl: number;
-  constructor({
-    symbol,
-    rate,
-    ttl,
-  }: {
-    symbol: string;
-    rate: number;
-    ttl: number;
-  }) {
-    this.symbol = symbol;
-    this.rate = rate;
-    this.ttl = ttl;
-  }
-
-  toString() {
-    this.rate.toFixed(2);
-  }
-
-  static async get(symbol: string, useCache = true) {
-    const platform = getRuntimePlatform();
-    if (platform === RuntimePlatform.browser) {
-      try {
-        return await this.getRateFromLocalStorage(symbol, useCache);
-      } catch {
-        return await this.getRateFromGlobalScope(symbol, useCache);
-      }
-    } else {
-      return await this.getRateFromGlobalScope(symbol, useCache);
-    }
-  }
-
-  static async getRateFromLocalStorage(
-    symbol: string,
-    useCache = true
-  ): Promise<number> {
-    if (!useCache) {
-      return await getRateFromExchange(symbol);
-    }
-
-    let cache = new ExchangeRateProvider();
-    let cacheRate = await cache.getRate(symbol);
-    if (cacheRate) {
-      // if the cache is still good, return it
-      if (cacheRate.ttl > Date.now()) {
-        return cacheRate.rate;
-      }
-      // else fall through
-    }
-    let freshRate = await getRateFromExchange(symbol);
-    cache.setRate(symbol, freshRate, getTtl());
-    return freshRate;
-  }
-
-  static async getRateFromGlobalScope(symbol, useCache = true) {
-    if (!useCache) {
-      return await getRateFromExchange(symbol);
-    }
-
-    if (globalThis.RATE) {
-      let rateObject = globalThis.RATE;
-      if (symbol in rateObject) {
-        let cachedRate = rateObject[symbol] as ExchangeRate;
-        // If the cache is still good return ie
-        if (cachedRate.ttl > Date.now()) {
-          return cachedRate.rate;
-        }
-      }
-    }
-    let freshRate = await getRateFromExchange(symbol);
-    this.cacheRateInGlobalScope(symbol, freshRate);
-    return freshRate;
-  }
-
-  static cacheRateInGlobalScope(symbol, rate) {
-    if (!globalThis.RATE) {
-      globalThis.RATE = {};
-    } else {
-      globalThis.RATE[symbol] = {
-        symbol: symbol,
-        rate: rate,
-        ttl: getTtl(),
-      };
-    }
-  }
-}
-
-export function getTtl() {
-  return Math.trunc(Date.now() + EXCHANGE_RATE_TTL);
-}
-
-// Attempt to get the usd rate from some web app
-export async function getRateFromExchange(symbol: string): Promise<number> {
-  if (Config.GetExchangeRateFn) {
-    return await Config.GetExchangeRateFn(symbol);
-  }
-
-  if (symbol.length > 0) {
-    symbol = symbol.toLocaleLowerCase();
-  }
-
-  if (symbol === "usd") {
-    try {
-      const response = await fetch(
-        "https://markets.api.bitcoin.com/live/bitcoin"
-      );
-      const data = await response.json();
-      return data["data"]["BCH"];
-    } catch {}
-  }
-
-  const response = await fetch("https://bitpay.com/rates/BCH");
-  const data = (await response.json()) as {
-    data: { code: string; rate: number }[];
-  };
-  const rates = data.data.reduce(
-    (acc, rate) => ({ ...acc, [rate.code.toLocaleLowerCase()]: rate.rate }),
-    {}
-  );
-  if (symbol in rates) {
-    return rates[symbol];
-  }
-
-  throw Error(`Currency '${symbol}' is not supported.`);
-}
-
-// do not await and do not throw in case we are offline
-// this promise can be used to warm up the cache
-export const ExchageRatePromise = ExchangeRate.get(Config.DefaultCurrency)
-  .then((result) => result)
-  .catch((error: Error) => error);

package/src/test/expect.ts

@@ -1,59 +0,0 @@
-export function expect(expected) {
-  return {
-    toBe: function (received) {
-      if (!(expected === received)) {
-        throw new Error(
-          `assertion failed: expected ${expected} is not equal to received ${received}`
-        );
-      }
-    },
-    toEqual: function (received) {
-      if (!(expected === received)) {
-        throw new Error(
-          `assertion failed: expected ${expected} is not equal to received ${received}`
-        );
-      }
-    },
-    toBeGreaterThan: function (received) {
-      if (!(expected > received)) {
-        throw new Error(
-          `assertion failed: expected ${expected} is not GreaterThan received ${received}`
-        );
-      }
-    },
-    toBeGreaterThanOrEqual: function (received) {
-      if (!(expected >= received)) {
-        throw new Error(
-          `assertion failed: expected ${expected} is not GreaterThanOrEqual received ${received}`
-        );
-      }
-    },
-    toStrictEqual: function (received) {
-      if (!(JSON.stringify(expected) === JSON.stringify(received))) {
-        throw new Error(
-          `assertion failed: expected ${expected} is not StrictEqual to received ${received}`
-        );
-      }
-    },
-    toContain: function (received) {
-      if (!(expected as String).includes(received)) {
-        throw new Error(
-          `assertion failed: expected ${expected} does not Contain received ${received}`
-        );
-      }
-    },
-    rejects: {
-      toThrow: async function (message: string): Promise<void> {
-        try {
-          await expected;
-        } catch (e: any) {
-          if (!(e.message as String).includes(message)) {
-            throw new Error(
-              `assertion failed: expected function to throw with message ${message}, but it did not.`
-            );
-          }
-        }
-      },
-    },
-  };
-}

package/src/test/fetch.ts

@@ -1,39 +0,0 @@
-const map: Record<string, any> = {};
-
-const _fetch = globalThis.fetch;
-
-Object.defineProperty(globalThis, "fetch", {
-  writable: true,
-});
-
-globalThis.fetch = (async (uri: any, ...rest: any) => {
-  if (!map[uri]) {
-    // allow for execution of the original fetch taking some time
-    const response = await _fetch(uri, ...rest);
-    // upon arrival of the response, check if it was mocked in the meanwhile
-    if (!map[uri]) {
-      return response;
-    }
-  }
-
-  return new Promise((resolve) =>
-    resolve({
-      json: () => {
-        return typeof map[uri] === "string" ? JSON.parse(map[uri]) : map[uri];
-      },
-      text: () => {
-        return typeof map[uri] === "string"
-          ? map[uri]
-          : JSON.stringify(map[uri], null, 2);
-      },
-    })
-  );
-}) as any;
-
-export function setupFetchMock(mockUrl: string, responseData: any) {
-  map[mockUrl] = responseData;
-}
-
-export function removeFetchMock(mockUrl: string) {
-  delete map[mockUrl];
-}

package/src/test/json.test.ts

@@ -1,13 +0,0 @@
-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"');
-  });
-});