mainnet-js 2.7.34 → 3.0.0-next.1

package/src/transaction/allocateFee.test.ts

@@ -29,66 +29,61 @@ describe("Fee tests", () => {
       await funder.send([
         {
           cashaddr: alice.cashaddr!,
-          value: 4500,
-          unit: "satoshis",
+          value: 4500n,
         },
       ]);
       await alice.send(
         [
           {
             cashaddr: bob.cashaddr!,
-            unit: "sat",
-            value: 549,
+            value: 549n,
           },
           {
             cashaddr: charlie.cashaddr!,
-            unit: "sat",
-            value: 550,
+            value: 550n,
           },
           {
             cashaddr: dave.cashaddr!,
-            unit: "sat",
-            value: 551,
+            value: 551n,
           },
           {
             cashaddr: edward.cashaddr!,
-            unit: "sat",
-            value: 2552,
+            value: 2552n,
           },
         ],
         { feePaidBy: FeePaidByEnum.changeThenAny }
       );
-      expect(await alice.getBalance("sat")).toBe(0);
-      expect(await bob.getBalance("sat")).toBe(0);
-      expect(await charlie.getBalance("sat")).toBe(550);
-      expect(await dave.getBalance("sat")).toBe(551);
-      expect(await edward.getBalance("sat")).toBe(2552);
+      expect(await alice.getBalance()).toBe(0n);
+      expect(await bob.getBalance()).toBe(0n);
+      expect(await charlie.getBalance()).toBe(550n);
+      expect(await dave.getBalance()).toBe(551n);
+      expect(await edward.getBalance()).toBe(2552n);
     }
   });
 
   test("Expect first in to subtract fee from first", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 2000n],
     ];
-    let fee = 1;
+    let fee = 1n;
     let requests = asSendRequestObject(to) as SendRequest[];
-    let allocatedInputs = await allocateFee(
+    let allocatedInputs = allocateFee(
       requests,
       fee,
       FeePaidByEnum.first,
       BigInt(0)
     );
-    expect(allocatedInputs[0].value).toBeLessThan(2000);
-    expect(allocatedInputs[1].value).toBe(2000);
+    expect(allocatedInputs[0].value).toBeLessThan(2000n);
+    expect(allocatedInputs[1].value).toBe(2000n);
   });
 
   test("Expect last to subtract fee from last", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 2000n],
     ];
-    let fee = 1;
+    let fee = 1n;
     let requests = asSendRequestObject(to) as SendRequest[];
     let allocatedInputs = allocateFee(
       requests,
@@ -97,17 +92,17 @@ describe("Fee tests", () => {
       BigInt(0)
     );
 
-    expect(allocatedInputs[0].value).toBe(2000);
-    expect(allocatedInputs[1].value).toBeLessThan(2000);
+    expect(allocatedInputs[0].value).toBe(2000n);
+    expect(allocatedInputs[1].value).toBeLessThan(2000n);
   });
 
   test("Expect all to allocate fees equally", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 2000, "sat"],
-      ["charlie", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 2000n],
+      ["charlie", 2000n],
     ];
-    let fee = 3;
+    let fee = 3n;
     let requests = asSendRequestObject(to) as SendRequest[];
 
     let allocatedInputs = allocateFee(
@@ -117,18 +112,18 @@ describe("Fee tests", () => {
       BigInt(0)
     );
 
-    expect(allocatedInputs[0].value).toBe(1999);
-    expect(allocatedInputs[1].value).toBe(1999);
-    expect(allocatedInputs[2].value).toBe(1999);
+    expect(allocatedInputs[0].value).toBe(1999n);
+    expect(allocatedInputs[1].value).toBe(1999n);
+    expect(allocatedInputs[2].value).toBe(1999n);
   });
 
   test("Expect all to allocate fees equally, taking dust result", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 547, "sat"],
-      ["charlie", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 547n],
+      ["charlie", 2000n],
     ];
-    let fee = 300;
+    let fee = 300n;
     let requests = asSendRequestObject(to) as SendRequest[];
 
     let allocatedInputs = allocateFee(
@@ -138,18 +133,18 @@ describe("Fee tests", () => {
       BigInt(0)
     );
 
-    expect(allocatedInputs[0].value).toBe(2000);
-    expect(allocatedInputs[1].value).toBe(2000);
+    expect(allocatedInputs[0].value).toBe(2000n);
+    expect(allocatedInputs[1].value).toBe(2000n);
     expect(allocatedInputs.length).toBe(2);
   });
 
   test("Expect all to allocate fees equally, taking dust result output, dividing remainder", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 547, "sat"],
