mainnet-js 1.1.1 → 1.1.3

package/src/wallet/Cashtokens.test.headless.js

@@ -77,6 +77,8 @@ describe(`Wallet should function in the browser`, () => {
         new TokenSendRequest({
           cashaddr: bob.cashaddr,
           tokenId: tokenId,
+          capability: NFTCapability.mutable,
+          commitment: "abcd",
         }),
       ]);
       expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -135,6 +137,7 @@ describe(`Wallet should function in the browser`, () => {
         new TokenSendRequest({
           cashaddr: alice.cashaddr,
           tokenId: tokenId,
+          capability: NFTCapability.mutable,
           commitment: "abcd02",
         }),
       ]);
@@ -163,9 +166,13 @@ describe(`Wallet should function in the browser`, () => {
       const response = await alice.tokenMint(tokenId, [
         new TokenMintRequest({
           cashaddr: alice.cashaddr,
+          commitment: "test",
+          capability: NFTCapability.none,
         }),
         new TokenMintRequest({
           cashaddr: alice.cashaddr,
+          commitment: "test2",
+          capability: NFTCapability.none,
         }),
       ]);
       expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -197,9 +204,13 @@ describe(`Wallet should function in the browser`, () => {
         [
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0a",
           }),
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0b",
           }),
         ],
         true
@@ -215,9 +226,13 @@ describe(`Wallet should function in the browser`, () => {
         [
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0c",
           }),
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0d",
           }),
         ],
         false
@@ -234,12 +249,18 @@ describe(`Wallet should function in the browser`, () => {
         [
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0a",
           }),
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0a",
           }),
           new TokenMintRequest({
             cashaddr: alice.cashaddr,
+            capability: NFTCapability.none,
+            commitment: "0a",
           }),
         ],
         true
@@ -425,6 +446,8 @@ describe(`Wallet should function in the browser`, () => {
       const genesisResponse = await alice.tokenGenesis({
         amount: 100,
         value: 5000,
+        capability: NFTCapability.minting,
+        commitment: "test",
         cashaddr: alice.cashaddr,
       });
 
@@ -444,6 +467,8 @@ describe(`Wallet should function in the browser`, () => {
               amount: 100,
               tokenId: tokenId,
               value: 1500,
+              capability: NFTCapability.minting,
+              commitment: "test",
             }),
           ]),
         0
@@ -464,4 +489,140 @@ describe(`Wallet should function in the browser`, () => {
       await Promise.all([cancel(), delay(1000)]);
     }, process.env.ALICE_ID);
   });
