mainnet-js 2.6.1 → 2.6.3

package/src/cache/MemoryCache.ts

@@ -0,0 +1,18 @@
+export class MemoryCache {
+  public cache: Record<string, string> = {};
+  async init() {
+    return;
+  }
+  async setItem(key: string, value: string) {
+    this.cache[key] = value;
+  }
+  async getItem(key: string) {
+    return this.cache[key] ?? null;
+  }
+  async removeItem(key: string) {
+    delete this.cache[key];
+  }
+  async clear() {
+    this.cache = {};
+  }
+}

package/src/cache/WebStorageCache.test.ts

@@ -0,0 +1,15 @@
+import { WebStorageCache } from "./WebStorageCache";
+
+describe("WebStorageCache Tests", () => {
+  test("test", async () => {
+    const cache = new WebStorageCache();
+    await cache.init();
+    await cache.setItem("key", "value");
+    const value = await cache.getItem("key");
+    expect(value).toBe("value");
+
+    await cache.removeItem("key");
+    const value2 = await cache.getItem("key");
+    expect(value2).toBeNull();
+  });
+});

package/src/cache/WebStorageCache.ts

@@ -0,0 +1,24 @@
+import { CacheProvider } from "./interface";
+
+// super thin wrapper around localStorage
+export class WebStorageCache implements CacheProvider {
+  async init() {
+    return;
+  }
+
+  async setItem(key: string, value: string): Promise<void> {
+    localStorage.setItem(key, value);
+  }
+
+  async getItem(key: string): Promise<string | null> {
+    return localStorage.getItem(key);
+  }
+
+  async removeItem(key: string): Promise<void> {
+    localStorage.removeItem(key);
+  }
+
+  async clear(): Promise<void> {
+    localStorage.clear();
+  }
+}

package/src/cache/index.ts

@@ -0,0 +1 @@
+export * from "./interface.js";

package/src/cache/interface.ts

@@ -0,0 +1,7 @@
+export interface CacheProvider {
+  init(): Promise<void>;
+  setItem(key: string, value: string): Promise<void>;
+  getItem(key: string): Promise<string | null>;
+  removeItem(key: string): Promise<void>;
+  clear(): Promise<void>;
+}

package/src/config.ts

