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

package/src/wallet/HDWallet.test.ts

@@ -3,6 +3,9 @@ import { HDWallet, RegTestHDWallet } from "./HDWallet";
 import { RegTestWallet, Wallet } from "./Wif";
 import { Config } from "../config";
 import { getNextUnusedIndex } from "../util/hd";
+import { NFTCapability } from "../interface";
+import { TokenMintRequest, TokenSendRequest } from "./model";
+import { stringify } from "../cache";
 
 const expectedXpub =
   "xpub6CGqRCnS5qDfyxtzV3y3tj8CY7qf3z3GiB2qnCUTdNkhpNxbLtobrU5ZXBVPG3rzPcBUpJAoj3K1u1jyDwKuduL71gLPm27Tckc85apgQRr";
@@ -93,7 +96,7 @@ describe("HDWallet", () => {
       (async () => 1)(),
       new Promise((resolve) => resolve(2)),
     ]);
-    expect(JSON.stringify(result)).toBe(JSON.stringify([1, 2]));
+    expect(stringify(result)).toBe(stringify([1, 2]));
   });
 
   it("deposit indexes", async () => {
@@ -106,30 +109,26 @@ describe("HDWallet", () => {
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(0),
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
     expect(hdWallet.depositIndex).toBe(1);
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(1),
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
     expect(hdWallet.depositIndex).toBe(2);
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(4),
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
     expect(hdWallet.depositIndex).toBe(5);
 
     // beyond gap size, should not update index
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(30),
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
     expect(hdWallet.depositIndex).toBe(5);
 
@@ -143,16 +142,15 @@ describe("HDWallet", () => {
     );
 
     const hdWallet = await RegTestHDWallet.newRandom();
-    expect(await hdWallet.getBalance("sat")).toBe(0);
+    expect(await hdWallet.getBalance()).toBe(0n);
 
     const depositAddress = hdWallet.getDepositAddress();
     await fundingWallet.send({
       cashaddr: depositAddress,
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
 
-    expect(await hdWallet.getBalance("sat")).toBe(100000);
+    expect(await hdWallet.getBalance()).toBe(100000n);
 
     const depositAddress2 = hdWallet.getDepositAddress();
     expect(depositAddress).not.toBe(depositAddress2);
@@ -160,63 +158,61 @@ describe("HDWallet", () => {
     // send more funds to new deposit address
     await fundingWallet.send({
       cashaddr: depositAddress2,
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
 
-    expect(await hdWallet.getBalance("sat")).toBe(200000);
+    expect(await hdWallet.getBalance()).toBe(200000n);
 
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(0))
-      ).getBalance("sat")
-    ).toBe(100000);
+      ).getBalance()
+    ).toBe(100000n);
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(1))
-      ).getBalance("sat")
-    ).toBe(100000);
+      ).getBalance()
+    ).toBe(100000n);
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(2))
-      ).getBalance("sat")
-    ).toBe(0);
+      ).getBalance()
+    ).toBe(0n);
 
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getChangeAddress(0))
-      ).getBalance("sat")
-    ).toBe(0);
+      ).getBalance()
+    ).toBe(0n);
 
     const bob = await RegTestWallet.newRandom();
 
     await hdWallet.send({
       cashaddr: bob.getDepositAddress(),
-      value: 150000,
-      unit: "sat",
+      value: 150000n,
     });
 
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(0))
-      ).getBalance("sat")
-    ).toBe(0);
+      ).getBalance()
+    ).toBe(0n);
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(1))
-      ).getBalance("sat")
-    ).toBe(0);
+      ).getBalance()
+    ).toBe(0n);
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getDepositAddress(2))
-      ).getBalance("sat")
-    ).toBe(0);
+      ).getBalance()
+    ).toBe(0n);
 
     expect(
       await (
         await RegTestWallet.watchOnly(hdWallet.getChangeAddress(0))
-      ).getBalance("sat")
-    ).toBeGreaterThan(50000 - 1000);
+      ).getBalance()
+    ).toBeGreaterThan(50000n - 1000n);
 
     expect(hdWallet.getChangeAddress()).not.toBe(hdWallet.getChangeAddress(0));
     expect(hdWallet.getChangeAddress()).toBe(hdWallet.getChangeAddress(1));