+
+  test("Should encode unsigned transactions", async () => {
+    await page.evaluate(async (id) => {
+      const binsAreEqual = (a, b) => {
+        if (a.length !== b.length) {
+          return false;
+        }
+        // eslint-disable-next-line functional/no-let, functional/no-loop-statement, no-plusplus
+        for (let i = 0; i < a.length; i++) {
+          if (a[i] !== b[i]) {
+            return false;
+          }
+        }
+        return true;
+      };
+
+      const aliceWallet = await RegTestWallet.fromId(id);
+      const aliceWatchWallet = await RegTestWallet.watchOnly(
+        aliceWallet.cashaddr
+      );
+
+      {
+        const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+        const { unsignedTransaction, sourceOutputs } =
+          await aliceWatchWallet.tokenGenesis(
+            {
+              capability: "minting",
+              commitment: "00",
+            },
+            undefined,
+            { buildUnsigned: true }
+          );
+        const encodedTransaction = hexToBin(unsignedTransaction);
+        expect(encodedTransaction.length).toBeGreaterThan(0);
+
+        // check transaction was not submitted
+        expect(JSON.stringify(aliceUtxos)).toBe(
+          JSON.stringify(await aliceWallet.getAddressUtxos())
+        );
+
+        const decoded = libauth.decodeTransaction(encodedTransaction);
+        if (typeof decoded === "string") {
+          throw decoded;
+        }
+
+        expect(
+          binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+        ).toBe(true);
+        expect(sourceOutputs.length).toBe(decoded.inputs.length);
+        expect(binToHex(decoded.outputs[0].token?.nft?.commitment)).toBe("00");
+      }
+
+      const genesisResponse = await aliceWallet.tokenGenesis({
+        capability: "minting",
+        commitment: "00",
+      });
+      const tokenId = genesisResponse.tokenIds[0];
+
+      {
+        const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+        const { unsignedTransaction, sourceOutputs } =
+          await aliceWatchWallet.tokenMint(
+            tokenId,
+            {
+              capability: "none",
+              commitment: "0a",
+            },
+            undefined,
+            { buildUnsigned: true }
+          );
+        const encodedTransaction = hexToBin(unsignedTransaction);
+        expect(encodedTransaction.length).toBeGreaterThan(0);
+
+        // check transaction was not submitted
+        expect(JSON.stringify(aliceUtxos)).toBe(
+          JSON.stringify(await aliceWallet.getAddressUtxos())
+        );
+
+        const decoded = libauth.decodeTransaction(encodedTransaction);
+        if (typeof decoded === "string") {
+          throw decoded;
+        }
+
+        expect(
+          binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+        ).toBe(true);
+        expect(sourceOutputs.length).toBe(decoded.inputs.length);
+        expect(binToHex(sourceOutputs[0].token?.nft?.commitment)).toBe("00");
+        expect(binToHex(decoded.outputs[0].token?.nft?.commitment)).toBe("00");
+        expect(binToHex(decoded.outputs[1].token?.nft?.commitment)).toBe("0a");
+      }
+
+      await aliceWallet.tokenMint(tokenId, {
+        capability: "none",
+        commitment: "0a",
+      });
+
+      {
+        const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+        const { unsignedTransaction, sourceOutputs } =
+          await aliceWatchWallet.send(
+            [
+              new TokenSendRequest({
+                tokenId: tokenId,
+                capability: "none",
+                commitment: "0a",
+                cashaddr: aliceWallet.cashaddr,
+              }),
+            ],
+            { buildUnsigned: true }
+          );
+        const encodedTransaction = hexToBin(unsignedTransaction);
+        expect(encodedTransaction.length).toBeGreaterThan(0);
+
+        // check transaction was not submitted
+        expect(JSON.stringify(aliceUtxos)).toBe(
+          JSON.stringify(await aliceWallet.getAddressUtxos())
+        );
+
+        const decoded = libauth.decodeTransaction(encodedTransaction);
+        if (typeof decoded === "string") {
+          throw decoded;
+        }
+
+        expect(
+          binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+        ).toBe(true);
+        expect(sourceOutputs.length).toBe(decoded.inputs.length);
+        expect(binToHex(sourceOutputs[0].token?.nft?.commitment)).toBe("0a");
+        expect(binToHex(decoded.outputs[0].token?.nft?.commitment)).toBe("0a");
+      }
+    }, process.env.ALICE_ID);
+  });
 });

package/src/wallet/Cashtokens.test.ts

@@ -1,13 +1,20 @@
 import { RegTestWallet, TestNetWallet, Wallet } from "./Wif";
 import { initProviders, disconnectProviders } from "../network/Connection";
 import {
+  OpReturnData,
   SendRequest,
   SendResponse,
   TokenMintRequest,
   TokenSendRequest,
 } from "./model";
 import { Network, NFTCapability } from "../interface";
-import { binToHex, utf8ToBin } from "@bitauth/libauth";
+import {
+  binToHex,
+  binsAreEqual,
+  decodeTransaction,
+  hexToBin,
+  utf8ToBin,
+} from "@bitauth/libauth";
 import { delay } from "../util";
 import { Config } from "../config";
 
@@ -134,6 +141,8 @@ describe(`Test cashtokens`, () => {
       {
         cashaddr: bob.cashaddr!,
         tokenId: tokenId,
+        capability: NFTCapability.mutable,
+        commitment: "abcd",
       } as any,
     ]);
     expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -189,6 +198,7 @@ describe(`Test cashtokens`, () => {
       new TokenSendRequest({
         cashaddr: alice.cashaddr!,
         tokenId: tokenId,
+        capability: NFTCapability.mutable,
         commitment: "abcd02",
       }),
     ]);
