mainnet-js 1.1.0 → 1.1.2

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);
@@ -113,7 +115,7 @@ describe(`Wallet should function in the browser`, () => {
             commitment: "abcd02",
           }),
         ])
-      ).rejects.toThrow("Can not change the commitment of an immutable token");
+      ).rejects.toThrow("No suitable token utxos available to send token");
     }, process.env.ALICE_ID);
   });
 
@@ -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

@@ -7,7 +7,13 @@ import {
   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";
 
@@ -110,6 +116,8 @@ describe(`Test cashtokens`, () => {
     expect(newTokenUtxos.length).toBe(2);
     expect(await alice.getTokenBalance(tokenId)).toBe(75);
     expect(await bob.getTokenBalance(tokenId)).toBe(25);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(0);
+    expect((await bob.getAllNftTokenBalances())[tokenId] || 0).toBe(0);
   });
 
   test("Test NFT cashtoken genesis and sending", async () => {
@@ -132,6 +140,8 @@ describe(`Test cashtokens`, () => {
       {
         cashaddr: bob.cashaddr!,
         tokenId: tokenId,
+        capability: NFTCapability.mutable,
+        commitment: "abcd",
       } as any,
     ]);
     expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -167,7 +177,7 @@ describe(`Test cashtokens`, () => {
           commitment: "abcd02",
         }),
       ])
-    ).rejects.toThrow("Can not change the commitment of an immutable token");
+    ).rejects.toThrow("No suitable token utxos available to send token");
   });
 
   test("Test mutable NFT cashtoken genesis and mutation", async () => {
@@ -187,6 +197,7 @@ describe(`Test cashtokens`, () => {
       new TokenSendRequest({
         cashaddr: alice.cashaddr!,
         tokenId: tokenId,
+        capability: NFTCapability.mutable,
         commitment: "abcd02",
       }),
     ]);
@@ -219,6 +230,7 @@ describe(`Test cashtokens`, () => {
       new TokenMintRequest({
         cashaddr: alice.cashaddr!,
         commitment: "test2",
+        capability: NFTCapability.none,
       }),
     ]);
     expect(await alice.getTokenBalance(tokenId)).toBe(0);
@@ -248,9 +260,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
@@ -266,9 +282,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
@@ -285,12 +305,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
@@ -490,6 +516,8 @@ describe(`Test cashtokens`, () => {
             amount: 100,
             tokenId: tokenId,
             value: 1500,
+            capability: NFTCapability.minting,
+            commitment: "test",
           }),
         ])),
       0
@@ -615,6 +643,314 @@ describe(`Test cashtokens`, () => {
     expect(tokenUtxos2.length).toBe(1);
   });
 
+  test("Test minting NFTs not burn tokens", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0a",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(1);
+  });
+
+  test("Test sending NFTs after burning minting token", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0b",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(3);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(3);
+
+    await bob.tokenBurn({
+      tokenId: tokenId,
+      capability: "minting",
+      commitment: "",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0a",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0b",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(0);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(0);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(2);
+  });
+
+  test("Test sending NFTs with empty commitment", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "00",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0b",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(3);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(3);
+
+    await bob.tokenBurn({
+      tokenId: tokenId,
+      capability: "minting",
+      commitment: "00",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await expect(
+      bob.send(
+        new TokenSendRequest({
+          tokenId: tokenId,
+          capability: "none",
+          commitment: "",
+          cashaddr: charlie.cashaddr!,
+        })
+      )
+    ).rejects.toThrow(
+      "No suitable token utxos available to send token with id"
+    );
+  });
+
+  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("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);
   }