mainnet-js 2.3.15 → 2.3.16

package/package.json

@@ -9,7 +9,7 @@
     "url": "https://github.com/mainnet-cash/mainnet-js/issues"
   },
   "name": "mainnet-js",
-  "version": "2.3.15",
+  "version": "2.3.16",
   "homepage": "https://mainnet.cash",
   "module": "dist/module/index.js",
   "browser": {

package/src/interface.ts

@@ -35,11 +35,21 @@ export interface TxI {
   fee?: number;
 }
 
-export interface HeaderI {
+export interface HexHeaderI {
   height: number;
   hex: string;
 }
 
+export interface HeaderI {
+  version: number;
+  previousBlockHash: string;
+  merkleRoot: string;
+  timestamp: number;
+  bits: number;
+  nonce: number;
+  height: number;
+}
+
 export interface TokenI {
   amount: bigint;
   tokenId: string;

package/src/network/ElectrumNetworkProvider.ts

@@ -5,7 +5,7 @@ import {
   ConnectionStatus,
 } from "electrum-cash";
 import { default as NetworkProvider } from "./NetworkProvider.js";
-import { HeaderI, TxI, UtxoI, ElectrumBalanceI } from "../interface.js";
+import { HexHeaderI, TxI, UtxoI, ElectrumBalanceI, HeaderI } from "../interface.js";
 import { Network } from "../interface.js";
 import { delay } from "../util/delay.js";
 import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
@@ -13,6 +13,7 @@ import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
 import { CancelWatchFn } from "../wallet/interface.js";
 import { getTransactionHash } from "../util/transaction.js";
 import { Config } from "../config.js";
+import { decodeHeader } from "../util/header.js";
 
 export default class ElectrumNetworkProvider implements NetworkProvider {
   public electrum: ElectrumCluster | ElectrumClient;
@@ -105,6 +106,29 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return result.confirmed + result.unconfirmed;
   }
 
+  static rawHeaderCache = {};
+  async getHeader(height: number, verbose: boolean = false): Promise<HeaderI | HexHeaderI> {
+    const key = `header-${this.network}-${height}-${verbose}`;
+
+    if (Config.UseLocalStorageCache) {
+      const cached = localStorage.getItem(key);
+      if (cached) {
+        return verbose ? decodeHeader(JSON.parse(cached)) : JSON.parse(cached);
+      }
+    } else {
+      ElectrumNetworkProvider.rawTransactionCache[key];
+    }
+
+    const result = await this.performRequest("blockchain.header.get", height) as HexHeaderI;
+    if (Config.UseLocalStorageCache) {
+      localStorage.setItem(key, JSON.stringify(result));
+    } else {
+      ElectrumNetworkProvider.rawTransactionCache[key] = result;
+    }
+
+    return verbose ? decodeHeader(result) : result;
+  }
+
   async getBlockHeight(): Promise<number> {
     return ((await this.performRequest("blockchain.headers.get_tip")) as any)
       .height;
@@ -116,7 +140,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     verbose: boolean = false,
     loadInputValues: boolean = false
   ): Promise<string> {
-    const key = `${this.network}-${txHash}-${verbose}-${loadInputValues}`;
+    const key = `tx-${this.network}-${txHash}-${verbose}-${loadInputValues}`;
 
     if (Config.UseLocalStorageCache) {
       const cached = localStorage.getItem(key);
@@ -317,9 +341,9 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   // Wait for the next block or a block at given blockchain height.
-  public watchBlocks(callback: (header: HeaderI) => void): CancelWatchFn {
+  public watchBlocks(callback: (header: HexHeaderI) => void): CancelWatchFn {
     let acknowledged = false;
-    const waitForBlockCallback = (_header: HeaderI | HeaderI[]) => {
+    const waitForBlockCallback = (_header: HexHeaderI | HexHeaderI[]) => {
       if (!acknowledged) {
         acknowledged = true;
         return;
@@ -336,7 +360,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   // Wait for the next block or a block at given blockchain height.
-  public async waitForBlock(height?: number): Promise<HeaderI> {
+  public async waitForBlock(height?: number): Promise<HexHeaderI> {
     return new Promise(async (resolve) => {
       const cancelWatch = this.watchBlocks(async (header) => {
         if (height === undefined || header.height >= height!) {
@@ -348,13 +372,13 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   // subscribe to notifications sent when new block is found, the block header is sent to callback
-  async subscribeToHeaders(callback: (header: HeaderI) => void): Promise<void> {
+  async subscribeToHeaders(callback: (header: HexHeaderI) => void): Promise<void> {
     await this.subscribeRequest("blockchain.headers.subscribe", callback);
   }
 
   // unsubscribe to notifications sent when new block is found
   async unsubscribeFromHeaders(
-    callback: (header: HeaderI) => void
+    callback: (header: HexHeaderI) => void
   ): Promise<void> {
     await this.unsubscribeRequest("blockchain.headers.subscribe", callback);
   }

package/src/network/NetworkProvider.ts

@@ -1,4 +1,4 @@
-import { TxI, UtxoI, Network, HeaderI } from "../interface.js";
+import { TxI, UtxoI, Network, HexHeaderI, HeaderI } from "../interface.js";
 
 export default interface NetworkProvider {
   /**
@@ -20,6 +20,12 @@ export default interface NetworkProvider {
    */
   getBalance(cashaddr: string): Promise<number>;
 
+  /**
+   * @returns The block header fetched at blockheight @param height.
+   * @param verbose steers the response type. If true, a verbose response is returned.
+   */
+  getHeader(height: number, verbose: boolean): Promise<HeaderI | HexHeaderI>;
+
   /**
    * @returns The current block height.
    */
@@ -72,7 +78,7 @@ export default interface NetworkProvider {
    * @param height If specified, waits for blockchain to reach this height.
    * @returns Block header.
    */
-  waitForBlock(height?: number): Promise<HeaderI>;
+  waitForBlock(height?: number): Promise<HexHeaderI>;
 
   /**
    * Subscribe to the address change events

package/src/util/header.test.ts

@@ -0,0 +1,28 @@
+import { HeaderI, HexHeaderI } from "../interface";
+import { disconnectProviders, initProviders } from "../network";
+import { Wallet } from "../wallet/Wif";
+
+beforeAll(async () => {
+  await initProviders();
+});
+afterAll(async () => {
+  await disconnectProviders();
+});
+
+describe('header tests', () => {
+  it('decodeHeader', async () => {
+    const wallet = await Wallet.newRandom();
+    const hexHeader = await wallet.provider!.getHeader(854724) as HexHeaderI;
+    expect(hexHeader.height).toBe(854724);
+    expect(hexHeader.hex).toBe("0080c4339674a81d4e35a5b590b15a6b69f93b7b22bd14845b3517000000000000000000128a8b776c82fda87f60c6fdb0de26f021cdf39ffd835dc309eb1fc6bbfaac343e2f96662d5202184db2428f");
+
+    const header = await wallet.provider!.getHeader(854724, true) as HeaderI;
+    expect(header.version).toBe(868515840);
+    expect(header.previousBlockHash).toBe("00000000000000000017355b8414bd227b3bf9696b5ab190b5a5354e1da87496");
+    expect(header.merkleRoot).toBe("34acfabbc61feb09c35d83fd9ff3cd21f026deb0fdc6607fa8fd826c778b8a12");
+    expect(header.timestamp).toBe(1721118526);
+    expect(header.bits).toBe(402805293);
+    expect(header.nonce).toBe(2403512909);
+    expect(header.height).toBe(854724);
+  });
+});

package/src/util/header.ts

@@ -0,0 +1,16 @@
+import { HeaderI, HexHeaderI } from "../interface";
+
+export const decodeHeader = (hexHeader: HexHeaderI): HeaderI => {
+  const result = {} as HeaderI;
+
+  const header = Buffer.from(hexHeader.hex, "hex");
+  result.version = header.readUInt32LE(0);
+  result.previousBlockHash = header.subarray(4, 36).reverse().toString("hex");
+  result.merkleRoot = header.subarray(36, 68).reverse().toString("hex");
+  result.timestamp = header.readUInt32LE(68);
+  result.bits = header.readUInt32LE(72);
+  result.nonce = header.readUInt32LE(76);
+  result.height = hexHeader.height;
+
+  return result;
+}

package/src/util/index.ts

@@ -34,3 +34,4 @@ export {
   balanceResponseFromSatoshi,
 } from "./balanceObjectFromSatoshi.js";
 export * from "./sumUtxoValue.js";
+export { decodeHeader } from "./header.js";

package/src/wallet/Wif.ts

@@ -25,7 +25,7 @@ import {
 import { mnemonicToSeedSync, generateMnemonic } from "@scure/bip39";
 import { NetworkType, prefixFromNetworkMap, UnitEnum } from "../enum.js";
 
-import { Network, HeaderI, TxI, NFTCapability } from "../interface.js";
+import { Network, HexHeaderI, TxI, NFTCapability } from "../interface.js";
 
 import { networkPrefixMap } from "../enum.js";
 import { PrivateKeyI, UtxoI } from "../interface.js";
@@ -1396,7 +1396,7 @@ export class Wallet extends BaseWallet {
    *
    * @returns a function which will cancel watching upon evaluation
    */
-  public watchBlocks(callback: (header: HeaderI) => void): CancelWatchFn {
+  public watchBlocks(callback: (header: HexHeaderI) => void): CancelWatchFn {
     return (this.provider! as ElectrumNetworkProvider).watchBlocks(callback);
   }
 
@@ -1406,7 +1406,7 @@ export class Wallet extends BaseWallet {
    * @param height if specified waits for this exact blockchain height, otherwise resolves with the next block
    *
    */
-  public async waitForBlock(height?: number): Promise<HeaderI> {
+  public async waitForBlock(height?: number): Promise<HexHeaderI> {
     return (this.provider! as ElectrumNetworkProvider).waitForBlock(height);
   }
   //#endregion Funds