@@ -11,6 +11,10 @@ export class Config {
   static DefaultCurrency = "usd";
   // caches the raw transactions in browser's local storage instead of memory
   static UseLocalStorageCache = false;
+  // caches the raw transactions in browser's indexedDB instead of memory
+  static UseIndexedDBCache = false;
+  // caches the raw transactions in browser's memory
+  static UseMemoryCache = false;
   private static DefaultWordlist = english;
 
   public static setIpfsGateway(ipfsGateway: string) {

package/src/history/electrumTransformer.ts

@@ -7,6 +7,8 @@ import {
   decodeCashAddress,
   TransactionCommon,
   assertSuccess,
+  OpcodesBCH,
+  Opcodes,
 } from "@bitauth/libauth";
 import { UnitEnum } from "../enum.js";
 import NetworkProvider from "../network/NetworkProvider.js";
@@ -174,7 +176,7 @@ export const getAddressHistory = async ({
       const cached = addressCache[output.lockingBytecode as any];
       let address: string;
       if (!cached) {
-        if (output.valueSatoshis === 0n) {
+        if (output.lockingBytecode[0] === Opcodes.OP_RETURN) {
           address = `OP_RETURN: ${binToHex(output.lockingBytecode)}`;
         } else {
           address = assertSuccess(

package/src/network/ElectrumNetworkProvider.ts

@@ -20,13 +20,49 @@ import { CancelWatchFn } from "../wallet/interface.js";
 import { getTransactionHash } from "../util/transaction.js";
 import { Config } from "../config.js";
 import { decodeHeader } from "../util/header.js";
+import { CacheProvider } from "../cache/interface.js";
+import { IndexedDbCache } from "../cache/IndexedDbCache.js";
+import { WebStorageCache } from "../cache/WebStorageCache.js";
+import { MemoryCache } from "../cache/MemoryCache.js";
 
 export default class ElectrumNetworkProvider implements NetworkProvider {
   public electrum: ElectrumCluster | ElectrumClient;
   public subscriptions: number = 0;
   public version;
   private connectPromise;
-  private blockHeight = 0;
+
+  private _cache: CacheProvider | undefined;
+
+  get cache(): CacheProvider | undefined {
+    if (
+      !Config.UseMemoryCache &&
+      !Config.UseLocalStorageCache &&
+      !Config.UseIndexedDBCache
+    ) {
+      this._cache = undefined;
+      return this._cache;
+    }
+
+    if (Config.UseMemoryCache && !(this._cache instanceof MemoryCache)) {
+      this._cache = new IndexedDbCache();
+      return this._cache;
+    }
+
+    if (
+      Config.UseLocalStorageCache &&
+      !(this._cache instanceof WebStorageCache)
+    ) {
+      this._cache = new WebStorageCache();
+      return this._cache;
+    }
+
+    if (Config.UseIndexedDBCache && !(this._cache instanceof IndexedDbCache)) {
+      this._cache = new IndexedDbCache();
+      return this._cache;
+    }
+
+    return this._cache;
+  }
 
   constructor(
     electrum: ElectrumCluster | ElectrumClient,
@@ -112,30 +148,25 @@ 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 (this.cache) {
+      const cached = await this.cache.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;
+    if (this.cache) {
+      await this.cache.setItem(key, JSON.stringify(result));
     }
 
     return verbose ? decodeHeader(result) : result;
@@ -146,7 +177,6 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
       .height;
   }
 
-  static rawTransactionCache = {};
   async getRawTransaction(
     txHash: string,
     verbose: boolean = false,
@@ -154,13 +184,11 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   ): Promise<string> {
     const key = `tx-${this.network}-${txHash}-${verbose}-${loadInputValues}`;
 
-    if (Config.UseLocalStorageCache) {
-      const cached = localStorage.getItem(key);
+    if (this.cache) {
+      const cached = await this.cache.getItem(key);
       if (cached) {
         return verbose ? JSON.parse(cached) : cached;
       }
-    } else {
-      ElectrumNetworkProvider.rawTransactionCache[key];
     }
 
     try {
@@ -170,15 +198,13 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
         verbose
       )) as ElectrumRawTransaction;
 
-      if (Config.UseLocalStorageCache) {
-        localStorage.setItem(
+      if (this.cache) {
+        await this.cache.setItem(
           key,
           verbose
             ? JSON.stringify(transaction)
             : (transaction as unknown as string)
         );
-      } else {
-        ElectrumNetworkProvider.rawTransactionCache[key] = transaction;
       }
 
       if (verbose && loadInputValues) {
@@ -551,6 +577,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   async connect(): Promise<void[]> {
+    await this.cache?.init();
     return await this.connectPromise;
   }
 

package/src/network/constant.ts

@@ -33,7 +33,7 @@ export const mainnetServers = [
 export const testnetServers = [
   // "wss://chipnet.imaginary.cash:50004",
   //"wss://blackie.c3-soft.com:64004", // chipnet with protocol 1.5.0
-  "wss://chipnet.bch.ninja:50004"
+  "wss://chipnet.bch.ninja:50004",
 ];
 
 export const regtestServers = ["ws://127.0.0.1:60003"];

package/src/wallet/Wif.test.ts

@@ -543,18 +543,6 @@ describe(`Watch only Wallets`, () => {
 
     expect(await bobWallet.getLastTransaction()).not.toBeNull();
   });
-
-  test("Should fail localStorage cache", async () => {
-    const aliceWif = `wif:regtest:${process.env.PRIVATE_WIF!}`;
-    const aliceWallet = await RegTestWallet.fromId(aliceWif);
-
-    expect(await aliceWallet.getLastTransaction()).not.toBeNull();
-    Config.UseLocalStorageCache = true;
-    await expect(aliceWallet.getLastTransaction()).rejects.toThrow(
-      "localStorage is not defined"
-    );
-    Config.UseLocalStorageCache = false;
-  });
 });
 describe(`Wallet subscriptions`, () => {
   test("Should wait for transaction", async () => {