mainnet-js 3.0.1 → 3.1.1

package/src/wallet/HDWallet.test.ts

@@ -6,6 +6,9 @@ import { getNextUnusedIndex } from "../util/hd";
 import { NFTCapability } from "../interface";
 import { TokenMintRequest, TokenSendRequest } from "./model";
 import { stringify } from "../cache";
+import { mine } from "../mine";
+import { delay } from "../util/delay";
+import { CancelFn } from "./interface";
 
 const expectedXpub =
   "xpub6CGqRCnS5qDfyxtzV3y3tj8CY7qf3z3GiB2qnCUTdNkhpNxbLtobrU5ZXBVPG3rzPcBUpJAoj3K1u1jyDwKuduL71gLPm27Tckc85apgQRr";
@@ -111,12 +114,16 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(1);
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(1),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(2);
 
     await fundingWallet.send({
@@ -155,6 +162,9 @@ describe("HDWallet", () => {
       { cashaddr: addr0, value: 10000n },
       { cashaddr: addr20, value: 10000n },
     ]);
+    // Wait for seedWallet to see both transactions via electrum
+    while (seedWallet.depositIndex < 21)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Restore wallet from same seed, starting from index 0
     const restoredWallet = await RegTestHDWallet.fromSeed(
@@ -181,6 +191,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
     expect(hdWallet.depositIndex).toBe(1);
     expect(hdWallet.changeIndex).toBe(0);
 
@@ -199,6 +211,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
     await hdWallet.send({
       cashaddr: bob.getDepositAddress(),
       value: 50000n,
@@ -247,6 +261,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(100000n);
 
@@ -258,6 +274,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress2,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(200000n);
 
@@ -289,6 +307,8 @@ describe("HDWallet", () => {
       cashaddr: bob.getDepositAddress(),
       value: 150000n,
     });
+    while (hdWallet.changeIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(
       await (
@@ -326,6 +346,10 @@ describe("HDWallet", () => {
     const charlie = await RegTestWallet.newRandom();
     await hdWallet.sendMax(charlie.cashaddr);
 
+    // Wait for HD wallet to process the spent notification
+    while ((await hdWallet.getBalance()) > 0n)
+      await new Promise((r) => setTimeout(r, 50));
+
     expect(await charlie.getBalance()).toBe(49407n);
     expect(await hdWallet.getBalance()).toBe(0n);
   });
@@ -343,6 +367,8 @@ describe("HDWallet", () => {
       cashaddr: depositAddress,
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(await hdWallet.getBalance()).toBe(100000n);
 
@@ -436,6 +462,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     expect(
       hdWallet.walletCache.get(hdWallet.getDepositAddress(0))?.status
@@ -486,6 +514,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     // rawHistory should now have one entry
     expect(
@@ -527,11 +557,15 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     await fundingWallet.send({
       cashaddr: hdWallet.getDepositAddress(1),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check depositRawHistory arrays are populated
     expect(hdWallet.depositRawHistory[0].length).toBe(1);
@@ -557,6 +591,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 100000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     const history = await hdWallet.getHistory({ unit: "sat" });
     expect(history.length).toBe(1);
@@ -578,6 +614,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 50000n,
     });
+    while (hdWallet.depositIndex < 1)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check rawHistory is populated
     const cacheEntry1 = hdWallet.walletCache.get(hdWallet.getDepositAddress(0));
@@ -590,6 +628,8 @@ describe("HDWallet", () => {
       cashaddr: hdWallet.getDepositAddress(0),
       value: 60000n,
     });
+    while (hdWallet.depositRawHistory[0].length < 2)
+      await new Promise((r) => setTimeout(r, 50));
 
     // Check history accumulated correctly
     const cacheEntry2 = hdWallet.walletCache.get(hdWallet.getDepositAddress(0));
@@ -680,6 +720,7 @@ describe("HDWallet", () => {
       cashaddr: alice.getDepositAddress(),
       value: 1000000n,
     });
+    while (alice.depositIndex < 1) await new Promise((r) => setTimeout(r, 50));
 
     const genesisResponse = await alice.tokenGenesis({
       cashaddr: alice.getDepositAddress(1),
@@ -764,6 +805,7 @@ describe("HDWallet", () => {
       cashaddr: alice.getDepositAddress(),
       value: 1000000n,
     });
+    while (alice.depositIndex < 1) await new Promise((r) => setTimeout(r, 50));
 
     const genesisResponse = await alice.tokenGenesis({
       amount: 100n,
@@ -839,4 +881,201 @@ describe("HDWallet", () => {
 
     Config.EnforceCashTokenReceiptAddresses = previousValue;
   });
+
+  it("watchTransactionHashes reports new transactions on HD wallet", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Fund the HD wallet at deposit address 0
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    // Set up watchTransactionHashes, collect reported tx hashes
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Wait for initial callback to fire with existing tx
+    await delay(2000);
+
+    // Send a new transaction to the HD wallet
+    const sendResponse = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // The new transaction's txId should appear in collected hashes
+    expect(reportedHashes).toContain(sendResponse.txId);
+  });
+
+  it("watchTransactionHashes does not re-report old transactions", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Start watching before any transactions so the first funding triggers a callback
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Fund the HD wallet at deposit address 0
+    const fundResponse = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    // Record how many hashes reported so far (the initial set)
+    const initialCount = reportedHashes.length;
+    expect(reportedHashes).toContain(fundResponse.txId);
+    const initialHashes = [...reportedHashes];
+
+    // Send a second transaction to the HD wallet
+    const sendResponse2 = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // Hashes reported after the initial set
+    const laterHashes = reportedHashes.slice(initialCount);
+
+    // The second tx hash was reported
+    expect(laterHashes).toContain(sendResponse2.txId);
+
+    // None of the initial tx hashes were reported again after the first callback
+    for (const hash of initialHashes) {
+      expect(laterHashes).not.toContain(hash);
+    }
+  });
+
+  it("watchTransactionHashes handles transactions across multiple deposit addresses", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+
+    // Fund deposit address 0
+    const fund0Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(0),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(1000);
+
+    // Fund deposit address 1
+    const fund1Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(1),
+      value: 100000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(1000);
+
+    // depositIndex should be 2
+    expect(hdWallet.depositIndex).toBe(2);
+
+    // Set up watchTransactionHashes, collect all reported hashes
+    const reportedHashes: string[] = [];
+    let cancelWatch: CancelFn;
+    cancelWatch = await hdWallet.watchTransactionHashes((txHash) => {
+      reportedHashes.push(txHash);
+    });
+
+    // Wait for initial callback to fire
+    await delay(2000);
+
+    // Send a new transaction to the wallet's next deposit address
+    const fund2Response = await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(),
+      value: 50000n,
+    });
+    await mine({ cashaddr: hdWallet.getDepositAddress(0), blocks: 1 });
+    await delay(2000);
+
+    await cancelWatch();
+
+    // All 3 tx hashes appear in the collected output
+    expect(reportedHashes).toContain(fund0Response.txId);
+    expect(reportedHashes).toContain(fund1Response.txId);
+    expect(reportedHashes).toContain(fund2Response.txId);
+
+    // Each tx hash appears exactly once
+    const uniqueHashes = new Set(reportedHashes);
+    expect(uniqueHashes.size).toBe(reportedHashes.length);
+  });
+
+  it("gap is maintained when addresses near the edge are used", async () => {
+    const fundingWallet = await RegTestWallet.fromId(
+      "wif:regtest:cNfsPtqN2bMRS7vH5qd8tR8GMvgXyL5BjnGAKgZ8DYEiCrCCQcP6"
+    );
+    const hdWallet = await RegTestHDWallet.newRandom();
+    await hdWallet.watchPromise;
+
+    // Initially: depositIndex=0, watched addresses 0..(GAP_SIZE-1)
+    expect(hdWallet.depositIndex).toBe(0);
+    const initialWatched = (hdWallet as any).depositStatuses.length;
+    expect(initialWatched).toBe(GAP_SIZE);
+
+    // Fund an address near the edge of the gap
+    const edgeIndex = GAP_SIZE - 2;
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(edgeIndex),
+      value: 10000n,
+    });
+
+    // Wait for the subscription callback to fire and gap extension to complete
+    while (hdWallet.depositIndex < edgeIndex + 1)
+      await new Promise((r) => setTimeout(r, 50));
+    await delay(1000);
+
+    // depositIndex should have advanced
+    expect(hdWallet.depositIndex).toBe(edgeIndex + 1);
+
+    // The watched range should have extended to maintain the gap
+    const newWatched = (hdWallet as any).depositStatuses.length;
+    expect(newWatched).toBeGreaterThanOrEqual(hdWallet.depositIndex + GAP_SIZE);
+
+    // Verify the new addresses are actually subscribed (watchCancels populated)
+    const watchCancels = (hdWallet as any).depositWatchCancels;
+    for (let i = initialWatched; i < newWatched; i++) {
+      expect(watchCancels[i]).toBeDefined();
+    }
+
+    // Fund an address in the newly extended range to prove it's being watched
+    const newEdge = newWatched - 2;
+    await fundingWallet.send({
+      cashaddr: hdWallet.getDepositAddress(newEdge),
+      value: 10000n,
+    });
+    while (hdWallet.depositIndex < newEdge + 1)
+      await new Promise((r) => setTimeout(r, 50));
+    await delay(1000);
+
+    expect(hdWallet.depositIndex).toBe(newEdge + 1);
+
+    // Gap should still be maintained after the second extension
+    const finalWatched = (hdWallet as any).depositStatuses.length;
+    expect(finalWatched).toBeGreaterThanOrEqual(
+      hdWallet.depositIndex + GAP_SIZE
+    );
+  });
 });

package/src/wallet/HDWallet.ts

@@ -414,6 +414,12 @@ export class HDWallet extends BaseWallet {
                 if (newIndex > getCurrentIndex()) {
                   setCurrentIndex(newIndex);
                 }
+
+                // Maintain the gap: extend watched range if it shrank
+                const gap = statuses.length - getCurrentIndex();
+                if (gap < gapSize) {
+                  await this.watchAddressType(isChange, gapSize);
+                }
               }
 
               // Notify wallet watchers of the status change
@@ -493,6 +499,36 @@ export class HDWallet extends BaseWallet {
     };
   }
 
+  /**
+   * Watch wallet for new transactions (HD wallet override)
+   *
+   * Uses unfiltered history so that seenTxHashes always covers all known
+   * transactions, including those from newly discovered addresses when
+   * depositIndex/changeIndex extends and widens getRawHistory's scope.
+   */
+  public override async watchTransactionHashes(
+    callback: (txHash: string) => void
+  ): Promise<CancelFn> {
+    const seenTxHashes = new Set<string>();
+
+    return this.watchStatus(async () => {
+      const history = await this.getRawHistory();
+
+      const newTxHashes: string[] = [];
+
+      for (const tx of history) {
+        if (!seenTxHashes.has(tx.tx_hash)) {
+          seenTxHashes.add(tx.tx_hash);
+          newTxHashes.push(tx.tx_hash);
+        }
+      }
+
+      if (newTxHashes.length > 0) {
+        newTxHashes.forEach((txHash) => callback(txHash));
+      }
+    });
+  }
+
   /**
    * utxos Get unspent outputs for the wallet
    *

package/src/wallet/Util.test.ts

@@ -1,6 +1,8 @@
 import { initProviders, disconnectProviders } from "../network";
-import { ElectrumRawTransaction } from "../network/interface";
 import { RegTestWallet, Wallet } from "./Wif";
+import { mine } from "../mine";
+import { Config } from "../config";
+import { delay } from "../util/delay";
 
 beforeAll(async () => {
   await initProviders();
@@ -41,9 +43,9 @@ describe("Utility tests", () => {
   test("Should get raw transaction", async () => {
     let wallet = await RegTestWallet.fromId(process.env.ALICE_ID!);
     const utxo = (await wallet.getUtxos())[0];
-    const transaction = (await wallet.provider!.getRawTransactionObject(
+    const transaction = await wallet.provider!.getRawTransactionObject(
       utxo.txid
-    )) as ElectrumRawTransaction;
+    );
     expect((await wallet.util.decodeTransaction(transaction.hash)).hash).toBe(
       utxo.txid
     );
@@ -67,18 +69,66 @@ describe("Utility tests", () => {
       "0e3e2357e806b6cdb1f70b54c3a3a17b6714ee1f0e68bebb44a74b1efd512098"
     );
 
-    expect(decoded.vin[0].address).toBeUndefined();
-    expect(decoded.vin[0].value).toBeUndefined();
+    // non-enriched vin entries don't carry vout fields (enforced by types)
+    expect((decoded.vin[0] as any).address).toBeUndefined();
   });
 
   test("Should decode a transaction and fetch input values and addresses", async () => {
     const txHash =
       "dc8f059900807c36941313f10b43ec049e23dfede4e09f8fbccc3871ed359fbe";
     const decoded = await Wallet.util.decodeTransaction(txHash, true);
-    expect(decoded.vin[0].address).toBeDefined();
+    expect(decoded.vin[0].scriptPubKey.addresses[0]).toBeDefined();
     expect(decoded.vin[0].value).toBeDefined();
 
     //  uncomment next line
     // expect(await Wallet.util.decodeTransaction(txHash)).toBe(await new Wallet().provider!.getRawTransactionObject(txHash));
   });
 });
+
+describe("Dynamic confirmations via fetchHeight", () => {
+  test("confirmations defaults to 0 for decoded mempool transactions", async () => {
+    const wallet = await RegTestWallet.newRandom();
+    const decoded = await wallet.util.decodeTransaction(
+      "01000000015bb9142c960a838329694d3fe9ba08c2a6421c5158d8f7044cb7c48006c1b484000000006a4730440220229ea5359a63c2b83a713fcc20d8c41b20d48fe639a639d2a8246a137f29d0fc02201de12de9c056912a4e581a62d12fb5f43ee6c08ed0238c32a1ee769213ca8b8b412103bcf9a004f1f7a9a8d8acce7b51c983233d107329ff7c4fb53e44c855dbe1f6a4feffffff02c6b68200000000001976a9141041fb024bd7a1338ef1959026bbba860064fe5f88ac50a8cf00000000001976a91445dac110239a7a3814535c15858b939211f8529888ac61ee0700"
+    );
+    expect(decoded.confirmations).toBe(0);
+  });
+
+  test("confirmations is present on verbose server response", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const utxo = (await alice.getUtxos())[0];
+    const transaction = await alice.provider.getRawTransactionObject(utxo.txid);
+    expect(transaction.confirmations).toBeGreaterThan(0);
+  });
+
+  test("fetchHeight is not exposed in returned transaction", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const utxo = (await alice.getUtxos())[0];
+    const transaction = await alice.provider.getRawTransactionObject(utxo.txid);
+    expect((transaction as any).fetchHeight).toBeUndefined();
+  });
+
+  test("cached transaction has up-to-date confirmations", async () => {
+    const memoryCacheValue = Config.UseMemoryCache;
+    Config.UseMemoryCache = true;
+    try {
+      const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+      const utxo = (await alice.getUtxos())[0];
+
+      // first fetch primes the cache
+      const tx1 = await alice.provider.getRawTransactionObject(utxo.txid);
+      const confirmations1 = tx1.confirmations;
+
+      // mine a block and wait for header subscription to propagate
+      await mine({ cashaddr: alice.cashaddr!, blocks: 1 });
+      await delay(1000);
+
+      // second fetch should hit cache but with updated confirmations
+      const tx2 = await alice.provider.getRawTransactionObject(utxo.txid);
+      expect(tx2.confirmations).toBe(confirmations1 + 1);
+      expect((tx2 as any).fetchHeight).toBeUndefined();
+    } finally {
+      Config.UseMemoryCache = memoryCacheValue;
+    }
+  });
+});

package/src/wallet/Util.ts

@@ -15,9 +15,9 @@ import { getNetworkProvider } from "../network/default.js";
 import {
   ElectrumRawTransaction,
   ElectrumRawTransactionVin,
-  ElectrumRawTransactionVinScriptSig,
+  ElectrumRawTransactionVinWithValues,
   ElectrumRawTransactionVout,
-  ElectrumRawTransactionVoutScriptPubKey,
+  ElectrumRawTransactionWithInputValues,
 } from "../network/interface.js";
 import NetworkProvider from "../network/NetworkProvider.js";
 import { getTransactionHash } from "../util/transaction.js";
@@ -49,10 +49,18 @@ export class Util {
     return getTransactionHash(rawTransactionHex);
   }
 
+  public async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  public async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
   public async decodeTransaction(
     transactionHashOrHex: string,
     loadInputValues: boolean = false
-  ): Promise<ElectrumRawTransaction> {
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
     let transactionHex: string;
     let transactionBin: Uint8Array;
     let txHash: string;
@@ -89,14 +97,15 @@ export class Util {
       const transactionMap = new Map<string, ElectrumRawTransaction>();
       transactions.forEach((val) => transactionMap.set(val.hash, val));
 
-      transaction.vin.forEach((input) => {
-        const output = transactionMap
-          .get(input.txid)!
-          .vout.find((val) => val.n === input.vout)!;
-        input.address = output.scriptPubKey.addresses[0];
-        input.value = output.value;
-        input.tokenData = output.tokenData;
-      });
+      const enrichedVin: ElectrumRawTransactionVinWithValues[] =
+        transaction.vin.map((input) => {
+          const output = transactionMap
+            .get(input.txid)!
+            .vout.find((val) => val.n === input.vout)!;
+          return { ...input, ...output };
+        });
+
+      return { ...transaction, vin: enrichedVin };
     }
 
     return transaction;
@@ -107,22 +116,30 @@ export class Util {
     txHash: string,
     txHex: string
   ): ElectrumRawTransaction {
-    let result: ElectrumRawTransaction = {} as any;
-
-    result.vin = transaction.inputs.map((input): ElectrumRawTransactionVin => {
-      return {
-        scriptSig: {
-          hex: binToHex(input.unlockingBytecode),
-        } as ElectrumRawTransactionVinScriptSig,
-        sequence: input.sequenceNumber,
-        txid: binToHex(input.outpointTransactionHash),
-        vout: input.outpointIndex,
-      };
-    });
-
-    result.vout = transaction.outputs.map(
-      (output, index): ElectrumRawTransactionVout => {
-        return {
+    return {
+      blockhash: "",
+      blocktime: 0,
+      confirmations: 0,
+      time: 0,
+      hash: txHash,
+      hex: txHex,
+      txid: txHash,
+      locktime: transaction.locktime,
+      version: transaction.version,
+      size: txHex.length / 2,
+      vin: transaction.inputs.map(
+        (input): ElectrumRawTransactionVin => ({
+          scriptSig: {
+            asm: "",
+            hex: binToHex(input.unlockingBytecode),
+          },
+          sequence: input.sequenceNumber,
+          txid: binToHex(input.outpointTransactionHash),
+          vout: input.outpointIndex,
+        })
+      ),
+      vout: transaction.outputs.map(
+        (output, index): ElectrumRawTransactionVout => ({
           n: index,
           scriptPubKey: {
             addresses: [
@@ -132,7 +149,7 @@ export class Util {
                       output.lockingBytecode
                     ).payload,
                     prefix: prefixFromNetworkMap[this.network],
-                  })
+                  }).address
                 : assertSuccess(
                     lockingBytecodeToCashAddress({
                       bytecode: output.lockingBytecode,
@@ -140,31 +157,35 @@ export class Util {
                     })
                   ).address,
             ],
+            asm: "",
             hex: binToHex(output.lockingBytecode),
-          } as ElectrumRawTransactionVoutScriptPubKey,
+            reqSigs: 1,
+            type: "",
+          },
           value: Number(output.valueSatoshis) / Number(bchParam.subUnits),
-        };
-      }
-    );
-
-    result.locktime = transaction.locktime;
-    result.version = transaction.version;
-    result.hash = txHash;
-    result.hex = txHex;
-    result.txid = txHash;
-    result.size = txHex.length / 2;
-
-    return result;
+        })
+      ),
+    };
   }
 
+  public static async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues: true,
+    network?: NetworkType
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  public static async decodeTransaction(
+    transactionHashOrHex: string,
+    loadInputValues?: false,
+    network?: NetworkType
+  ): Promise<ElectrumRawTransaction>;
   public static async decodeTransaction(
     transactionHashOrHex: string,
     loadInputValues: boolean = false,
     network?: NetworkType
-  ): Promise<ElectrumRawTransaction> {
-    return new this(network).decodeTransaction(
-      transactionHashOrHex,
-      loadInputValues
-    );
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
+    if (loadInputValues) {
+      return new this(network).decodeTransaction(transactionHashOrHex, true);
+    }
+    return new this(network).decodeTransaction(transactionHashOrHex);
   }
 }