mainnet-js 2.3.13 → 2.3.15

package/src/network/ElectrumNetworkProvider.ts

@@ -12,6 +12,7 @@ import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
 
 import { CancelWatchFn } from "../wallet/interface.js";
 import { getTransactionHash } from "../util/transaction.js";
+import { Config } from "../config.js";
 
 export default class ElectrumNetworkProvider implements NetworkProvider {
   public electrum: ElectrumCluster | ElectrumClient;
@@ -116,8 +117,14 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     loadInputValues: boolean = false
   ): Promise<string> {
     const key = `${this.network}-${txHash}-${verbose}-${loadInputValues}`;
-    if (ElectrumNetworkProvider.rawTransactionCache[key]) {
-      return ElectrumNetworkProvider.rawTransactionCache[key];
+
+    if (Config.UseLocalStorageCache) {
+      const cached = localStorage.getItem(key);
+      if (cached) {
+        return verbose ? JSON.parse(cached) : cached;
+      }
+    } else {
+      ElectrumNetworkProvider.rawTransactionCache[key];
     }
 
     try {
@@ -127,7 +134,16 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
         verbose
       )) as ElectrumRawTransaction;
 
-      ElectrumNetworkProvider.rawTransactionCache[key] = transaction;
+      if (Config.UseLocalStorageCache) {
+        localStorage.setItem(
+          key,
+          verbose
+            ? JSON.stringify(transaction)
+            : (transaction as unknown as string)
+        );
+      } else {
+        ElectrumNetworkProvider.rawTransactionCache[key] = transaction;
+      }
 
       if (verbose && loadInputValues) {
         // get unique transaction hashes

package/src/rate/ExchangeRate.test.ts

@@ -64,4 +64,13 @@ describe("Exchange rate tests", () => {
     expect(cbCounter).toBe(2);
     await cancelWatchFn();
   });
+
+  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();
+  });
 });

package/src/rate/ExchangeRate.ts

@@ -124,9 +124,19 @@ export async function getRateFromExchange(symbol: string): Promise<number> {
         }
       }
     default:
-      throw Error(
-        "Support for giving an amount in '${symbol}' is not supported."
+      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.`);
   }
 }
 

package/src/util/amountInSatoshi.ts

@@ -28,11 +28,10 @@ export async function amountInSatoshi(
       return value;
     case UnitEnum.SATOSHIS:
       return value;
-    case UnitEnum.USD:
-      let USD_over_BCH = await ExchangeRate.get("usd");
-      let SAT_over_BCH = bchParam.subUnits;
-      return Math.round(Number(value * (SAT_over_BCH / USD_over_BCH)));
     default:
-      throw Error("Unit of value not defined");
+      const Currency_over_BCH = await ExchangeRate.get(rawUnit);
+      const SAT_over_BCH = bchParam.subUnits;
+
+      return Math.round(Number(value * (SAT_over_BCH / Currency_over_BCH)));
   }
 }

package/src/util/balanceObjectFromSatoshi.test.ts

@@ -1,3 +1,4 @@
+import { Config } from "../config";
 import { bchParam } from "../chain";
 import { balanceResponseFromSatoshi } from "./balanceObjectFromSatoshi";
 import { balanceFromSatoshi } from "./balanceObjectFromSatoshi";
@@ -8,6 +9,22 @@ test("Get balanceResponse from 1 bch in satoshi", async () => {
   expect(bal.sat).toBe(bchParam.subUnits);
 });
 
+test("Get balanceResponse from 0", async () => {
+  let bal = await balanceResponseFromSatoshi(0);
+  expect(bal.bch).toBe(0);
+  expect(bal.sat).toBe(0);
+  expect(bal.usd).toBe(0);
+});
+
+test("Get balanceResponse from 1 bch in eur", async () => {
+  Config.DefaultCurrency = "eur";
+  let bal = await balanceResponseFromSatoshi(100000000);
+  expect(bal.bch).toBe(1);
+  expect(bal.sat).toBe(bchParam.subUnits);
+  expect(bal.eur).toBeGreaterThan(0);
+  Config.DefaultCurrency = "usd";
+});
+
 test("Get balanceResponse from 1 satoshi", async () => {
   let bal = await balanceResponseFromSatoshi(110000000);
   expect(bal.bch).toBe(1.1);

package/src/util/balanceObjectFromSatoshi.ts

@@ -3,52 +3,33 @@ import { UnitEnum } from "../enum.js";
 import { floor } from "./floor.js";
 import { ExchangeRate } from "../rate/ExchangeRate.js";
 import { sanitizeUnit } from "./sanitizeUnit.js";
+import { Config } from "../config.js";
 
-export class BalanceResponse {
-  bch?: number;
-  sat?: number;
-  usd?: number;
-  constructor(bch?: number, sat?: number, usd?: number) {
-    this.bch = bch;
-    this.sat = sat;
-    this.usd = usd;
-  }
+export interface BalanceResponse {
+  bch: number;
+  sat: number;
+  [currency: string]: number;
 }
 
 export async function balanceResponseFromSatoshi(
   value: number,
-  usdPriceCache: boolean = true
+  priceCache: boolean = true
 ): Promise<BalanceResponse> {
-  let response = new BalanceResponse();
-  let returnUnits: UnitEnum[] = ["bch", "sat", "usd"];
+  const response = {} as BalanceResponse;
 
-  for (const u of returnUnits) {
-    switch (u) {
-      case UnitEnum.BCH:
-        response.bch = value / bchParam.subUnits;
-        break;
-      case UnitEnum.SAT:
-        response.sat = value;
-        break;
-      case UnitEnum.USD:
-        let usd =
-          (value / bchParam.subUnits) *
-          (await ExchangeRate.get("usd", usdPriceCache));
-        response.usd = floor(usd, 2);
-        break;
-      default:
-        throw Error(
-          `Balance response type ${JSON.stringify(u)} not understood`
-        );
-    }
-  }
+  response.bch = value / bchParam.subUnits;
+  response.sat = value;
+  const currencyValue =
+    (value / bchParam.subUnits) *
+    (await ExchangeRate.get(Config.DefaultCurrency, priceCache));
+  response[Config.DefaultCurrency] = floor(currencyValue, 2);
   return response;
 }
 
 export async function balanceFromSatoshi(
   value: number,
   rawUnit: string,
-  usdPriceCache: boolean = true
+  priceCache: boolean = true
 ): Promise<number> {
   const unit = sanitizeUnit(rawUnit);
   switch (unit) {
@@ -62,14 +43,10 @@ export async function balanceFromSatoshi(
       return value;
     case UnitEnum.SATOSHIS:
       return value;
-    case UnitEnum.USD:
-      let usd =
-        (value / bchParam.subUnits) *
-        (await ExchangeRate.get("usd", usdPriceCache));
-      return Number(usd.toFixed(2));
     default:
-      throw Error(
-        `Balance response type ${JSON.stringify(unit)} not understood`
-      );
+      const currencyValue =
+        (value / bchParam.subUnits) *
+        (await ExchangeRate.get(Config.DefaultCurrency, priceCache));
+      return Number(currencyValue.toFixed(2));
   }
 }

package/src/util/convert.test.ts

@@ -39,3 +39,8 @@ test("Should convert all the BCH from sat to bch", async () => {
   let bch = await convert(21000000 * 100000000, "sat", "BCH");
   expect(bch).toBe(21000000);
 });
+
+test("Should convert BCH to EUR", async () => {
+  let eur = await convert(1, "BCH", "EUR");
+  expect(eur).toBeGreaterThan(0);
+});

package/src/util/satoshiToAmount.ts

@@ -27,16 +27,13 @@ export async function satoshiToAmount(
       return value;
     case UnitEnum.SATOSHIS:
       return value;
-    case UnitEnum.USD:
-      let USD_over_BCH = await ExchangeRate.get("usd");
-      let SAT_over_BCH = bchParam.subUnits;
-      // truncate dollar amounts to fixed precision (2),
-      // then return the fixed value string as a float.
-      let dollarValue = Number(value * (USD_over_BCH / SAT_over_BCH)).toFixed(
-        2
-      );
-      return Number.parseFloat(dollarValue);
     default:
-      throw Error("Unit of value not defined");
+      const Currency_over_BCH = await ExchangeRate.get(rawUnit);
+      // truncate currency amounts to fixed precision (2),
+      // then return the fixed value string as a float.
+      const currencyValue = Number(
+        value * (Currency_over_BCH / bchParam.subUnits)
+      ).toFixed(2);
+      return Number.parseFloat(currencyValue);
   }
 }

package/src/wallet/Wif.test.ts

@@ -18,6 +18,7 @@ import {
 import { mine } from "../mine";
 import json from "../../polyfill/json";
 import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider";
+import { Config } from "../config";
 
 beforeAll(async () => {
   await initProviders();
@@ -458,6 +459,23 @@ describe(`Watch only Wallets`, () => {
     }
   });
 
+  test("Should get the regtest wallet balance in eur", async () => {
+    // Build Alice's wallet from Wallet Import Format string, send some sats
+    if (!process.env.ADDRESS) {
+      throw Error("Attempted to pass an empty address");
+    } else {
+      Config.DefaultCurrency = "eur";
+      let alice = await RegTestWallet.watchOnly(process.env.ADDRESS); // insert WIF from #1
+      // Build Bob's wallet from a public address, check his balance.
+      expect(alice.getPublicKeyHash()!.length).toBe(20);
+      const aliceBalance = (await alice.getBalance()) as BalanceResponse;
+      expect(aliceBalance.bch).toBeGreaterThan(5000);
+      expect(await alice.getBalance("eur")).toBeGreaterThan(0);
+      expect(await (await RegTestWallet.newRandom()).getBalance("eur")).toBe(0);
+      Config.DefaultCurrency = "usd";
+    }
+  });
+
   test("Should send to testnet coins to a random address", async () => {
     if (!process.env.ALICE_TESTNET_WALLET_ID) {
       throw Error("Attempted to pass an empty address");
@@ -525,6 +543,18 @@ describe(`Watch only Wallets`, () => {
 
     expect(await bobWallet.getLastTransaction()).not.toBeNull();
   });
+
+  test("Should fail localStorage cache", async () => {
+    const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
+    const aliceWallet = await RegTestWallet.fromId(aliceWif);
+
+    expect(await aliceWallet.getLastTransaction()).not.toBeNull();
+    Config.UseLocalStorageCache = true;
+    await expect(aliceWallet.getLastTransaction()).rejects.toThrow(
+      "localStorage is not defined"
+    );
+    Config.UseLocalStorageCache = false;
+  });
 });
 describe(`Wallet subscriptions`, () => {
   test("Should wait for transaction", async () => {

package/src/wallet/Wif.ts

@@ -636,22 +636,22 @@ export class Wallet extends BaseWallet {
     return await this.getAddressUtxos(this.cashaddr);
   }
 
-  // gets wallet balance in sats, bch and usd
+  // gets wallet balance in sats, bch and currency
   public async getBalance(
     rawUnit?: string,
-    usdPriceCache = true
+    priceCache = true
   ): Promise<BalanceResponse | number> {
     if (rawUnit) {
       const unit = sanitizeUnit(rawUnit);
       return await balanceFromSatoshi(
         await this.getBalanceFromProvider(),
         unit,
-        usdPriceCache
+        priceCache
       );
     } else {
       return await balanceResponseFromSatoshi(
         await this.getBalanceFromProvider(),
-        usdPriceCache
+        priceCache
       );
     }
   }

package/src/wallet/model.ts

@@ -334,7 +334,7 @@ export class SendResponse {
     explorerUrl?: string;
   }) {
     this.txId = txId;
-    this.balance = new BalanceResponse(balance);
+    this.balance = balance;
     this.explorerUrl = explorerUrl;
   }
 }