-      ["charlie", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 547n],
+      ["charlie", 2000n],
     ];
-    let fee = 647;
+    let fee = 647n;
     let requests = asSendRequestObject(to) as SendRequest[];
 
     let allocatedInputs = allocateFee(
@@ -159,18 +154,18 @@ describe("Fee tests", () => {
       BigInt(0)
     );
 
-    expect(allocatedInputs[0].value).toBe(1950);
-    expect(allocatedInputs[1].value).toBe(1950);
+    expect(allocatedInputs[0].value).toBe(1950n);
+    expect(allocatedInputs[1].value).toBe(1950n);
     expect(allocatedInputs.length).toBe(2);
   });
 
   test("Expect an odd fee to be applied to have remainder applied to first receipt", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 2000, "sat"],
-      ["charlie", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 2000n],
+      ["charlie", 2000n],
     ];
-    let fee = 301;
+    let fee = 301n;
     let requests = asSendRequestObject(to) as SendRequest[];
 
     let allocatedInputs = allocateFee(
@@ -180,88 +175,72 @@ describe("Fee tests", () => {
       BigInt(0)
     );
 
-    expect(allocatedInputs[0].value).toBe(1899);
-    expect(allocatedInputs[1].value).toBe(1900);
-    expect(allocatedInputs[2].value).toBe(1900);
+    expect(allocatedInputs[0].value).toBe(1899n);
+    expect(allocatedInputs[1].value).toBe(1900n);
+    expect(allocatedInputs[2].value).toBe(1900n);
   });
 
   test("Expect insufficient funds to error", async () => {
-    expect.assertions(1);
-    try {
-      let to = [
-        ["alice", 2000, "sat"],
-        ["bob", 2000, "sat"],
-        ["charlie", 2000, "sat"],
-      ];
-      let fee = 7000;
-      let requests = asSendRequestObject(to) as SendRequest[];
-      let allocatedInputs = allocateFee(
-        requests,
-        fee,
-        FeePaidByEnum.changeThenAny,
-        BigInt(999)
-      );
-    } catch (e: any) {
-      expect(e.message).toBe("Insufficient funds for transaction given fee");
-    }
+    let to = [
+      ["alice", 2000n],
+      ["bob", 2000n],
+      ["charlie", 2000n],
+    ];
+    let fee = 7000n;
+    let requests = asSendRequestObject(to) as SendRequest[];
+    expect(() =>
+      allocateFee(requests, fee, FeePaidByEnum.changeThenAny, BigInt(999))
+    ).toThrow("Insufficient funds for transaction given fee");
   });
 
   test("Expect dust amounts to error", async () => {
-    expect.assertions(1);
-    try {
-      let to = [
-        ["alice", 2000, "sat"],
-        ["bob", 2000, "sat"],
-        ["charlie", 2000, "sat"],
-      ];
-      let fee = 1500;
-      let requests = asSendRequestObject(to) as SendRequest[];
-      let allocatedInputs = allocateFee(
-        requests,
-        fee,
-        FeePaidByEnum.first,
-        BigInt(0)
-      );
-    } catch (e: any) {
-      expect(e.message).toBe("Fee strategy would result in dust output");
-    }
+    let to = [
+      ["alice", 2000n],
+      ["bob", 2000n],
+      ["charlie", 2000n],
+    ];
+    let fee = 1500n;
+    let requests = asSendRequestObject(to) as SendRequest[];
+    expect(() =>
+      allocateFee(requests, fee, FeePaidByEnum.first, BigInt(0))
+    ).toThrow("Fee strategy would result in dust output");
   });
 
   test("Expect near-dust amounts not to error", async () => {
     let to = [
-      ["alice", 1000, "sat"],
-      ["bob", 1000, "sat"],
-      ["charlie", 1000, "sat"],
+      ["alice", 1000n],
+      ["bob", 1000n],
+      ["charlie", 1000n],
     ];
-    let fee = 1362;
+    let fee = 1362n;
     let requests = asSendRequestObject(to) as SendRequest[];
     let result = allocateFee(requests, fee, FeePaidByEnum.any, BigInt(0));
-    expect(result[0].value).toBe(546);
-    expect(result[1].value).toBe(546);
-    expect(result[2].value).toBe(546);
+    expect(result[0].value).toBe(546n);
+    expect(result[1].value).toBe(546n);
+    expect(result[2].value).toBe(546n);
   });
 
   test("Expect `any` to not consume change", async () => {
     let to = [
-      ["alice", 1000, "sat"],
-      ["bob", 1000, "sat"],
-      ["charlie", 1000, "sat"],
+      ["alice", 1000n],
+      ["bob", 1000n],
+      ["charlie", 1000n],
     ];
-    let fee = 1362;
+    let fee = 1362n;
     let requests = asSendRequestObject(to) as SendRequest[];
     let result = allocateFee(requests, fee, FeePaidByEnum.any, BigInt(1362));
-    expect(result[0].value).toBe(546);
-    expect(result[1].value).toBe(546);
-    expect(result[2].value).toBe(546);
+    expect(result[0].value).toBe(546n);
+    expect(result[1].value).toBe(546n);
+    expect(result[2].value).toBe(546n);
   });
 
   test("Expect `change,any` to consume only change", async () => {
     let to = [
-      ["alice", 1000, "sat"],
-      ["bob", 1000, "sat"],
-      ["charlie", 1000, "sat"],
+      ["alice", 1000n],
+      ["bob", 1000n],
+      ["charlie", 1000n],
     ];
-    let fee = 1362;
+    let fee = 1362n;
     let requests = asSendRequestObject(to) as SendRequest[];
     let result = allocateFee(
       requests,
@@ -269,18 +248,18 @@ describe("Fee tests", () => {
       FeePaidByEnum.changeThenAny,
       BigInt(1362)
     );
-    expect(result[0].value).toBe(1000);
-    expect(result[1].value).toBe(1000);
-    expect(result[2].value).toBe(1000);
+    expect(result[0].value).toBe(1000n);
+    expect(result[1].value).toBe(1000n);
+    expect(result[2].value).toBe(1000n);
   });
 
   test("Expect `change,any` to use both", async () => {
     let to = [
-      ["alice", 1000, "sat"],
-      ["bob", 1000, "sat"],
-      ["charlie", 1000, "sat"],
+      ["alice", 1000n],
+      ["bob", 1000n],
+      ["charlie", 1000n],
     ];
-    let fee = 1362 * 2;
+    let fee = 1362n * 2n;
     let requests = asSendRequestObject(to) as SendRequest[];
     let result = allocateFee(
       requests,
@@ -288,32 +267,32 @@ describe("Fee tests", () => {
       FeePaidByEnum.changeThenAny,
       BigInt(1362)
     );
-    expect(result[0].value).toBe(546);
-    expect(result[1].value).toBe(546);
-    expect(result[2].value).toBe(546);
+    expect(result[0].value).toBe(546n);
+    expect(result[1].value).toBe(546n);
+    expect(result[2].value).toBe(546n);
   });
 
   test("Expect sortSendRequests to sort by lowest value first", async () => {
     let to = [
-      ["alice", 2000, "sat"],
-      ["bob", 547, "sat"],
-      ["charlie", 1, "sat"],
-      ["dave", 4, "sat"],
-      ["edward", 6, "sat"],
-      ["fred", 2000, "sat"],
-      ["greg", 2000, "sat"],
-      ["harry", 2000, "sat"],
+      ["alice", 2000n],
+      ["bob", 547n],
+      ["charlie", 1n],
+      ["dave", 4n],
+      ["edward", 6n],
+      ["fred", 2000n],
+      ["greg", 2000n],
+      ["harry", 2000n],
     ];
-    let fee = 1;
+    let fee = 1n;
     let requests = asSendRequestObject(to) as SendRequest[];
 
     let result = sortSendRequests(requests);
-    expect(result[0].value).toBe(1);
-    expect(result[1].value).toBe(4);
-    expect(result[2].value).toBe(6);
-    expect(result[3].value).toBe(547);
-    expect(result[4].value).toBe(2000);
-    expect(result[5].value).toBe(2000);
+    expect(result[0].value).toBe(1n);
+    expect(result[1].value).toBe(4n);
+    expect(result[2].value).toBe(6n);
+    expect(result[3].value).toBe(547n);
+    expect(result[4].value).toBe(2000n);
+    expect(result[5].value).toBe(2000n);
     expect(result.length).toBe(8);
   });
 });

package/src/transaction/allocateFee.ts

@@ -6,7 +6,7 @@ import {
 import { FeePaidByEnum } from "../wallet/enum.js";
 import { DUST_UTXO_THRESHOLD } from "../constant.js";
 
-export function checkFeeForDust(value: number) {
+export function checkFeeForDust(value: bigint) {
   if (value < DUST_UTXO_THRESHOLD) {
     throw Error("Fee strategy would result in dust output");
   }
@@ -14,11 +14,11 @@ export function checkFeeForDust(value: number) {
 
 export function checkSatsAvailable(
   sendRequestArray: Array<SendRequest>,
-  fee: number
+  fee: bigint
 ) {
   let amountAvailable = sendRequestArray.reduce(function (sum, r) {
     return sum + (r.value - DUST_UTXO_THRESHOLD);
-  }, 0);
+  }, 0n);
   if (amountAvailable < fee) {
     throw Error("Insufficient funds for transaction given fee");
   }
@@ -39,22 +39,21 @@ export function checkForNonStandardSendRequest(
 }
 
 export function sortSendRequests(sendRequestArray: Array<SendRequest>) {
-  return sendRequestArray.sort(
-    (a: SendRequest, b: SendRequest) => a.value - b.value
+  return sendRequestArray.sort((a: SendRequest, b: SendRequest) =>
+    Number(a.value - b.value)
   );
 }
 
-function distributeFees(requests: Array<SendRequest>, fee: number) {
+function distributeFees(requests: Array<SendRequest>, fee: bigint) {
   checkSatsAvailable(requests, fee);
-  fee = Number(fee);
   for (let r = 0; r < requests.length; r++) {
     if (fee > 0) {
       checkForNonStandardSendRequest(requests[r]);
-      let perRequestFee = Math.floor(fee / (requests.length - r));
-      perRequestFee += fee % (requests.length - r);
+      let perRequestFee = fee / BigInt(requests.length - r);
+      perRequestFee += fee % BigInt(requests.length - r);
       if (requests[r].value - perRequestFee < DUST_UTXO_THRESHOLD) {
         fee -= requests[r].value;
-        requests[r].value = 0;
+        requests[r].value = 0n;
       } else {
         fee -= perRequestFee;
         requests[r].value -= perRequestFee;
@@ -66,7 +65,7 @@ function distributeFees(requests: Array<SendRequest>, fee: number) {
 
 function firstPays(
   requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
-  fee: number
+  fee: bigint
 ) {
   let payer = requests.shift()!;
   payer = checkForNonStandardSendRequest(payer);
@@ -77,7 +76,7 @@ function firstPays(
 }
 function lastPays(
   requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
-  fee: number
+  fee: bigint
 ) {
   let payer = requests.pop()!;
   payer = checkForNonStandardSendRequest(payer);
@@ -88,7 +87,7 @@ function lastPays(
 }
 function anyPays(
   requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
-  fee: number
+  fee: bigint
 ) {
   for (let r of requests) {
     checkForNonStandardSendRequest(r);
@@ -100,7 +99,7 @@ function anyPays(
 
 function changeThenFallback(
   requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
-  fee: number,
+  fee: bigint,
   change: bigint,
   fallbackFn: Function
 ) {
@@ -113,7 +112,7 @@ function changeThenFallback(
 
 export function allocateFee(
   requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
-  fee: number,
+  fee: bigint,
   feePaidBy: FeePaidByEnum,
   change: bigint
 ): Array<SendRequest> {

package/src/util/amountInSatoshi.test.ts

@@ -13,15 +13,7 @@ test("Get price of Bch, BCH, bch in sat", async () => {
 
 test("Get price of sat(s)", async () => {
   let rate = await amountInSatoshi(1, "sat");
-  expect(rate).toBe(1);
-  rate = await amountInSatoshi(1, "sats");
-  expect(rate).toBe(1);
-  rate = await amountInSatoshi(1, "Satoshi");
-  expect(rate).toBe(1);
-  rate = await amountInSatoshi(1, "SATOSHIS");
-  expect(rate).toBe(1);
-  rate = await amountInSatoshi(1, "satoshis");
-  expect(rate).toBe(1);
+  expect(rate).toBe(1n);
 });
 
 test("Get price of USD, Usd, usd", async () => {

package/src/util/amountInSatoshi.ts

@@ -15,23 +15,19 @@ import { sanitizeUnit } from "../util/sanitizeUnit.js";
 export async function amountInSatoshi(
   value: number,
   rawUnit: any
-): Promise<number> {
+): Promise<bigint> {
   const unit = sanitizeUnit(rawUnit);
   switch (unit) {
     case UnitEnum.BCH:
-      return Math.round(value * bchParam.subUnits);
-    case UnitEnum.SATOSHI:
-      return value;
+      return BigInt(Math.round(value * Number(bchParam.subUnits)));
     case UnitEnum.SAT:
-      return value;
-    case UnitEnum.SATS:
-      return value;
-    case UnitEnum.SATOSHIS:
-      return value;
+      return BigInt(value);
     default:
       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)));
+      return BigInt(
+        Math.round(Number(value * (Number(SAT_over_BCH) / Currency_over_BCH)))
+      );
   }
 }

package/src/util/asSendRequestObject.ts

@@ -1,5 +1,4 @@
 import { base64ToBin } from "@bitauth/libauth";
-import { UnitEnum } from "../enum.js";
 import {
   OpReturnData,
   SendRequest,
@@ -31,12 +30,14 @@ export function asSendRequestObject(
               )
             );
           } else {
-            // ['cashaddr', 120, 'sats'],
+            // ['cashaddr', 120] or ['cashaddr', 120n],
             resp.push(
               new SendRequest({
                 cashaddr: r[0] as string,
-                value: r[1] as number,
-                unit: r[2] as UnitEnum,
+                value:
+                  typeof r[1] === "number"
+                    ? BigInt(Math.floor[1])
+                    : (r[1] as bigint),
               })
             );
           }
@@ -56,9 +57,7 @@ export function asSendRequestObject(
 }
 
 function convertToClass(object: SendRequest | TokenSendRequest | OpReturnData) {
-  if (object.hasOwnProperty("unit")) {
-    return new SendRequest(object as SendRequest);
-  } else if (object.hasOwnProperty("tokenId")) {
+  if (object.hasOwnProperty("tokenId")) {
     return new TokenSendRequest(object as TokenSendRequest);
   } else if (object.hasOwnProperty("buffer")) {
     return OpReturnData.fromUint8Array((object as OpReturnData).buffer);
@@ -70,6 +69,12 @@ function convertToClass(object: SendRequest | TokenSendRequest | OpReturnData) {
     return OpReturnData.fromUint8Array(
       Uint8Array.from(base64ToBin((object as any).dataBuffer))
     );
+  } else if (
+    object.hasOwnProperty("cashaddr") &&
+    object.hasOwnProperty("value") &&
+    object.hasOwnProperty("tokenId") === false
+  ) {
+    return new SendRequest(object as SendRequest);
   }
 
   throw new Error("Unsupported send object");

package/src/util/checkUtxos.ts

@@ -1,31 +1,26 @@
-import { UtxoI } from "../interface.js";
+import { Utxo, UtxoId } from "../interface.js";
 
 export async function checkUtxos(
-  utxos: UtxoI[],
-  wallet: import("../wallet/Wif.js").Wallet
-): Promise<UtxoI[]> {
-  if (utxos.some((val) => val.satoshis === 0)) {
-    const addressUtxos = await wallet.getAddressUtxos(wallet.cashaddr);
-    const absent = utxos.filter(
-      (val) =>
-        !addressUtxos.find(
-          (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
-        )
-    );
-    if (absent.length) {
-      const absentString = absent
-        .map((val) => `${val.txid}:${val.vout}`)
-        .join(", ");
-      throw Error(`Utxos [${absentString}] not found in wallet`);
-    }
-
-    utxos = utxos.map(
-      (val) =>
-        addressUtxos.find(
-          (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
-        )!
-    );
+  utxoIds: UtxoId[],
+  walletOrUtxos: Utxo[] | import("../wallet/Wif.js").Wallet
+): Promise<Utxo[]> {
+  const addressUtxos = Array.isArray(walletOrUtxos)
+    ? walletOrUtxos
+    : await walletOrUtxos.getUtxos();
+  const absent = utxoIds.filter(
+    (val) =>
+      !addressUtxos.find(
+        (utxo) => val.txid === utxo.txid && val.vout === utxo.vout
+      )
+  );
+  if (absent.length) {
+    const absentString = absent
+      .map((val) => `${val.txid}:${val.vout}`)
+      .join(", ");
+    throw Error(`Utxos [${absentString}] not found in wallet`);
   }
 
-  return utxos;
+  return addressUtxos.filter((val) =>
+    utxoIds.find((utxo) => val.txid === utxo.txid && val.vout === utxo.vout)
+  );
 }

package/src/util/convert.ts

@@ -1,3 +1,4 @@
+import { bchParam } from "../chain.js";
 import { amountInSatoshi } from "./amountInSatoshi.js";
 import { satoshiToAmount } from "./satoshiToAmount.js";
 
@@ -30,3 +31,20 @@ export async function convertObject({
 }) {
   return await convert(value, from, to);
 }
+
+// sats -> bch
+export function toBch(sats: bigint): number {
+  return Number(sats) / Number(bchParam.subUnits);
+}
+
+// bch -> sats
+export function toSat(bch: string | number): bigint {
+  return BigInt(Math.round(Number(bch) * Number(bchParam.subUnits)));
+}
+
+export async function toCurrency(
+  sats: bigint,
+  currency: string
+): Promise<number> {
+  return convert(Number(sats), "sat", currency);
+}