@@ -224,17 +220,16 @@ describe("HDWallet", () => {
     expect(hdWallet.depositIndex).toBe(2);
     expect(hdWallet.changeIndex).toBe(1);
 
-    expect(await bob.getBalance("sat")).toBe(150000);
+    expect(await bob.getBalance()).toBe(150000n);
 
-    expect(await hdWallet.getBalance("sat")).toBe(49639); // minus fees
-
-    expect((await hdWallet.getMaxAmountToSend()).sat).toBe(49407);
+    expect(await hdWallet.getBalance()).toBe(49639n); // minus fees
 
+    expect(await hdWallet.getMaxAmountToSend()).toBe(49407n);
     const charlie = await RegTestWallet.newRandom();
     await hdWallet.sendMax(charlie.cashaddr);
 
-    expect(await charlie.getBalance("sat")).toBe(49407);
-    expect(await hdWallet.getBalance("sat")).toBe(0);
+    expect(await charlie.getBalance()).toBe(49407n);
+    expect(await hdWallet.getBalance()).toBe(0n);
   });
 
   it("Should build unsigned transactions from an HDWallet", async () => {
@@ -243,22 +238,20 @@ describe("HDWallet", () => {
     );
 
     const hdWallet = await RegTestHDWallet.newRandom();
-    expect(await hdWallet.getBalance("sat")).toBe(0);
+    expect(await hdWallet.getBalance()).toBe(0n);
 
     const depositAddress = hdWallet.getDepositAddress();
     await fundingWallet.send({
       cashaddr: depositAddress,
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
 
-    expect(await hdWallet.getBalance("sat")).toBe(100000);
+    expect(await hdWallet.getBalance()).toBe(100000n);
 
     const unsignedTx = await hdWallet.send(
       {
         cashaddr: (await RegTestWallet.newRandom()).getDepositAddress(),
-        value: 50000,
-        unit: "sat",
+        value: 50000n,
       },
       {
         buildUnsigned: true,
@@ -291,23 +284,23 @@ describe("HDWallet", () => {
     // check cache data is there in other instance
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))
+      otherWallet.walletCache.get(hdWallet.getDepositAddress(0))
     ).toBeDefined();
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getDepositAddress(99))
+      otherWallet.walletCache.get(hdWallet.getDepositAddress(99))
     ).not.toBeDefined();
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getDepositAddress(100))
+      otherWallet.walletCache.get(hdWallet.getDepositAddress(100))
     ).toBeDefined();
 
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getChangeAddress(0))
+      otherWallet.walletCache.get(hdWallet.getChangeAddress(0))
     ).toBeDefined();
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getChangeAddress(99))
+      otherWallet.walletCache.get(hdWallet.getChangeAddress(99))
     ).not.toBeDefined();
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getChangeAddress(100))
+      otherWallet.walletCache.get(hdWallet.getChangeAddress(100))
     ).toBeDefined();
 
     Config.UseMemoryCache = memoryCacheValue;
@@ -322,7 +315,7 @@ describe("HDWallet", () => {
     // get some addresses to populate cache
     hdWallet.getDepositAddress(0);
     expect(
-      hdWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))?.status
+      hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.status
     ).toBeNull();
 
     const fundingWallet = await RegTestWallet.fromId(
@@ -330,16 +323,14 @@ describe("HDWallet", () => {
     );
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(0),
-      value: 100000,
-      unit: "sat",
+      value: 100000n,
     });
 
     expect(
-      hdWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))?.status
+      hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.status
     ).not.toBeNull();
     expect(
-      hdWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))?.utxos
-        .length
+      hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.utxos.length
     ).toBe(1);
 
     // persist cache
@@ -349,24 +340,188 @@ describe("HDWallet", () => {
     const otherWallet = await RegTestHDWallet.fromId(hdWallet.toDbString());
     await otherWallet.watchPromise; // ensure any async init is done
     expect(
-      otherWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))
-        ?.status
+      otherWallet.walletCache.get(hdWallet.getDepositAddress(0))?.status
     ).not.toBeNull();
     expect(
-      hdWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))?.utxos
-        .length
+      hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.utxos.length
     ).toBe(1);
     expect(
-      JSON.stringify(
-        hdWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))?.utxos
-      )
+      stringify(hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.utxos)
     ).toBe(
-      JSON.stringify(
-        otherWallet.walletCache.getByAddress(hdWallet.getDepositAddress(0))
-          ?.utxos
+      stringify(
+        otherWallet.walletCache.get(hdWallet.getDepositAddress(0))?.utxos
       )
     );
 
     Config.UseMemoryCache = memoryCacheValue;
   });
