mainnet-js 3.1.7 → 4.0.0-next.2

package/src/cache/walletCache.ts

@@ -58,7 +58,7 @@ export interface WalletCache {
 // Full interface for wallet cache management
 export interface WalletCacheI extends WalletCache {
   init(): Promise<void>;
-  persist(): Promise<void>;
+  persist(immediate?: boolean): Promise<void>;
   get(address: string): WalletCacheEntry | undefined;
   getByIndex(addressIndex: number, change: boolean): WalletCacheEntry;
   setStatusAndUtxos(
@@ -70,51 +70,114 @@ export interface WalletCacheI extends WalletCache {
   ): void;
 }
 
-export class PersistentWalletCache implements WalletCacheI {
+function getStorage(): CacheProvider | undefined {
+  if (Config.UseMemoryCache) return new MemoryCache();
+  if (Config.UseLocalStorageCache) return new WebStorageCache();
+  if (Config.UseIndexedDBCache) return new IndexedDbCache("WalletCache");
+  return undefined;
+}
+
+/// Cache for single-address wallets (WatchWallet, Wif)
+export class SingleAddressWalletCache implements WalletCacheI {
+  private entry: WalletCacheEntry;
   private _storage: CacheProvider | undefined;
-  private walletCache: Record<string, WalletCacheEntry> = {};
-  private indexCache: Record<
-    string,
-    {
-      index: number;
-      change: boolean;
-    }
-  > = {};
   private debounceTimer: ReturnType<typeof setTimeout> | undefined;
 
-  get storage(): CacheProvider | undefined {
-    if (
-      !Config.UseMemoryCache &&
-      !Config.UseLocalStorageCache &&
-      !Config.UseIndexedDBCache
-    ) {
-      this._storage = undefined;
-      return this._storage;
-    }
+  constructor(
+    public walletId: string,
+    address: string,
+    tokenAddress: string,
+    public writeTimeout: number = 2000
+  ) {
+    this.entry = {
+      address,
+      tokenAddress,
+      privateKey: undefined,
+      publicKey: new Uint8Array(),
+      publicKeyHash: new Uint8Array(),
+      index: 0,
+      change: false,
+      status: null,
+      utxos: [],
+      rawHistory: [],
+      lastConfirmedHeight: 0,
+    };
+  }
 
-    if (Config.UseMemoryCache && !(this._storage instanceof MemoryCache)) {
-      this._storage = new MemoryCache();
-      return this._storage;
+  public async init() {
+    this._storage = getStorage();
+    await this._storage?.init();
+    const data = await this._storage?.getItem(`walletCache-${this.walletId}`);
+    if (data) {
+      try {
+        const parsed = parse(data);
+        // Restore persisted fields, keep address identity from constructor
+        const addr = this.entry.address;
+        const tokenAddr = this.entry.tokenAddress;
+        Object.assign(this.entry, parsed, {
+          address: addr,
+          tokenAddress: tokenAddr,
+        });
+      } catch (_e) {
+        // ignore
+      }
     }
+  }
 
-    if (
-      Config.UseLocalStorageCache &&
-      !(this._storage instanceof WebStorageCache)
-    ) {
-      this._storage = new WebStorageCache();
-      return this._storage;
+  public async persist(immediate = false) {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (immediate) {
+      this.debounceTimer = undefined;
+      await this._storage?.setItem(
+        `walletCache-${this.walletId}`,
+        stringify(this.entry)
+      );
+    } else {
+      this.debounceTimer = setTimeout(() => {
+        this.debounceTimer = undefined;
+        this._storage?.setItem(
+          `walletCache-${this.walletId}`,
+          stringify(this.entry)
+        );
+      }, this.writeTimeout);
     }
+  }
 
-    if (
-      Config.UseIndexedDBCache &&
-      !(this._storage instanceof IndexedDbCache)
-    ) {
-      this._storage = new IndexedDbCache("WalletCache");
-      return this._storage;
-    }
+  public get(address: string) {
+    return address === this.entry.address ? this.entry : undefined;
+  }
+
+  public getByIndex(_index: number, _change: boolean) {
+    return this.entry;
+  }
 
-    return this._storage;
+  public setStatusAndUtxos(
+    address: string,
+    status: string | null,
+    utxos: Utxo[],
+    rawHistory: TxI[],
+    lastConfirmedHeight: number
+  ) {
+    if (address !== this.entry.address) return;
+    this.entry.status = status;
+    this.entry.utxos = utxos;
+    this.entry.rawHistory = rawHistory;
+    this.entry.lastConfirmedHeight = lastConfirmedHeight;
+    this.persist();
   }
+}
+
+export class HDWalletCache implements WalletCacheI {
+  private _storage: CacheProvider | undefined;
+  private walletCache: Record<string, WalletCacheEntry> = {};
+  private indexCache: Record<
+    string,
+    {
+      index: number;
+      change: boolean;
+    }
+  > = {};
+  private debounceTimer: ReturnType<typeof setTimeout> | undefined;
 
   constructor(
     public walletId: string,
@@ -128,8 +191,9 @@ export class PersistentWalletCache implements WalletCacheI {
   }
 
   public async init() {
-    await this.storage?.init();
-    const data = await this.storage?.getItem(`walletCache-${this.walletId}`);
+    this._storage = getStorage();
+    await this._storage?.init();
+    const data = await this._storage?.getItem(`walletCache-${this.walletId}`);
     if (data) {
       try {
         const parsed = parse(data);
@@ -141,24 +205,25 @@ export class PersistentWalletCache implements WalletCacheI {
     }
   }
 
-  private schedulePersist() {
+  public async persist(immediate = false) {
     if (this.debounceTimer) clearTimeout(this.debounceTimer);
-    this.debounceTimer = setTimeout(() => {
-      this.persist().catch(() => {});
-    }, this.writeTimeout);
-  }
-
-  public async persist() {
-    if (this.debounceTimer) clearTimeout(this.debounceTimer);
-    this.debounceTimer = undefined;
-
-    this.storage?.setItem(
-      `walletCache-${this.walletId}`,
-      stringify({
-        walletCache: this.walletCache,
-        indexCache: this.indexCache,
-      })
-    );
+    const write = () =>
+      this._storage?.setItem(
+        `walletCache-${this.walletId}`,
+        stringify({
+          walletCache: this.walletCache,
+          indexCache: this.indexCache,
+        })
+      );
+    if (immediate) {
+      this.debounceTimer = undefined;
+      await write();
+    } else {
+      this.debounceTimer = setTimeout(() => {
+        this.debounceTimer = undefined;
+        write();
+      }, this.writeTimeout);
+    }
   }
 
   public getByIndex(addressIndex: number, change: boolean) {
@@ -212,7 +277,7 @@ export class PersistentWalletCache implements WalletCacheI {
         change,
       };
 
-      this.schedulePersist();
+      this.persist();
     }
 
     return this.walletCache[id];
@@ -249,6 +314,6 @@ export class PersistentWalletCache implements WalletCacheI {
     this.walletCache[key].rawHistory = rawHistory;
     this.walletCache[key].lastConfirmedHeight = lastConfirmedHeight;
 
-    this.schedulePersist();
+    this.persist();
   }
 }

package/src/mine/mine.ts

@@ -1,4 +1,7 @@
 import { binToBase64, utf8ToBin } from "@bitauth/libauth";
+import { http } from "@rpckit/http";
+import { fallback } from "@rpckit/fallback";
+import type { Transport } from "@rpckit/core";
 
 /**
  * Mine blocks to a regtest address
@@ -16,27 +19,20 @@ export const mine = async ({
   cashaddr: string;
   blocks: number;
 }): Promise<any> => {
-  const response = await fetch(`http://127.0.0.1:${process.env.RPC_PORT}/`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization:
-        "Basic " +
-        binToBase64(
-          utf8ToBin(`${process.env.RPC_USER}:${process.env.RPC_PASS}`)
-        ),
-    },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: "0",
-      method: "generatetoaddress",
-      params: {
-        nblocks: blocks,
-        address: cashaddr,
-      },
-    }),
-  });
-  const json = await response.json();
+  const auth =
+    "Basic " +
+    binToBase64(utf8ToBin(`${process.env.RPC_USER}:${process.env.RPC_PASS}`));
 
-  return json.result;
+  const transports = ["127.0.0.1", "host.docker.internal"].map((host) =>
+    http(`http://${host}:${process.env.RPC_PORT}/`, {
+      headers: { Authorization: auth },
+    })
+  ) as [Transport, Transport];
+
+  const transport = fallback(transports);
+  try {
+    return await transport.request("generatetoaddress", blocks, cashaddr);
+  } finally {
+    await transport.close();
+  }
 };

package/src/network/Connection.test.ts

@@ -1,4 +1,5 @@
-import { initProviders, disconnectProviders, Connection } from "./Connection";
+import { initProviders, disconnectProviders } from "./Connection";
+import { createProvider } from "./default";
 import { RegTestWallet, TestNetWallet, Wallet } from "../wallet/Wif";
 
 beforeAll(async () => {
@@ -41,11 +42,11 @@ test.skip("Should lower overhead in creating wallets", async () => {
   expect(height).toBeGreaterThan(114);
 });
 
-test("Should create a new Connection", async () => {
-  let conn = new Connection("mainnet", "wss://bch.imaginary.cash:50004");
-  await conn.ready();
-  expect(conn.networkProvider == globalThis.BCH).toBeFalsy();
-  let blockheight = await conn.networkProvider.getBlockHeight();
+test("Should create a provider with custom servers", async () => {
+  let provider = await createProvider("mainnet", "wss://fulcrum.pat.mn:50004");
+  await provider.connect();
+  expect(provider == globalThis.BCH).toBeFalsy();
+  let blockheight = await provider.getBlockHeight();
   expect(blockheight).toBeGreaterThan(10000);
-  expect(10001).toBeGreaterThan(10000);
+  await provider.disconnect();
 });

package/src/network/Connection.ts

@@ -1,19 +1,16 @@
-import { default as NetworkProvider } from "./NetworkProvider.js";
 import {
-  getNetworkProvider,
+  createProvider,
   setGlobalProvider,
   getGlobalProvider,
   removeGlobalProvider,
 } from "./default.js";
 import { Network } from "../interface.js";
 import { networkTickerMap } from "./constant.js";
-import { prefixFromNetworkMap } from "../enum.js";
-import { CashAddressNetworkPrefix } from "@bitauth/libauth";
 
 export async function initProvider(network: Network) {
   if (!getGlobalProvider(network)) {
-    const conn = new Connection(network);
-    const provider = (await conn.ready()).networkProvider;
+    const provider = await createProvider(network);
+    await provider.connect();
     setGlobalProvider(network, provider);
     return provider;
   }
@@ -22,10 +19,18 @@ export async function initProvider(network: Network) {
 
 export async function initProviders(networks?: Network[]) {
   networks = networks ? networks : (Object.keys(networkTickerMap) as Network[]);
-  let initPromises = networks.map((n) => initProvider(n));
-  await Promise.all(initPromises).catch((e) => {
-    console.warn(`Warning, couldn't establish a connection for ${e}`);
-  });
+  const results = await Promise.allSettled(
+    networks.map((n) => initProvider(n))
+  );
+  for (let i = 0; i < results.length; i++) {
+    if (results[i].status === "rejected") {
+      const { reason } = results[i] as PromiseRejectedResult;
+      const message = reason instanceof Error ? reason.message : reason;
+      console.warn(
+        `Warning, couldn't establish a connection for ${networks[i]}: ${message}`
+      );
+    }
+  }
 }
 
 async function disconnectProvider(network: Network) {
@@ -33,41 +38,10 @@ async function disconnectProvider(network: Network) {
   if (provider) {
     await provider.disconnect();
     removeGlobalProvider(network);
-    return;
-  } else {
-    // console.warn(
-    //   `Ignoring attempt to disconnect non-existent ${network} provider`
-    // );
-    return true;
   }
 }
 
 export async function disconnectProviders(networks?: Network[]) {
   networks = networks ? networks : (Object.keys(networkTickerMap) as Network[]);
-  let disconnectPromises = networks.map((n) => disconnectProvider(n));
-  await Promise.all(disconnectPromises);
-}
-
-export class Connection {
-  public network: Network;
-  public servers?: string[];
-  public networkPrefix: CashAddressNetworkPrefix;
-  public networkProvider: NetworkProvider;
-
-  constructor(network?: Network, servers?: string[] | string) {
-    this.network = network ? network : "mainnet";
-    this.networkPrefix = prefixFromNetworkMap[this.network];
-    this.networkProvider = getNetworkProvider(this.network, servers, true);
-  }
-
-  public async ready() {
-    await this.networkProvider.connect();
-    await this.networkProvider.ready();
-    return this;
-  }
-
-  public async disconnect() {
-    await this.networkProvider.disconnect();
-    return this;
-  }
+  await Promise.all(networks.map((n) => disconnectProvider(n)));
 }

package/src/network/ElectrumNetworkProvider.ts

@@ -1,10 +1,5 @@
-import {
-  ElectrumClient,
-  RequestResponse,
-  ElectrumClientEvents,
-  RPCNotification,
-  ConnectionStatus,
-} from "@electrum-cash/network";
+import type { Transport, Unsubscribe } from "@rpckit/core";
+import type { ElectrumCashSchema } from "@rpckit/core/electrum-cash";
 import { default as NetworkProvider } from "./NetworkProvider.js";
 import {
   HexHeaderI,
@@ -34,9 +29,8 @@ import { MemoryCache } from "../cache/MemoryCache.js";
 type CachedRawTransaction = ElectrumRawTransaction & { fetchHeight: number };
 
 export default class ElectrumNetworkProvider implements NetworkProvider {
-  public electrum: ElectrumClient<ElectrumClientEvents>;
+  public transport: Transport<ElectrumCashSchema>;
   public subscriptions: number = 0;
-  private subscriptionMap: Record<string, number> = {};
   private currentHeight: number = 0;
   private headerCancelFn?: CancelFn;
 
@@ -74,14 +68,13 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   }
 
   constructor(
-    electrum: ElectrumClient<ElectrumClientEvents>,
-    public network: Network = Network.MAINNET,
-    private manualConnectionManagement?: boolean
+    transport: Transport<ElectrumCashSchema>,
+    public network: Network = Network.MAINNET
   ) {
-    if (electrum) {
-      this.electrum = electrum;
+    if (transport) {
+      this.transport = transport;
     } else {
-      throw new Error(`A electrum-cash client is required.`);
+      throw new Error(`A transport is required.`);
     }
   }
 
@@ -162,6 +155,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
 
     if (misses.length > 0) {
+      // rpckit automatically batches concurrent requests via BatchScheduler
       const fetched = await Promise.all(
         misses.map(async (hash) => {
           const tx = await this.performRequest<string>(
@@ -215,6 +209,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     }
 
     if (misses.length > 0) {
+      // rpckit automatically batches concurrent requests via BatchScheduler
       const fetched = await Promise.all(
         misses.map(async (height) => {
           const result = await this.performRequest<HexHeaderI>(
@@ -342,7 +337,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     } catch (error: any) {
       if (
         (error.message as string).indexOf(
-          "No such mempool or blockchain transaction."
+          "No such mempool or blockchain transaction"
         ) > -1
       )
         throw Error(
@@ -490,8 +485,8 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   public async waitForBlock(height?: number): Promise<HexHeaderI> {
     return new Promise(async (resolve) => {
       let cancelWatch: CancelFn;
-      if (this.electrum.chainHeight && !height) {
-        height = this.electrum.chainHeight + 1;
+      if (this.currentHeight && !height) {
+        height = this.currentHeight + 1;
       }
 
       cancelWatch = await this.watchBlocks(async (header) => {
@@ -549,63 +544,38 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   ): Promise<T> {
     await this.ready();
 
-    const requestTimeout = new Promise(function (_resolve, reject) {
-      setTimeout(function () {
-        reject("electrum-cash request timed out, retrying");
-      }, 30000);
-    }).catch(function (e) {
-      throw e;
-    });
-
-    const request = this.electrum.request(name, ...parameters);
+    const TIMEOUT_MSG = "electrum-cash request timed out, retrying";
 
-    return await Promise.race([request, requestTimeout])
-      .then((value) => {
-        if (value instanceof Error) throw value;
-        let result = value as RequestResponse;
-        return result as T;
-      })
-      .catch(async () => {
-        return await Promise.race([request, requestTimeout])
-          .then((value) => {
-            if (value instanceof Error) throw value;
-            let result = value as RequestResponse;
-            return result as T;
-          })
-          .catch(function (e) {
-            throw e;
-          });
+    const makeTimeout = () =>
+      new Promise<never>(function (_resolve, reject) {
+        setTimeout(function () {
+          reject(TIMEOUT_MSG);
+        }, 30000);
       });
-  }
 
-  private async trackSubscription(
-    methodName: string,
-    ...parameters: (string | number | boolean)[]
-  ): Promise<void> {
-    const key = `${methodName}-${this.network}-${JSON.stringify(parameters)}`;
-    if (this.subscriptionMap[key]) {
-      this.subscriptionMap[key]++;
-    } else {
-      this.subscriptionMap[key] = 1;
-    }
+    const ensureError = (e: unknown): Error => {
+      if (e instanceof Error) return e;
+      if (typeof e === "object" && e !== null && "message" in e)
+        return Object.assign(new Error((e as any).message), e);
+      return new Error(typeof e === "string" ? e : String(e));
+    };
 
-    await this.electrum.subscribe(methodName, ...parameters);
-  }
+    const request = this.transport.request(name as any, ...(parameters as any));
 
-  private async untrackSubscription(
-    methodName: string,
-    ...parameters: (string | number | boolean)[]
-  ): Promise<void> {
-    const key = `${methodName}-${this.network}-${JSON.stringify(parameters)}`;
-    if (this.subscriptionMap[key]) {
-      this.subscriptionMap[key]--;
-      if (this.subscriptionMap[key] <= 0) {
-        // only really unsubscribe if there are no more subscriptions for this `key`
-        delete this.subscriptionMap[key];
-
-        try {
-          await this.electrum.unsubscribe(methodName, ...parameters);
-        } catch {}
+    try {
+      const value = await Promise.race([request, makeTimeout()]);
+      if (value instanceof Error) throw value;
+      return value as T;
+    } catch (e: unknown) {
+      const error = ensureError(e);
+      // Only retry on timeout, not on server errors
+      if (error.message !== TIMEOUT_MSG) throw error;
+      try {
+        const value = await Promise.race([request, makeTimeout()]);
+        if (value instanceof Error) throw value;
+        return value as T;
+      } catch (e2: unknown) {
+        throw ensureError(e2);
       }
     }
   }
@@ -617,19 +587,21 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
   ): Promise<CancelFn> {
     await this.ready();
 
-    const handler = (data: RPCNotification) => {
-      if (data.method === methodName) {
-        callback(data.params);
+    const subscribeFn = this.transport.subscribe.bind(this.transport) as (
+      method: string,
+      ...args: unknown[]
+    ) => Promise<Unsubscribe>;
+    const unsubscribe: Unsubscribe = await subscribeFn(
+      methodName,
+      ...parameters,
+      (data: unknown) => {
+        callback(data);
       }
-    };
-
-    this.electrum.on("notification", handler);
-    await this.trackSubscription(methodName, ...parameters);
+    );
     this.subscriptions++;
 
     return async () => {
-      this.electrum.off("notification", handler);
-      await this.untrackSubscription(methodName, ...parameters);
+      await unsubscribe();
       this.subscriptions--;
     };
   }
@@ -640,18 +612,12 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
 
   async connect(): Promise<void> {
     await this.cache?.init();
-    if (this.electrum.status !== ConnectionStatus.CONNECTED) {
-      await this.electrum.connect();
-    }
+    await this.transport.connect();
   }
 
   async disconnect(): Promise<boolean> {
-    if (this.subscriptions > 0) {
-      // console.warn(
-      //   `Trying to disconnect a network provider with ${this.subscriptions} active subscriptions. This is in most cases a bad idea.`
-      // );
-    }
     await this.headerCancelFn?.();
-    return this.electrum.disconnect(true, false);
+    await this.transport.close();
+    return true;
   }
 }

package/src/network/Rpc.test.ts

@@ -70,17 +70,18 @@ describe("Rpc tests", () => {
 
   test("Watch wallet balance", async () => {
     const aliceWallet = await RegTestWallet.fromId(aliceWif);
+    const bobWallet = await RegTestWallet.newRandom();
 
     let result = false;
-    aliceWallet.watchBalance((balance) => {
+    const cancel = await aliceWallet.watchBalance((balance) => {
       expect(balance).toBeGreaterThan(0);
       result = true;
-      // stop watching
-      return true;
     });
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    // we do not trigger the callback upon subscription anymore
+    // Trigger a real status change on Alice's address
+    await aliceWallet.send([{ cashaddr: bobWallet.cashaddr!, value: 1000n }]);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
     expect(result).toBe(true);
+    await cancel();
   });
 
   test("Wait for block timeout", async () => {