@@ -221,6 +231,7 @@ describe(`Test cashtokens`, () => {
       new TokenMintRequest({
         cashaddr: alice.cashaddr!,
         commitment: "test2",
+        capability: NFTCapability.none,
       }),
     ]);
     expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -250,9 +261,13 @@ describe(`Test cashtokens`, () => {
       [
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0a",
         }),
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0b",
         }),
       ],
       true
@@ -268,9 +283,13 @@ describe(`Test cashtokens`, () => {
       [
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0c",
         }),
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0d",
         }),
       ],
       false
@@ -287,12 +306,18 @@ describe(`Test cashtokens`, () => {
       [
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0a",
         }),
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0a",
         }),
         new TokenMintRequest({
           cashaddr: alice.cashaddr!,
+          capability: NFTCapability.none,
+          commitment: "0a",
         }),
       ],
       true
@@ -492,6 +517,8 @@ describe(`Test cashtokens`, () => {
             amount: 100,
             tokenId: tokenId,
             value: 1500,
+            capability: NFTCapability.minting,
+            commitment: "test",
           }),
         ])),
       0
@@ -803,6 +830,157 @@ describe(`Test cashtokens`, () => {
     );
   });
 
+  test("Should encode unsigned transactions", async () => {
+    const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
+    const aliceWallet = await RegTestWallet.fromId(aliceWif);
+    const aliceWatchWallet = await RegTestWallet.watchOnly(
+      aliceWallet.cashaddr!
+    );
+
+    {
+      const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+      const { unsignedTransaction, sourceOutputs } =
+        await aliceWatchWallet.tokenGenesis(
+          {
+            capability: "minting",
+            commitment: "00",
+          },
+          undefined,
+          { buildUnsigned: true }
+        );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+      expect(binToHex(decoded.outputs[0].token?.nft?.commitment!)).toBe("00");
+    }
+
+    const genesisResponse = await aliceWallet.tokenGenesis({
+      capability: "minting",
+      commitment: "00",
+    });
+    const tokenId = genesisResponse.tokenIds![0];
+
+    {
+      const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+      const { unsignedTransaction, sourceOutputs } =
+        await aliceWatchWallet.tokenMint(
+          tokenId,
+          {
+            capability: "none",
+            commitment: "0a",
+          },
+          undefined,
+          { buildUnsigned: true }
+        );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+      expect(binToHex(sourceOutputs![0].token?.nft?.commitment!)).toBe("00");
+      expect(binToHex(decoded.outputs[0].token?.nft?.commitment!)).toBe("00");
+      expect(binToHex(decoded.outputs[1].token?.nft?.commitment!)).toBe("0a");
+    }
+
+    await aliceWallet.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    {
+      const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+      const { unsignedTransaction, sourceOutputs } =
+        await aliceWatchWallet.send(
+          [
+            new TokenSendRequest({
+              tokenId: tokenId,
+              capability: "none",
+              commitment: "0a",
+              cashaddr: aliceWallet.cashaddr!,
+            }),
+          ],
+          { buildUnsigned: true }
+        );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+      expect(binToHex(sourceOutputs![0].token?.nft?.commitment!)).toBe("0a");
+      expect(binToHex(decoded.outputs[0].token?.nft?.commitment!)).toBe("0a");
+    }
+  });
+
+  test("Kek", async () => {
+    const aliceWatchWallet = await TestNetWallet.watchOnly("bchtest:zzm0t7f76ye50xh2hr0lmt2a0wage2sutcqnl25ahq");
+
+    // const utxos = (await aliceWatchWallet.getTokenUtxos()).filter(val => val.token?.tokenId.startsWith("4cca"));
+    // console.log(utxos);
+    // return;
+
+
+      const { unsignedTransaction, sourceOutputs } = await aliceWatchWallet.tokenGenesis({
+        cashaddr: aliceWatchWallet.cashaddr!,
+        capability: NFTCapability.minting,
+        commitment: "",
+        value: 1000
+      }, OpReturnData.from(""), { buildUnsigned: true });
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // const decoded = decodeTransaction(encodedTransaction);
+      // if (typeof decoded === "string") {
+      //   throw decoded;
+      // }
+
+      // expect(binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))).toBe(true);
+      // expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+      // expect(binToHex(decoded.outputs[0].token?.nft?.commitment!)).toBe("00");
+
+  });
+
+
   test("Test enforcing token addresses", async () => {
     const bob = await RegTestWallet.newRandom();
 

package/src/wallet/Slp.ts

@@ -682,6 +682,7 @@ export class Slp {
       utxos: fundingBchUtxos,
       sendRequests: slpOutputsResult.BchSendRequests,
       privateKey: this.wallet.privateKey,
+      sourceAddress: this.wallet.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       slpOutputs: slpOutputsResult.SlpOutputs,
       feePaidBy: FeePaidByEnum.change,
@@ -709,19 +710,21 @@ export class Slp {
       utxos: fundingUtxos,
       sendRequests: slpOutputsResult.BchSendRequests,
       privateKey: this.wallet.privateKey,
+      sourceAddress: this.wallet.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       slpOutputs: slpOutputsResult.SlpOutputs,
       feePaidBy: FeePaidByEnum.change,
     });
 
-    const encodedTransaction = await buildEncodedTransaction(
-      fundingUtxos,
-      slpOutputsResult.BchSendRequests,
-      this.wallet.privateKey,
+    const { encodedTransaction } = await buildEncodedTransaction({
+      inputs: fundingUtxos,
+      outputs: slpOutputsResult.BchSendRequests,
+      signingKey: this.wallet.privateKey,
+      sourceAddress: this.wallet.cashaddr!,
       fee,
-      false,
-      slpOutputsResult.SlpOutputs
-    );
+      discardChange: false,
+      slpOutputs: slpOutputsResult.SlpOutputs,
+    });
 
     return this._submitTransaction(encodedTransaction, tokenId);
   }

package/src/wallet/Wif.test.ts

@@ -7,7 +7,13 @@ import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD as DUST } from "../constant";
 import { delay } from "../util/delay";
 import { OpReturnData, SendResponse } from "./model";
 import { ElectrumRawTransaction } from "../network/interface";
