mainnet-js 0.5.8 → 1.0.0-rc.1

package/src/wallet/Cashtokens.test.ts

@@ -0,0 +1,475 @@
+import { RegTestWallet, TestNetWallet, Wallet } from "./Wif";
+import { initProviders, disconnectProviders } from "../network/Connection";
+import { SendRequest, TokenMintRequest, TokenSendRequest } from "./model";
+import { Network, NFTCapability } from "../interface";
+import { binToHex, utf8ToBin } from "@bitauth/libauth";
+import { delay } from "../util";
+
+beforeAll(async () => {
+  await initProviders([Network.REGTEST]);
+});
+afterAll(async () => {
+  await disconnectProviders([Network.REGTEST]);
+});
+
+describe(`Test cashtokens`, () => {
+  test("Test tokens will not be burned when sending bch value", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const genesisResponse = await alice.tokenGenesis({
+      amount: 100,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    await alice.send([
+      new SendRequest({
+        cashaddr: bob.cashaddr!,
+        value: 5000,
+        unit: "sat",
+      }),
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        amount: 25,
+        tokenId: tokenId,
+      }),
+    ]);
+    expect(await bob.getTokenBalance(tokenId)).toBe(25);
+    expect(await bob.getBalance("sat")).toBe(5000);
+
+    await bob.send(
+      new SendRequest({
+        cashaddr: alice.cashaddr!,
+        value: 1000,
+        unit: "sat",
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(25);
+    expect(await bob.getBalance("sat")).toBe(3780);
+
+    await bob.sendMax(alice.cashaddr!);
+    expect(await bob.getTokenBalance(tokenId)).toBe(25);
+    expect(await bob.getBalance("sat")).toBe(0);
+  });
+
+  test("Test fungible cashtoken genesis and sending", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const genesisResponse = await alice.tokenGenesis({
+      amount: 100,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    const response = await alice.send([
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        amount: 25,
+        tokenId: tokenId,
+      }),
+      new TokenSendRequest({
+        cashaddr: alice.cashaddr!,
+        amount: 25,
+        tokenId: tokenId,
+      }),
+    ]);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(2);
+    expect(await alice.getTokenBalance(tokenId)).toBe(75);
+    expect(await bob.getTokenBalance(tokenId)).toBe(25);
+  });
+
+  test("Test NFT cashtoken genesis and sending", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      capability: NFTCapability.mutable,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(0);
+    const nftTokenBalance = await alice.getNftTokenBalance(tokenId);
+    expect(nftTokenBalance).toBe(1);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    const response = await alice.send([
+      {
+        cashaddr: bob.cashaddr!,
+        tokenId: tokenId,
+      } as any,
+    ]);
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    expect(await alice.getNftTokenBalance(tokenId)).toBe(0);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(0);
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    const bobTokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(bobTokenUtxos.length).toBe(1);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+    expect(bobTokenUtxos[0].token?.commitment).toEqual("abcd");
+  });
+
+  test("Test immutable NFT cashtoken genesis and sending, error on mutation", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      capability: NFTCapability.none,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(0);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    await expect(
+      alice.send([
+        new TokenSendRequest({
+          cashaddr: alice.cashaddr!,
+          tokenId: tokenId,
+          commitment: "abcd02",
+        }),
+      ])
+    ).rejects.toThrow("Can not change the commitment of an immutable token");
+  });
+
+  test("Test mutable NFT cashtoken genesis and mutation", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      capability: NFTCapability.mutable,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(0);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    const response = await alice.send([
+      new TokenSendRequest({
+        cashaddr: alice.cashaddr!,
+        tokenId: tokenId,
+        commitment: "abcd02",
+      }),
+    ]);
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(1);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+    expect(newTokenUtxos[0].token?.commitment).toEqual("abcd02");
+  });
+
+  test("Test minting NFT cashtoken genesis and minting", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      capability: NFTCapability.minting,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(0);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    const response = await alice.tokenMint(tokenId, [
+      new TokenMintRequest({
+        cashaddr: alice.cashaddr!,
+      }),
+      new TokenMintRequest({
+        cashaddr: alice.cashaddr!,
+      }),
+    ]);
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(3);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+  });
+
+  test("Test minting NFT and optionally burning FT cashtoken", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      amount: 4,
+      capability: NFTCapability.minting,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(4);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    // mint 2 NFTs, amount reducing
+    const response = await alice.tokenMint(
+      tokenId,
+      [
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+      ],
+      true
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(2);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(3);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+
+    // mint 2 more NFTs without amount reducing
+    const ftResponse = await alice.tokenMint(
+      tokenId,
+      [
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+      ],
+      false
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(2);
+    const ftTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(ftTokenUtxos.length).toBe(5);
+    expect(tokenId).toEqual(ftResponse.tokenIds![0]);
+
+    // we are going to hit amount -1, when minting 3 more NFTs
+    // check that it will stop at 0
+    const ft2Response = await alice.tokenMint(
+      tokenId,
+      [
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+        new TokenMintRequest({
+          cashaddr: alice.cashaddr!,
+        }),
+      ],
+      true
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    const ft2TokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(ft2TokenUtxos.length).toBe(8);
+    expect(tokenId).toEqual(ft2Response.tokenIds![0]);
+  });
+
+  test("Test explicit burning of FT", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      amount: 4,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(4);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    // burn 5 FT
+    const response = await alice.tokenBurn(
+      {
+        tokenId: tokenId,
+        amount: 5,
+      },
+      "burn"
+    );
+
+    const rawTx = await alice.provider!.getRawTransaction(response.txId, true);
+    expect(rawTx!.vout.length).toEqual(3);
+    expect(rawTx!.vout[0].scriptPubKey.type).toEqual("nulldata");
+    expect(rawTx!.vout[0].scriptPubKey.hex).toContain(
+      binToHex(utf8ToBin("burn"))
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(0);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+  });
+
+  test("Test explicit burning of FT+NFT", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const genesisResponse = await alice.tokenGenesis({
+      cashaddr: alice.cashaddr!,
+      amount: 4,
+      capability: NFTCapability.minting,
+      commitment: "abcd",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(4);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+
+    // burn 1 FT
+    const response = await alice.tokenBurn(
+      {
+        tokenId: tokenId,
+        amount: 1,
+        capability: NFTCapability.minting,
+        commitment: "abcd",
+      },
+      "burn"
+    );
+
+    const rawTx = await alice.provider!.getRawTransaction(response.txId, true);
+    expect(rawTx!.vout.length).toEqual(3);
+    expect(rawTx!.vout[0].scriptPubKey.type).toEqual("nulldata");
+    expect(rawTx!.vout[0].scriptPubKey.hex).toContain(
+      binToHex(utf8ToBin("burn"))
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(3);
+    expect((await alice.getAllTokenBalances())[tokenId]).toBe(3);
+    const newTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(1);
+    expect(await alice.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await alice.getAllNftTokenBalances())[tokenId || 0]).toBe(1);
+    expect(tokenId).toEqual(response.tokenIds![0]);
+
+    // burn the rest FTs
+    const ftResponse = await alice.tokenBurn(
+      {
+        tokenId: tokenId,
+        amount: 5,
+        capability: NFTCapability.minting,
+        commitment: "abcd",
+      },
+      "burn"
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    const ftTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(ftTokenUtxos.length).toBe(1);
+    expect(tokenId).toEqual(ftResponse.tokenIds![0]);
+
+    // burn the NFT too
+    const nftResponse = await alice.tokenBurn(
+      {
+        tokenId: tokenId,
+        capability: NFTCapability.minting,
+        commitment: "abcd",
+      },
+      "burn"
+    );
+    expect(await alice.getTokenBalance(tokenId)).toBe(0);
+    expect((await alice.getAllTokenBalances())[tokenId] || 0).toBe(0);
+    const nftTokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(nftTokenUtxos.length).toBe(0);
+    expect(tokenId).toEqual(nftResponse.tokenIds![0]);
+    expect(await alice.getNftTokenBalance(tokenId)).toBe(0);
+    expect((await alice.getAllNftTokenBalances())[tokenId] || 0).toBe(0);
+  });
+
+  test("Test cashtoken satoshi values and fee calculations", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const genesisResponse = await alice.tokenGenesis({
+      amount: 100,
+      value: 7000,
+      cashaddr: bob.cashaddr!,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await bob.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    expect(tokenUtxos[0].satoshis).toBe(7000);
+
+    // lower the token satoshi value
+    const response = await bob.send([
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        amount: 100,
+        tokenId: tokenId,
+        value: 1500,
+      }),
+    ]);
+    let newTokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(1);
+    expect(await bob.getTokenBalance(tokenId)).toBe(100);
+
+    let bobUtxos = await bob.getAddressUtxos(bob.cashaddr!);
+    expect(bobUtxos.length).toBe(2);
+    expect(bobUtxos[0].satoshis).toBe(1500);
+    expect(bobUtxos[1].satoshis).toBe(5245);
+
+    // raise the token satoshi value
+    await bob.send([
+      new TokenSendRequest({
+        cashaddr: bob.cashaddr!,
+        amount: 100,
+        tokenId: tokenId,
+        value: 3000,
+      }),
+    ]);
+    newTokenUtxos = await bob.getTokenUtxos(tokenId);
+    expect(newTokenUtxos.length).toBe(1);
+    expect(await bob.getTokenBalance(tokenId)).toBe(100);
+
+    bobUtxos = await bob.getAddressUtxos(bob.cashaddr!);
+    expect(bobUtxos.length).toBe(2);
+    expect(bobUtxos[0].satoshis).toBe(3000);
+    expect(bobUtxos[1].satoshis).toBe(3349);
+  });
+
+  test("Test cashtoken waiting and watching balance", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+
+    const genesisResponse = await alice.tokenGenesis({
+      amount: 100,
+      value: 5000,
+      cashaddr: alice.cashaddr!,
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+    const tokenBalance = await alice.getTokenBalance(tokenId);
+    expect(tokenBalance).toBe(100);
+    const tokenUtxos = await alice.getTokenUtxos(tokenId);
+    expect(tokenUtxos.length).toBe(1);
+    expect(tokenUtxos[0].satoshis).toBe(5000);
+
+    let seenBalance = 0;
+    setTimeout(
+      () =>
+        alice.send([
+          new TokenSendRequest({
+            cashaddr: bob.cashaddr!,
+            amount: 100,
+            tokenId: tokenId,
+            value: 1500,
+          }),
+        ]),
+      0
+    );
+
+    const cancel = bob.watchTokenBalance(tokenId, (balance) => {
+      seenBalance = balance;
+    });
+
+    const balance = await bob.waitForTokenBalance(tokenId, 100);
+    expect(balance).toBe(100);
+    expect(seenBalance).toBe(100);
+    await cancel();
+    await delay(500);
+  });
+});

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

@@ -1,9 +1,8 @@
-const { default: BigNumber } = require("bignumber.js");
 const playwright = require("playwright");
-const { GsppProvider } = require("../slp");
+
 const PAGE_URL = "http://localhost:8080";
 
-describe(`Wallet should function in the browser`, () => {
+describe.skip(`Wallet should function in the browser`, () => {
   let browser = null;
   let page = null;
 
@@ -93,11 +92,10 @@ describe(`Wallet should function in the browser`, () => {
       async ([wif, tokenId]) => {
         const wallet = await TestNetWallet.fromId(`wif:testnet:${wif}`);
 
-        // FIXME: we do not have gspp testnet yet
-        if (wallet.slp.provider instanceof GsppProvider) {
-          console.warn("we do not have gspp testnet yet");
-          return { value: new BigNumber(1) };
-        }
+        // // FIXME: we do not have gspp testnet yet
+        // if (wallet.slp.provider instanceof GsppProvider) {
+        //   console.warn("we do not have gspp testnet yet");
+        // }
 
         const bobWallet = await TestNetWallet.newRandom();
 

package/src/wallet/Slp.test.ts

@@ -1,4 +1,4 @@
-import { RegTestWallet, TestNetWallet, Wallet } from "../wallet/Wif";
+import { RegTestWallet, TestNetWallet, Wallet } from "./Wif";
 
 import { Network } from "..";
 import { disconnectProviders, initProviders } from "../network";
@@ -15,7 +15,7 @@ import { GsppProvider } from "../slp/GsppProvider";
 import { createSlpWallet, walletFromId } from "./createWallet";
 import { WalletTypeEnum } from "./enum";
 
-describe("Slp wallet tests", () => {
+describe.skip("Slp wallet tests", () => {
   beforeAll(async () => {
     await initProviders([Network.MAINNET, Network.REGTEST]);
   });

package/src/wallet/Slp.ts

@@ -8,7 +8,7 @@ import {
   WatchWallet,
   TestNetWatchWallet,
   RegTestWatchWallet,
-} from "../wallet/Wif";
+} from "../wallet/Wif.js";
 import {
   SlpFormattedUtxo,
   SlpGenesisOptions,
@@ -22,38 +22,41 @@ import {
   SlpTokenType,
   SlpTxI,
   SlpUtxoI,
-} from "../slp/interface";
-import { SlpDbProvider } from "../slp/SlpDbProvider";
-import { ImageI } from "../qr/interface";
-import { qrAddress } from "../qr/Qr";
-import { TxI, UtxoI } from "../interface";
-import { ElectrumRawTransaction } from "../network/interface";
+} from "../slp/interface.js";
+import { SlpDbProvider } from "../slp/SlpDbProvider.js";
+import { ImageI } from "../qr/interface.js";
+import { qrAddress } from "../qr/Qr.js";
+import { TxI, UtxoI } from "../interface.js";
+import { ElectrumRawTransaction } from "../network/interface.js";
 import BigNumber from "bignumber.js";
-import { getRelayFeeCache } from "../network/getRelayFeeCache";
+import { getRelayFeeCache } from "../network/getRelayFeeCache.js";
 import {
   buildEncodedTransaction,
   getFeeAmount,
   getSuitableUtxos,
-} from "../transaction/Wif";
+} from "../transaction/Wif.js";
 import {
   SlpGetGenesisOutputs,
   SlpGetMintOutputs,
   SlpGetSendOutputs,
-} from "../slp/SlpLibAuth";
-import { binToHex } from "@bitauth/libauth";
-import { SendRequest } from "./model";
+} from "../slp/SlpLibAuth.js";
+import { binToHex, Output } from "@bitauth/libauth";
+import { SendRequest } from "./model.js";
 import {
   SlpCancelWatchFn,
   SlpProvider,
   SlpWatchBalanceCallback,
   SlpWatchTransactionCallback,
-} from "../slp/SlpProvider";
-import { toCashAddress, toSlpAddress } from "../util/bchaddr";
-import { GsppProvider } from "../slp/GsppProvider";
-import { delay } from "../util/delay";
-import { Util } from "./Util";
-import { Mainnet } from "../index";
-import { FeePaidByEnum } from "./enum";
+} from "../slp/SlpProvider.js";
+import { toCashAddress, toSlpAddress } from "../util/bchaddr.js";
+import { GsppProvider } from "../slp/GsppProvider.js";
+import { delay } from "../util/delay.js";
+import { Util } from "./Util.js";
+import { FeePaidByEnum } from "./enum.js";
+import {
+  getRuntimePlatform,
+  RuntimePlatform,
+} from "../util/getRuntimePlatform.js";
 
 /**
  * Class to manage an slp enabled wallet.
@@ -82,7 +85,7 @@ export class Slp {
 
     let provider = Slp.defaultProvider;
     if (
-      Mainnet.getRuntimePlatform() === Mainnet.RuntimePlatform.node &&
+      getRuntimePlatform() === RuntimePlatform.node &&
       process.env.SLP_PROVIDER
     )
       provider = process.env.SLP_PROVIDER!;
@@ -653,7 +656,7 @@ export class Slp {
   private async processSlpTransaction(
     fundingBchUtxos: UtxoI[],
     slpOutputsResult: {
-      SlpOutputs: { lockingBytecode: Uint8Array; satoshis: Uint8Array }[];
+      SlpOutputs: Output[];
       FundingSlpUtxos: SlpUtxoI[];
       BchSendRequests: SendRequest[];
     },
@@ -692,7 +695,8 @@ export class Slp {
       fundingBchUtxos,
       BigInt(bchSpendAmount) + BigInt(feeEstimate),
       bestHeight,
-      FeePaidByEnum.change
+      FeePaidByEnum.change,
+      slpOutputsResult.BchSendRequests
     );
 
     if (fundingUtxos.length === 0) {

package/src/wallet/Util.ts

@@ -8,16 +8,13 @@ import {
   Wallet,
   WatchWallet,
   WifWallet,
-} from "../wallet/Wif";
+} from "../wallet/Wif.js";
 import {
-  binToBigIntUint64LE,
   binToHex,
   decodeTransaction as decodeTransactionLibAuth,
   hexToBin,
-  instantiateSha256,
   lockingBytecodeToCashAddress,
   Transaction as LibAuthTransaction,
-  TransactionDecodingError,
 } from "@bitauth/libauth";
 import {
   ElectrumRawTransaction,
@@ -25,10 +22,9 @@ import {
   ElectrumRawTransactionVinScriptSig,
   ElectrumRawTransactionVout,
   ElectrumRawTransactionVoutScriptPubKey,
-} from "../network/interface";
-import { bchParam } from "../chain";
-
-let sha256;
+} from "../network/interface.js";
+import { bchParam } from "../chain.js";
+import { getTransactionHash } from "../util/transaction.js";
 
 /**
  * Class with various wallet utilities.
@@ -49,19 +45,13 @@ export class Util {
   }
 
   public async getTransactionHash(rawTransactionHex: string): Promise<string> {
-    const transactionBin = hexToBin(rawTransactionHex);
-
-    if (!sha256) {
-      sha256 = await instantiateSha256();
-    }
-    // transaction hash is a double sha256 of a raw transaction data, reversed byte order
-    return binToHex(sha256.hash(sha256.hash(transactionBin)).reverse());
+    return getTransactionHash(rawTransactionHex);
   }
 
   public static async getTransactionHash(
     rawTransactionHex: string
   ): Promise<string> {
-    return new this.walletType().util.getTransactionHash(rawTransactionHex);
+    return getTransactionHash(rawTransactionHex);
   }
 
   public async decodeTransaction(
@@ -85,8 +75,8 @@ export class Util {
     }
 
     const result = decodeTransactionLibAuth(transactionBin);
-    if (result === TransactionDecodingError.invalidFormat) {
-      throw Error(TransactionDecodingError.invalidFormat);
+    if (typeof result === "string") {
+      throw Error(result);
     }
 
     const transaction = this.mapToElectrumRawTransaction(
@@ -147,8 +137,7 @@ export class Util {
             ],
             hex: binToHex(output.lockingBytecode),
           } as ElectrumRawTransactionVoutScriptPubKey,
-          value:
-            Number(binToBigIntUint64LE(output.satoshis)) / bchParam.subUnits,
+          value: Number(output.valueSatoshis) / bchParam.subUnits,
         };
       }
     );