mainnet-js 3.0.1 → 3.1.1

package/src/network/ElectrumNetworkProvider.ts

@@ -14,7 +14,12 @@ import {
   HeaderI,
 } from "../interface.js";
 import { Network } from "../interface.js";
-import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
+import {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionVinWithValues,
+  ElectrumRawTransactionWithInputValues,
+  ElectrumUtxo,
+} from "./interface.js";
 
 import { CancelFn } from "../wallet/interface.js";
 import { getTransactionHash } from "../util/transaction.js";
@@ -25,6 +30,9 @@ import { IndexedDbCache } from "../cache/IndexedDbCache.js";
 import { WebStorageCache } from "../cache/WebStorageCache.js";
 import { MemoryCache } from "../cache/MemoryCache.js";
 
+/** Internal type for cached verbose transactions. fetchHeight is stripped before returning. */
+type CachedRawTransaction = ElectrumRawTransaction & { fetchHeight: number };
+
 export default class ElectrumNetworkProvider implements NetworkProvider {
   public electrum: ElectrumClient<ElectrumClientEvents>;
   public subscriptions: number = 0;
@@ -135,7 +143,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     if (hashes.length === 0) return new Map();
 
     const results = new Map<string, string>();
-    const keys = hashes.map((h) => `tx-${this.network}-${h}-false-false`);
+    const keys = hashes.map((hash) => `txraw-${this.network}-${hash}`);
 
     // batch cache read
     let cached: Map<string, string | null> | undefined;
@@ -168,7 +176,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
       // batch cache write
       if (this.cache) {
         const entries: [string, string][] = fetched.map(([hash, tx]) => [
-          `tx-${this.network}-${hash}-false-false`,
+          `txraw-${this.network}-${hash}`,
           tx,
         ]);
         await this.cache.setItems(entries);
@@ -186,7 +194,9 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     if (heights.length === 0) return new Map();
 
     const results = new Map<number, HeaderI>();
-    const keys = heights.map((h) => `header-${this.network}-${h}-true`);
+    const keys = heights.map(
+      (height) => `header-${this.network}-${height}-true`
+    );
 
     // batch cache read
     let cached: Map<string, string | null> | undefined;
@@ -251,56 +261,84 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return this.currentHeight;
   }
 
+  async getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  async getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  async getRawTransaction(
+    txHash: string,
+    verbose?: false,
+    loadInputValues?: false
+  ): Promise<string>;
   async getRawTransaction(
     txHash: string,
     verbose: boolean = false,
     loadInputValues: boolean = false
-  ): Promise<string> {
-    const key = `tx-${this.network}-${txHash}-${verbose}-${loadInputValues}`;
+  ): Promise<
+    string | ElectrumRawTransaction | ElectrumRawTransactionWithInputValues
+  > {
+    const nonVerboseKey = `txraw-${this.network}-${txHash}`;
+    const verboseKey = `tx-${this.network}-${txHash}`;
+    const key = verbose ? verboseKey : nonVerboseKey;
 
     if (this.cache) {
       const cached = await this.cache.getItem(key);
       if (cached) {
-        return verbose ? JSON.parse(cached) : cached;
+        if (!verbose) {
+          return cached;
+        }
+
+        const cachedTx = JSON.parse(cached) as CachedRawTransaction;
+        if (cachedTx.confirmations > 0) {
+          const currentHeight = await this.getBlockHeight();
+          cachedTx.confirmations += currentHeight - cachedTx.fetchHeight;
+        }
+        const { fetchHeight: _, ...transaction } = cachedTx;
+
+        if (loadInputValues) {
+          return this.enrichWithInputValues(transaction);
+        }
+
+        return transaction;
       }
     }
 
     try {
-      const transaction = (await this.performRequest(
+      const result = await this.performRequest(
         "blockchain.transaction.get",
         txHash,
         verbose
-      )) as ElectrumRawTransaction;
+      );
+
+      if (!verbose) {
+        const hex = result as string;
+        if (this.cache) {
+          await this.cache.setItem(key, hex);
+        }
+        return hex;
+      }
+
+      const cachedTx = result as CachedRawTransaction;
+      cachedTx.confirmations ??= 0;
+      cachedTx.fetchHeight = await this.getBlockHeight();
 
       if (this.cache) {
-        await this.cache.setItem(
-          key,
-          verbose
-            ? JSON.stringify(transaction)
-            : (transaction as unknown as string)
-        );
+        await this.cache.setItem(key, JSON.stringify(cachedTx));
       }
 
-      if (verbose && loadInputValues) {
-        // get unique transaction hashes
-        const hashes = [...new Set(transaction.vin.map((val) => val.txid))];
-        const transactions = await Promise.all(
-          hashes.map((hash) => this.getRawTransactionObject(hash, false))
-        );
-        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 { fetchHeight: _, ...transaction } = cachedTx;
+
+      if (loadInputValues) {
+        return this.enrichWithInputValues(transaction);
       }
 
-      return transaction as any;
+      return transaction;
     } catch (error: any) {
       if (
         (error.message as string).indexOf(
@@ -314,16 +352,44 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
   }
 
+  private async enrichWithInputValues(
+    transaction: ElectrumRawTransaction
+  ): Promise<ElectrumRawTransactionWithInputValues> {
+    const hashes = [...new Set(transaction.vin.map((val) => val.txid))];
+    const transactions = await Promise.all(
+      hashes.map((hash) => this.getRawTransactionObject(hash, false))
+    );
+    const transactionMap = new Map<string, ElectrumRawTransaction>();
+    transactions.forEach((val) => transactionMap.set(val.hash, val));
+
+    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 };
+  }
+
   // gets the decoded transaction in human readable form
+  async getRawTransactionObject(
+    txHash: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  async getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
   async getRawTransactionObject(
     txHash: string,
     loadInputValues: boolean = false
-  ): Promise<ElectrumRawTransaction> {
-    return (await this.getRawTransaction(
-      txHash,
-      true,
-      loadInputValues
-    )) as unknown as ElectrumRawTransaction;
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues> {
+    if (loadInputValues) {
+      return this.getRawTransaction(txHash, true, true);
+    }
+    return this.getRawTransaction(txHash, true);
   }
 
   async sendRawTransaction(

package/src/network/NetworkProvider.ts

@@ -1,4 +1,8 @@
 import { TxI, Utxo, Network, HexHeaderI, HeaderI } from "../interface.js";
+import {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionWithInputValues,
+} from "./interface.js";
 import { CancelFn } from "../wallet/interface.js";
 
 export default interface NetworkProvider {
@@ -38,13 +42,35 @@ export default interface NetworkProvider {
   getRelayFee(): Promise<number>;
 
   /**
-   * Retrieve the Hex transaction details for a given transaction ID.
+   * Retrieve transaction details for a given transaction ID.
    * @param txHash Hex of transaction hash.
-   * @param verbose Whether a verbose coin-specific response is required.
+   * @param verbose When true, returns a decoded transaction object instead of hex.
+   * @param loadInputValues When true (requires verbose), each vin is enriched with value, address and tokenData from the parent output.
    * @throws {Error} If the transaction does not exist
-   * @returns The full hex transaction for the provided transaction ID.
+   * @returns The hex string (non-verbose) or decoded transaction object (verbose).
    */
-  getRawTransaction(txHash: string): Promise<string>;
+  getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  getRawTransaction(
+    txHash: string,
+    verbose: true,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  getRawTransaction(
+    txHash: string,
+    verbose?: false,
+    loadInputValues?: false
+  ): Promise<string>;
+  getRawTransaction(
+    txHash: string,
+    verbose?: boolean,
+    loadInputValues?: boolean
+  ): Promise<
+    string | ElectrumRawTransaction | ElectrumRawTransactionWithInputValues
+  >;
 
   /**
    * Batch retrieve raw transactions by their hashes.
@@ -63,10 +89,22 @@ export default interface NetworkProvider {
   /**
    * Retrieve a verbose coin-specific response transaction details for a given transaction ID.
    * @param txHash Hex of transaction hash.
+   * @param loadInputValues When true, each vin is enriched with value, address and tokenData from the parent output.
    * @throws {Error} If the transaction does not exist
-   * @returns The full hex transaction for the provided transaction ID.
+   * @returns The decoded transaction object.
    */
-  getRawTransactionObject(txHash: string): Promise<any>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues: true
+  ): Promise<ElectrumRawTransactionWithInputValues>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: false
+  ): Promise<ElectrumRawTransaction>;
+  getRawTransactionObject(
+    txHash: string,
+    loadInputValues?: boolean
+  ): Promise<ElectrumRawTransaction | ElectrumRawTransactionWithInputValues>;
 
   /**
    * Broadcast a raw hex transaction to the Bitcoin Cash network.

package/src/network/index.ts

@@ -7,4 +7,8 @@ export {
 } from "./Connection.js";
 export { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
 export { default as NetworkProvider } from "./NetworkProvider.js";
-export { ElectrumRawTransaction } from "./interface.js";
+export {
+  ElectrumRawTransaction,
+  ElectrumRawTransactionWithInputValues,
+  ElectrumRawTransactionVinWithValues,
+} from "./interface.js";

package/src/network/interface.ts

@@ -54,9 +54,14 @@ export interface ElectrumRawTransactionVin {
   sequence: number;
   txid: string;
   vout: number;
-  value?: number; // optional extention by mainnet.cash
-  address?: string; // optional extension by mainnet.cash
-  tokenData?: ElectrumTokenData; // optional extension by mainnet.cash
+}
+
+export type ElectrumRawTransactionVinWithValues = ElectrumRawTransactionVin &
+  ElectrumRawTransactionVout;
+
+export interface ElectrumRawTransactionWithInputValues
+  extends Omit<ElectrumRawTransaction, "vin"> {
+  vin: ElectrumRawTransactionVinWithValues[];
 }
 
 export interface ElectrumRawTransactionVout {

package/src/wallet/Base.ts

@@ -571,10 +571,7 @@ export class BaseWallet implements WalletI {
   ): Promise<CancelFn> {
     return this.watchTransactions(
       async (transaction: ElectrumRawTransaction) => {
-        if (
-          transaction.vin.some((val) => val.tokenData) ||
-          transaction.vout.some((val) => val.tokenData)
-        ) {
+        if (transaction.vout.some((val) => val.tokenData)) {
           callback(transaction);
         }
       }