-import { binToHex, hexToBin, utf8ToBin } from "@bitauth/libauth";
+import {
+  binToHex,
+  binsAreEqual,
+  decodeTransaction,
+  hexToBin,
+  utf8ToBin,
+} from "@bitauth/libauth";
 import { mine } from "../mine";
 import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider";
 
@@ -1114,4 +1120,98 @@ describe(`Wallet extrema behavior regression testing`, () => {
       (await bob.getMaxAmountToSend({ options: { slpSemiAware: false } })).sat
     ).toBeLessThanOrEqual(546);
   });
+
+  test("Should encode unsigned transactions", async () => {
+    const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
+    const aliceWallet = await RegTestWallet.fromId(aliceWif);
+    const bobWallet = await RegTestWallet.newRandom();
+    aliceWallet.privateKey = undefined;
+
+    const aliceUtxos = await aliceWallet.getAddressUtxos();
+
+    {
+      const { encodedTransaction, sourceOutputs } =
+        await aliceWallet.encodeTransaction(
+          [
+            {
+              cashaddr: bobWallet.cashaddr!,
+              value: 2000,
+              unit: "satoshis",
+            },
+          ],
+          false,
+          { buildUnsigned: true }
+        );
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs.length).toBe(decoded.inputs.length);
+    }
+
+    {
+      const { unsignedTransaction, sourceOutputs } = await aliceWallet.send(
+        [
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 2000,
+            unit: "satoshis",
+          },
+        ],
+        { buildUnsigned: true }
+      );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+    }
+
+    {
+      const { unsignedTransaction, sourceOutputs } = await aliceWallet.sendMax(
+        bobWallet.cashaddr!,
+        { buildUnsigned: true }
+      );
+      const encodedTransaction = hexToBin(unsignedTransaction!);
+      expect(encodedTransaction.length).toBeGreaterThan(0);
+
+      // check transaction was not submitted
+      expect(JSON.stringify(aliceUtxos)).toBe(
+        JSON.stringify(await aliceWallet.getAddressUtxos())
+      );
+
+      const decoded = decodeTransaction(encodedTransaction);
+      if (typeof decoded === "string") {
+        throw decoded;
+      }
+
+      expect(
+        binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
+      ).toBe(true);
+      expect(sourceOutputs!.length).toBe(decoded.inputs.length);
+    }
+  });
 });