mainnet-js 3.0.0-next.0 → 3.0.0-next.1

package/src/constant.ts

@@ -1,7 +1,7 @@
 export const DELIMITER = ":";
 
 // Min amount utxo can be to be accepted by the network
-export const DUST_UTXO_THRESHOLD = 546;
+export const DUST_UTXO_THRESHOLD = 546n;
 
 // Current chained tx limit
 export const MEMPOOL_CHAIN_LIMIT = 50;

package/src/enum.ts

@@ -10,7 +10,6 @@ export enum NetworkEnum {
   Mainnet = <any>"mainnet",
   Testnet = <any>"testnet",
   Regtest = <any>"regtest",
-  Simtest = <any>"simtest",
 }
 
 export const networkPrefixMap = {
@@ -30,11 +29,6 @@ const literal = <L extends string>(l: L): L => l;
 export const UnitEnum = {
   BCH: literal("bch"),
   USD: literal("usd"),
-  BIT: literal("bit"),
-  BITS: literal("bits"),
   SAT: literal("sat"),
-  SATS: literal("sats"),
-  SATOSHI: literal("satoshi"),
-  SATOSHIS: literal("satoshis"),
 };
 export type UnitEnum = typeof UnitEnum[keyof typeof UnitEnum];

package/src/history/getHistory.test.ts

@@ -3,6 +3,7 @@ import { WalletTypeEnum } from "../wallet/enum";
 import { createWallet } from "../wallet/createWallet";
 import { mine } from "../mine";
 import { encodeCashAddress } from "@bitauth/libauth";
+import { toBch } from "../util";
 
 test("Should get miner history", async () => {
   const alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF!);
@@ -28,33 +29,29 @@ test("Should get an address history", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
       {
         cashaddr: charlie.cashaddr!,
-        value: 41000,
-        unit: "satoshis",
+        value: 41000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     await bob.send([
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.
@@ -110,28 +107,25 @@ test("Should get a history with multi-party sends", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     await bob.send([
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
 
     // Build Bob's wallet from a public address, check his balance.
@@ -190,31 +184,27 @@ test("Should cut results with a longer history to given count", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.
@@ -258,30 +248,26 @@ test("Should handle input and fee from many utxos", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.sendMax(charlie.cashaddr!);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.

package/src/history/getHistory.ts

@@ -22,38 +22,6 @@ type Transaction = TransactionCommon & {
   hash: string;
 };
 
-// export type AddressTxI = TxI & {
-//   address: string;
-// }
-
-// export const getAddressHistory = async ({
-//   address,
-//   provider,
-//   unit = "sat",
-//   fromHeight = 0,
-//   toHeight = -1,
-//   start = 0,
-//   count = -1,
-// }: {
-//   address: string;
-//   provider: NetworkProvider;
-//   unit?: UnitEnum;
-//   fromHeight?: number;
-//   toHeight?: number;
-//   start?: number;
-//   count?: number;
-// }): Promise<TransactionHistoryItem[]> => {
-//   return getHistory({
-//     addresses: [address],
-//     provider,
-//     unit,
-//     fromHeight,
-//     toHeight,
-//     start,
-//     count,
-//   });
-// }
-
 export const getHistory = async ({
   addresses,
   provider,

package/src/interface.ts

@@ -18,7 +18,7 @@ export type Network = typeof Network[keyof typeof Network];
 export interface Utxo {
   txid: string;
   vout: number;
-  satoshis: number;
+  satoshis: bigint;
   height?: number;
   coinbase?: boolean;
   token?: TokenI;
@@ -28,7 +28,6 @@ export interface Utxo {
 export interface UtxoId {
   txid: string;
   vout: number;
-  satoshis: number;
 }
 
 export interface ElectrumBalanceI {

package/src/network/Connection.test.ts

@@ -14,7 +14,7 @@ test("Should connect to mainnet", async () => {
 
   let wallet = await Wallet.newRandom();
   expect(wallet.provider == globalThis.BCH).toBeTruthy();
-  expect(await wallet.getBalance("sat")).toBe(0);
+  expect(await wallet.getBalance()).toBe(0n);
 
   let height = await globalThis.BCH.getBlockHeight();
   expect(height).toBeGreaterThan(5000);
@@ -23,7 +23,7 @@ test("Should connect to mainnet", async () => {
 test("Should use global provider when creating testnet wallet", async () => {
   let wallet = await TestNetWallet.newRandom();
   expect(wallet.provider == globalThis.tBCH).toBeTruthy();
-  expect(await wallet.getBalance("sat")).toBe(0);
+  expect(await wallet.getBalance()).toBe(0n);
 
   let height = await globalThis.tBCH.getBlockHeight();
   expect(height).toBeGreaterThan(114);
@@ -34,7 +34,7 @@ test.skip("Should lower overhead in creating wallets", async () => {
   for (let i = 0; i < 100; i++) {
     let wallet = await RegTestWallet.newRandom();
     expect(wallet.provider == globalThis.rBCH).toBeTruthy();
-    expect(await wallet.getBalance("sat")).toBe(0);
+    expect(await wallet.getBalance()).toBe(0n);
   }
 
   let height = await globalThis.rBCH.getBlockHeight();

package/src/network/ElectrumNetworkProvider.ts

@@ -86,7 +86,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
       address: cashaddr,
       txid: utxo.tx_hash,
       vout: utxo.tx_pos,
-      satoshis: utxo.value,
+      satoshis: BigInt(utxo.value),
       height: utxo.height,
       token: utxo.token_data
         ? {

package/src/network/Rpc.test.ts

@@ -73,7 +73,7 @@ describe("Rpc tests", () => {
 
     let result = false;
     aliceWallet.watchBalance((balance) => {
-      expect(balance.bch).toBeGreaterThan(0);
+      expect(balance).toBeGreaterThan(0);
       result = true;
       // stop watching
       return true;
@@ -105,8 +105,7 @@ describe("Rpc tests", () => {
     await aliceWallet.send([
       {
         cashaddr: bobWallet.cashaddr!,
-        value: 1000,
-        unit: "satoshis",
+        value: 1000n,
       },
     ]);
 

package/src/network/getRelayFeeCache.ts

@@ -15,9 +15,9 @@ export async function getRelayFeeCache(provider: NetworkProvider) {
       relayFeePerKbInCoins;
   }
   if (typeof relayFeePerKbInCoins === "number") {
-    return Math.round(relayFeePerKbInCoins * bchParam.subUnits) / 1000;
+    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 * bchParam.subUnits) / 1000;
+    return Math.round(0.00001 * Number(bchParam.subUnits)) / 1000;
   }
 }

package/src/rate/ExchangeRate.test.ts

@@ -1,8 +1,5 @@
-import { removeFetchMock, setupFetchMock } from "../test/fetch";
-import { BalanceResponse } from "../util/balanceObjectFromSatoshi";
-import { RegTestWallet } from "../wallet/Wif";
-import { ExchangeRate, getRateFromExchange } from "./ExchangeRate";
-import { delay } from "../util/delay";
+import { setupFetchMock } from "../test/fetch";
+import { ExchangeRate } from "./ExchangeRate";
 import { initProviders, disconnectProviders } from "../network";
 import { Config } from "../config";
 
@@ -25,45 +22,6 @@ describe("Exchange rate tests", () => {
     expect(rate).toBe(1337.42);
   });
 
-  test("Test watchBalanceUsd", async () => {
-    setupFetchMock("https://markets.api.bitcoin.com/live/bitcoin", {
-      data: {
-        BCH: 1337.42,
-      },
-    });
-
-    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
-    const bob = await RegTestWallet.newRandom();
-    const balance = (await alice.getBalance()) as BalanceResponse;
-    let cbCounter = 0;
-    const cancelWatchFn = await alice.watchBalanceUsd(async (newBalance) => {
-      cbCounter++;
-      if (cbCounter === 1) {
-        expect(newBalance.usd!).toBeGreaterThan(balance.usd!);
-      }
-    }, 3000);
-
-    setupFetchMock("https://markets.api.bitcoin.com/live/bitcoin", {
-      data: {
-        BCH: 31337.42,
-      },
-    });
-
-    await delay(3000);
-
-    await alice.send({
-      cashaddr: bob.getDepositAddress(),
-      value: 10000,
-      unit: "sat",
-    });
-
-    await delay(3000);
-
-    removeFetchMock("https://markets.api.bitcoin.com/live/bitcoin");
-    expect(cbCounter).toBe(2);
-    await cancelWatchFn();
-  });
-
   test("Test other currencies", async () => {
     const eurRate = await ExchangeRate.get("eur");
     expect(eurRate).toBeGreaterThan(0);

package/src/rate/ExchangeRate.ts

@@ -42,7 +42,7 @@ export class ExchangeRate {
   }
 
   static async getRateFromLocalStorage(
-    symbol,
+    symbol: string,
     useCache = true
   ): Promise<number> {
     if (!useCache) {
@@ -136,4 +136,7 @@ export async function getRateFromExchange(symbol: string): Promise<number> {
 }
 
 // do not await and do not throw in case we are offline
-ExchangeRate.get("usd").catch(() => {});
+// 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/transaction/Wif.ts

@@ -26,11 +26,10 @@ import {
   SourceOutput,
   TokenSendRequest,
 } from "../wallet/model.js";
-import { amountInSatoshi } from "../util/amountInSatoshi.js";
 import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts.js";
 import { sumUtxoValue } from "../util/sumUtxoValue.js";
 import { FeePaidByEnum } from "../wallet/enum.js";
-import { WalletCacheI } from "../cache/walletCache.js";
+import { WalletCache } from "../cache/walletCache.js";
 
 export const placeholderPrivateKey =
   "0000000000000000000000000000000000000000000000000000000000000001";
@@ -41,7 +40,7 @@ export async function buildP2pkhNonHdTransaction({
   inputs,
   outputs,
   signingKey,
-  fee = 0,
+  fee = 0n,
   discardChange = false,
   feePaidBy = FeePaidByEnum.change,
   changeAddress = "",
@@ -50,11 +49,11 @@ export async function buildP2pkhNonHdTransaction({
   inputs: Utxo[];
   outputs: Array<SendRequest | TokenSendRequest | OpReturnData>;
   signingKey?: Uint8Array;
-  fee?: number;
+  fee?: bigint;
   discardChange?: boolean;
   feePaidBy?: FeePaidByEnum;
   changeAddress?: string;
-  walletCache?: WalletCacheI;
+  walletCache?: WalletCache;
 }) {
   if (!signingKey) {
     throw new Error("Missing signing key when building transaction");
@@ -135,7 +134,7 @@ export function prepareInputs({
     AuthenticationProgramStateCommon
   >;
   signingKey: Uint8Array;
-  walletCache?: WalletCacheI;
+  walletCache?: WalletCache;
 }) {
   const preparedInputs: any[] = [];
   const sourceOutputs: any[] = [];
@@ -166,7 +165,7 @@ export function prepareInputs({
           : undefined,
     };
     const key =
-      walletCache?.getByAddress(i.address)?.privateKey ??
+      walletCache?.get(i.address)?.privateKey ??
       (signingKey?.length ? signingKey : Uint8Array.from(Array(32)));
     const newInput = {
       outpointIndex: utxoIndex,
@@ -231,7 +230,7 @@ export async function prepareOutputs(
     if (typeof outputLockingBytecode === "string")
       throw new Error(outputLockingBytecode);
 
-    const sendAmount = await amountInSatoshi(output.value, output.unit);
+    const sendAmount = Number(output.value);
     if (sendAmount % 1 !== 0) {
       throw Error(
         `Cannot send ${sendAmount} satoshis, (fractional sats do not exist, yet), please use an integer number.`
@@ -451,7 +450,7 @@ export async function getFeeAmountSimple({
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
   discardChange?: boolean;
-}) {
+}): Promise<bigint> {
   const inputSizeP2pkh = 148;
   const outputSizeP2pkh = 34;
 
@@ -468,10 +467,8 @@ export async function getFeeAmountSimple({
     0
   );
 
-  const outputSize = (sendRequest) => {
-    if (sendRequest.hasOwnProperty("unit")) {
-      return outputSizeP2pkh;
-    } else if (sendRequest.hasOwnProperty("tokenId")) {
+  const outputSize = (sendRequest: SendRequestType) => {
+    if (sendRequest.hasOwnProperty("tokenId")) {
       const tokenRequest = sendRequest as TokenSendRequest;
       return (
         outputSizeP2pkh +
@@ -482,17 +479,19 @@ export async function getFeeAmountSimple({
       );
     } else if (sendRequest.hasOwnProperty("buffer")) {
       return 9 + (sendRequest as OpReturnData).buffer.length;
+    } else {
+      return outputSizeP2pkh;
     }
-
-    return 0;
   };
 
   const outputTotalSize =
     sendRequests.reduce((prev, curr) => prev + outputSize(curr), 0) +
     (discardChange ? 0 : outputSizeP2pkh);
 
-  return Math.ceil(
-    (inputTotalSize + outputTotalSize + 16) * relayFeePerByteInSatoshi
+  return BigInt(
+    Math.ceil(
+      (inputTotalSize + outputTotalSize + 16) * relayFeePerByteInSatoshi
+    )
   );
 }
 
@@ -512,7 +511,7 @@ export async function getFeeAmount({
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
   discardChange?: boolean;
-  walletCache?: WalletCacheI;
+  walletCache?: WalletCache;
 }) {
   // build transaction
   if (utxos) {
@@ -522,14 +521,16 @@ export async function getFeeAmount({
         inputs: utxos,
         outputs: sendRequests,
         signingKey: placeholderPrivateKeyBin,
-        fee: 0, //DUST_UTXO_THRESHOLD
+        fee: 0n, //DUST_UTXO_THRESHOLD
         discardChange: discardChange ?? false,
         feePaidBy,
         changeAddress: "",
         walletCache,
       });
 
-    return Math.ceil(draftTransaction.length * relayFeePerByteInSatoshi + 1);
+    return BigInt(
+      Math.ceil(draftTransaction.length * relayFeePerByteInSatoshi + 1)
+    );
   } else {
     throw Error(
       "The available inputs in the wallet cannot satisfy this send request"
@@ -542,7 +543,7 @@ export async function buildEncodedTransaction({
   inputs,
   outputs,
   signingKey,
-  fee = 0,
+  fee = 0n,
   discardChange = false,
   feePaidBy = FeePaidByEnum.change,
   changeAddress = "",
@@ -552,12 +553,12 @@ export async function buildEncodedTransaction({
   inputs: Utxo[];
   outputs: Array<SendRequest | TokenSendRequest | OpReturnData>;
   signingKey: Uint8Array;
-  fee?: number;
+  fee?: bigint;
   discardChange?: boolean;
   feePaidBy?: FeePaidByEnum;
   changeAddress?: string;
   buildUnsigned?: boolean;
-  walletCache?: WalletCacheI;
+  walletCache?: WalletCache;
 }) {
   const { transaction, sourceOutputs } = await buildP2pkhNonHdTransaction({
     inputs,