+
+  it("Cashtokens integration test", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const alice = await RegTestHDWallet.newRandom();
+    await fundingWallet.send({
+      cashaddr: alice.getDepositAddress(),
+      value: 1000000n,
+    });
+
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.getDepositAddress(1),
+      nft: {
+        capability: NFTCapability.minting,
+        commitment: "abcd",
+      },
+      amount: 1000n,
+    });
+
+    const tokenId = genesisResponse.categories![0];
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // mint 2 NFTs, amount reducing
+    const response = await alice.tokenMint(tokenId, [
+      new TokenMintRequest({
+        cashaddr: alice.getDepositAddress(2),
+        nft: {
+          capability: NFTCapability.none,
+          commitment: "",
+        },
+      }),
+      new TokenMintRequest({
+        cashaddr: alice.getDepositAddress(3),
+        nft: {
+          capability: NFTCapability.mutable,
+          commitment: "00",
+        },
+      }),
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(3);
+    expect(tokenId).toEqual(response.categories![0]);
+
+    const bob = await RegTestWallet.newRandom();
+    await alice.send([
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        category: tokenId,
+        nft: {
+          capability: NFTCapability.minting,
+          commitment: "abcd",
+        },
+        amount: 1000n,
+      }),
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        category: tokenId,
+        nft: {
+          capability: NFTCapability.none,
+          commitment: "",
+        },
+      }),
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        category: tokenId,
+        nft: {
+          capability: NFTCapability.mutable,
+          commitment: "00",
+        },
+      }),
+    ]);
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    expect((await alice.getTokenUtxos(tokenId)).length).toBe(0);
+    const bobTokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(bobTokenUtxos.length).toBe(3);
+    expect(tokenId).toEqual(response.categories![0]);
+  });
+
+  test("Test enforcing token addresses", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const alice = await RegTestHDWallet.newRandom();
+    await fundingWallet.send({
+      cashaddr: alice.getDepositAddress(),
+      value: 1000000n,
+    });
+
+    const genesisResponse = await alice.tokenGenesis({
+      amount: 100n,
+    });
+    const category = genesisResponse.categories![0];
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    const previousValue = Config.EnforceCashTokenReceiptAddresses;
+
+    const wrap = (addr) => {
+      return new Promise((resolve) => {
+        resolve(new TokenSendRequest({ cashaddr: addr, category: "" }));
+      });
+    };
+
+    Config.EnforceCashTokenReceiptAddresses = false;
+    await expect(wrap(alice.getDepositAddress())).resolves.not.toThrow();
+    await expect(wrap(alice.getTokenDepositAddress())).resolves.not.toThrow();
+
+    await expect(
+      alice.send(
+        new TokenSendRequest({
+          cashaddr: alice.getDepositAddress(),
+          category: category,
+          amount: 1n,
+        })
+      )
+    ).resolves.not.toThrow();
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    await expect(
+      alice.send(
+        new TokenSendRequest({
+          cashaddr: alice.getTokenDepositAddress(),
+          category: category,
+          amount: 2n,
+        })
+      )
+    ).resolves.not.toThrow();
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    Config.EnforceCashTokenReceiptAddresses = true;
+    await expect(wrap(alice.getDepositAddress())).rejects.toThrow();
+    await expect(wrap(alice.getTokenDepositAddress())).resolves.not.toThrow();
+
+    await expect(
+      (async () =>
+        await alice.send(
+          new TokenSendRequest({
+            cashaddr: alice.getDepositAddress(),
+            category: category,
+            amount: 1n,
+          })
+        ))()
+    ).rejects.toThrow();
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    await expect(
+      alice.send(
+        new TokenSendRequest({
+          cashaddr: alice.getTokenDepositAddress(),
+          category: category,
+          amount: 2n,
+        })
+      )
+    ).resolves.not.toThrow();
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    Config.EnforceCashTokenReceiptAddresses = previousValue;
+  });
 });

package/src/wallet/Util.ts

@@ -142,7 +142,7 @@ export class Util {
             ],
             hex: binToHex(output.lockingBytecode),
           } as ElectrumRawTransactionVoutScriptPubKey,
-          value: Number(output.valueSatoshis) / bchParam.subUnits,
+          value: Number(output.valueSatoshis) / Number(bchParam.subUnits),
         };
       }
     );