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

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[] = [];
@@ -154,19 +153,20 @@ export function prepareInputs({
 
     const libAuthToken = i.token && {
       amount: BigInt(i.token.amount),
-      category: hexToBin(i.token.tokenId),
+      category: hexToBin(i.token.category),
       nft:
-        i.token.capability !== undefined || i.token.commitment !== undefined
+        i.token.nft?.capability !== undefined ||
+        i.token.nft?.commitment !== undefined
           ? {
-              capability: i.token.capability,
+              capability: i.token.nft?.capability,
               commitment:
-                i.token.commitment !== undefined &&
-                hexToBin(i.token.commitment!),
+                i.token.nft?.commitment !== undefined &&
+                hexToBin(i.token.nft?.commitment!),
             }
           : 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 +231,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.`
@@ -271,13 +271,14 @@ export function prepareTokenOutputs(request: TokenSendRequest): Output {
 
   const libAuthToken = {
     amount: BigInt(token.amount),
-    category: hexToBin(token.tokenId),
+    category: hexToBin(token.category),
     nft:
-      token.capability !== undefined || token.commitment !== undefined
+      token.nft?.capability !== undefined || token.nft?.commitment !== undefined
         ? {
-            capability: token.capability,
+            capability: token.nft?.capability,
             commitment:
-              token.commitment !== undefined && hexToBin(token.commitment!),
+              token.nft?.commitment !== undefined &&
+              hexToBin(token.nft?.commitment!),
           }
         : undefined,
   };
@@ -320,13 +321,13 @@ export async function getSuitableUtxos(
   if (tokenOperation === "send") {
     for (const request of tokenRequests) {
       const tokenInputs = availableInputs.filter(
-        (val) => val.token?.tokenId === request.tokenId
+        (val) => val.token?.category === request.category
       );
       const sameCommitmentTokens = [...suitableUtxos, ...tokenInputs]
         .filter(
           (val) =>
-            val.token?.capability === request.capability &&
-            val.token?.commitment === request.commitment
+            val.token?.nft?.capability === request.nft?.capability &&
+            val.token?.nft?.commitment === request.nft?.commitment
         )
         .filter(
           (val) =>
@@ -349,13 +350,15 @@ export async function getSuitableUtxos(
       }
 
       if (
-        request.capability === NFTCapability.minting ||
-        request.capability === NFTCapability.mutable
+        request.nft?.capability === NFTCapability.minting ||
+        request.nft?.capability === NFTCapability.mutable
       ) {
         const changeCommitmentTokens = [
           ...suitableUtxos,
           ...tokenInputs,
-        ].filter((val) => val.token?.capability === request.capability);
+        ].filter(
+          (val) => val.token?.nft?.capability === request.nft?.capability
+        );
         if (changeCommitmentTokens.length) {
           const input = changeCommitmentTokens[0];
           const index = availableInputs.indexOf(input);
@@ -370,17 +373,17 @@ export async function getSuitableUtxos(
 
       // handle splitting the hybrid (FT+NFT) token into its parts
       if (
-        request.capability === undefined &&
-        request.commitment === undefined &&
+        request.nft?.capability === undefined &&
+        request.nft?.commitment === undefined &&
         [...suitableUtxos, ...tokenInputs]
-          .map((val) => val.token?.tokenId)
-          .includes(request.tokenId)
+          .map((val) => val.token?.category)
+          .includes(request.category)
       ) {
         continue;
       }
 
       throw Error(
-        `No suitable token utxos available to send token with id "${request.tokenId}", capability "${request.capability}", commitment "${request.commitment}"`
+        `No suitable token utxos available to send token with id "${request.category}", capability "${request.nft?.capability}", commitment "${request.nft?.commitment}"`
       );
     }
   }
@@ -451,7 +454,7 @@ export async function getFeeAmountSimple({
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
   discardChange?: boolean;
-}) {
+}): Promise<bigint> {
   const inputSizeP2pkh = 148;
   const outputSizeP2pkh = 34;
 
@@ -462,37 +465,37 @@ export async function getFeeAmountSimple({
         ? inputSizeP2pkh +
           1 +
           34 +
-          Math.round(1 + (curr.token.commitment?.length ?? 0) / 2) +
+          Math.round(1 + (curr.token.nft?.commitment?.length ?? 0) / 2) +
           (curr.token.amount ? 9 : 0)
         : inputSizeP2pkh),
     0
   );
 
-  const outputSize = (sendRequest) => {
-    if (sendRequest.hasOwnProperty("unit")) {
-      return outputSizeP2pkh;
-    } else if (sendRequest.hasOwnProperty("tokenId")) {
+  const outputSize = (sendRequest: SendRequestType) => {
+    if (sendRequest.hasOwnProperty("category")) {
       const tokenRequest = sendRequest as TokenSendRequest;
       return (
         outputSizeP2pkh +
         1 +
         34 +
-        Math.round(1 + (tokenRequest.commitment?.length ?? 0) / 2) +
+        Math.round(1 + (tokenRequest.nft?.commitment?.length ?? 0) / 2) +
         (tokenRequest.amount ? 9 : 0)
       );
     } 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 +515,7 @@ export async function getFeeAmount({
   relayFeePerByteInSatoshi: number;
   feePaidBy: FeePaidByEnum;
   discardChange?: boolean;
-  walletCache?: WalletCacheI;
+  walletCache?: WalletCache;
 }) {
   // build transaction
   if (utxos) {
@@ -522,14 +525,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 +547,7 @@ export async function buildEncodedTransaction({
   inputs,
   outputs,
   signingKey,
-  fee = 0,
+  fee = 0n,
   discardChange = false,
   feePaidBy = FeePaidByEnum.change,
   changeAddress = "",
@@ -552,12 +557,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,

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);
   });
 });