mainnet-js 2.7.34 → 3.0.0-next.1

package/src/cache/walletCache.ts

@@ -0,0 +1,239 @@
+import {
+  assertSuccess,
+  CashAddressNetworkPrefix,
+  CashAddressType,
+  deriveHdPathRelative,
+  encodeCashAddress,
+  hash160,
+  HdPrivateNodeValid,
+  HdPublicNodeValid,
+  secp256k1,
+} from "@bitauth/libauth";
+import { Config } from "../config.js";
+import { CacheProvider } from "./interface.js";
+import { IndexedDbCache } from "./IndexedDbCache.js";
+import { MemoryCache } from "./MemoryCache.js";
+import { WebStorageCache } from "./WebStorageCache.js";
+import { Utxo } from "../interface.js";
+
+export const stringify = (_: any) =>
+  JSON.stringify(_, (_, value) =>
+    typeof value === "bigint" ? value.toString() + "n" : value
+  );
+export const parse = (data: string) =>
+  JSON.parse(data, (_, value) => {
+    if (typeof value === "string" && /^\d+n$/.test(value)) {
+      return BigInt(value.slice(0, -1));
+    }
+    return value;
+  });
+
+export interface WalletCacheEntry {
+  address: string;
+  tokenAddress: string;
+  privateKey: Uint8Array | undefined;
+  publicKey: Uint8Array;
+  publicKeyHash: Uint8Array;
+  index: number;
+  change: boolean;
+  status: string | null;
+  utxos: Utxo[];
+}
+
+// Minimal interface for use in transaction signing
+export interface WalletCache {
+  get(address: string): { privateKey: Uint8Array | undefined } | undefined;
+}
+
+// Full interface for wallet cache management
+export interface WalletCacheI extends WalletCache {
+  init(): Promise<void>;
+  persist(): Promise<void>;
+  get(address: string): WalletCacheEntry | undefined;
+  getByIndex(addressIndex: number, change: boolean): WalletCacheEntry;
+  setStatusAndUtxos(
+    address: string,
+    status: string | null,
+    utxos: Utxo[]
+  ): void;
+}
+
+export class WalletCache implements WalletCacheI {
+  private _storage: CacheProvider | undefined;
+  private walletCache: Record<string, WalletCacheEntry> = {};
+  private indexCache: Record<
+    string,
+    {
+      index: number;
+      change: boolean;
+    }
+  > = {};
+  private timeouts: NodeJS.Timeout[] = [];
+
+  get storage(): CacheProvider | undefined {
+    if (
+      !Config.UseMemoryCache &&
+      !Config.UseLocalStorageCache &&
+      !Config.UseIndexedDBCache
+    ) {
+      this._storage = undefined;
+      return this._storage;
+    }
+
+    if (Config.UseMemoryCache && !(this._storage instanceof MemoryCache)) {
+      this._storage = new MemoryCache();
+      return this._storage;
+    }
+
+    if (
+      Config.UseLocalStorageCache &&
+      !(this._storage instanceof WebStorageCache)
+    ) {
+      this._storage = new WebStorageCache();
+      return this._storage;
+    }
+
+    if (
+      Config.UseIndexedDBCache &&
+      !(this._storage instanceof IndexedDbCache)
+    ) {
+      this._storage = new IndexedDbCache();
+      return this._storage;
+    }
+
+    return this._storage;
+  }
+
+  constructor(
+    public walletId: string,
+    public hdNode: HdPublicNodeValid | HdPrivateNodeValid,
+    public networkPrefix: string,
+    public writeTimeout: number = 2000
+  ) {
+    if (!this.hdNode) {
+      throw new Error("HDNode is undefined");
+    }
+  }
+
+  public async init() {
+    await this.storage?.init();
+    const data = await this.storage?.getItem(`walletCache-${this.walletId}`);
+    if (data) {
+      try {
+        const parsed = parse(data);
+        this.walletCache = parsed.walletCache || {};
+        this.indexCache = parsed.indexCache || {};
+      } catch (e) {
+        // ignore
+      }
+    }
+  }
+
+  public async persist() {
+    this.timeouts.map(clearTimeout);
+    this.timeouts = [];
+
+    this.storage?.setItem(
+      `walletCache-${this.walletId}`,
+      stringify({
+        walletCache: this.walletCache,
+        indexCache: this.indexCache,
+      })
+    );
+  }
+
+  public getByIndex(addressIndex: number, change: boolean) {
+    const id = `${this.walletId}-${addressIndex}-${change}`;
+    if (!this.walletCache[id]) {
+      const node = deriveHdPathRelative(
+        this.hdNode,
+        `${change ? 1 : 0}/${addressIndex}`
+      );
+
+      const privateKey = "privateKey" in node ? node.privateKey : undefined;
+      const publicKey =
+        "publicKey" in node
+          ? node.publicKey
+          : assertSuccess(secp256k1.derivePublicKeyUncompressed(privateKey!));
+      const publicKeyCompressed = assertSuccess(
+        secp256k1.compressPublicKey(publicKey)
+      );
+      const publicKeyHash = hash160(publicKeyCompressed);
+
+      const address = encodeCashAddress({
+        throwErrors: true,
+        prefix: this.networkPrefix as CashAddressNetworkPrefix,
+        type: CashAddressType.p2pkh,
+        payload: publicKeyHash,
+      }).address;
+
+      const tokenAddress = encodeCashAddress({
+        throwErrors: true,
+        prefix: this.networkPrefix as CashAddressNetworkPrefix,
+        type: CashAddressType.p2pkhWithTokens,
+        payload: publicKeyHash,
+      }).address;
+
+      this.walletCache[id] = {
+        address,
+        tokenAddress,
+        privateKey: privateKey,
+        publicKey,
+        publicKeyHash,
+        index: addressIndex,
+        change,
+        status: null,
+        utxos: [],
+      };
+
+      this.indexCache[address] = {
+        index: addressIndex,
+        change,
+      };
+
+      // batch new data into a single writeout
+      this.timeouts.push(
+        setTimeout(() => {
+          this.persist().catch(() => {});
+        }, this.writeTimeout)
+      );
+    }
+
+    return this.walletCache[id];
+  }
+
+  public get(address: string) {
+    const { index, change } = this.indexCache[address] || {};
+    if (index === undefined || change === undefined) {
+      return undefined;
+    }
+    return this.getByIndex(index, change);
+  }
+
+  public setStatusAndUtxos(
+    address: string,
+    status: string | null,
+    utxos: Utxo[]
+  ) {
+    const entry = this.get(address);
+    if (!entry) {
+      return;
+    }
+
+    const { index, change } = this.indexCache[address] || {};
+    if (index === undefined || change === undefined) {
+      return;
+    }
+
+    const key = `${this.walletId}-${index}-${change}`;
+    this.walletCache[key].status = status;
+    this.walletCache[key].utxos = utxos;
+
+    // batch new data into a single writeout
+    this.timeouts.push(
+      setTimeout(() => {
+        this.persist().catch(() => {});
+      }, this.writeTimeout)
+    );
+  }
+}

package/src/chain.ts

@@ -1,3 +1,3 @@
 export const bchParam = {
-  subUnits: 100000000,
+  subUnits: 100000000n,
 };

package/src/constant.ts

@@ -1,7 +1,7 @@
 export const DELIMITER = ":";
 
 // Min amount utxo can be to be accepted by the network
-export const DUST_UTXO_THRESHOLD = 546;
+export const DUST_UTXO_THRESHOLD = 546n;
 
 // Current chained tx limit
 export const MEMPOOL_CHAIN_LIMIT = 50;

package/src/enum.ts

@@ -10,7 +10,6 @@ export enum NetworkEnum {
   Mainnet = <any>"mainnet",
   Testnet = <any>"testnet",
   Regtest = <any>"regtest",
-  Simtest = <any>"simtest",
 }
 
 export const networkPrefixMap = {
@@ -30,11 +29,6 @@ const literal = <L extends string>(l: L): L => l;
 export const UnitEnum = {
   BCH: literal("bch"),
   USD: literal("usd"),
-  BIT: literal("bit"),
-  BITS: literal("bits"),
   SAT: literal("sat"),
-  SATS: literal("sats"),
-  SATOSHI: literal("satoshi"),
-  SATOSHIS: literal("satoshis"),
 };
 export type UnitEnum = typeof UnitEnum[keyof typeof UnitEnum];

package/src/history/{electrumTransformer.test.ts → getHistory.test.ts}

@@ -2,14 +2,12 @@ import { RegTestWallet, Wallet } from "../wallet/Wif";
 import { WalletTypeEnum } from "../wallet/enum";
 import { createWallet } from "../wallet/createWallet";
 import { mine } from "../mine";
-import { getAddressHistory } from "./electrumTransformer";
+import { encodeCashAddress } from "@bitauth/libauth";
+import { toBch } from "../util";
 
 test("Should get miner history", async () => {
   const alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF!);
-  const history = await getAddressHistory({
-    address: alice.getDepositAddress(),
-    provider: alice.provider!,
-  });
+  const history = await alice.getHistory();
   expect(history.length).toBeGreaterThan(0);
 });
 
@@ -31,40 +29,33 @@ test("Should get an address history", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
       {
         cashaddr: charlie.cashaddr!,
-        value: 41000,
-        unit: "satoshis",
+        value: 41000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     await bob.send([
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.
-    const bobHistory = await getAddressHistory({
-      address: bob.getDepositAddress(),
-      provider: bob.provider!,
-    });
+    const bobHistory = await bob.getHistory();
     expect(bobHistory[0].valueChange).toBe(-2320);
     expect(
       bobHistory[0].outputs.some(
@@ -116,35 +107,29 @@ test("Should get a history with multi-party sends", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     await bob.send([
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
 
     // Build Bob's wallet from a public address, check his balance.
-    const bobHistory = await getAddressHistory({
-      address: bob.getDepositAddress(),
-      provider: bob.provider!,
-    });
+    const bobHistory = await bob.getHistory();
 
     expect(bobHistory[1].fee).toBeGreaterThan(120);
     expect(bobHistory[1].fee).toBe(220);
@@ -199,37 +184,31 @@ test("Should cut results with a longer history to given count", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 31000,
-        unit: "satoshis",
+        value: 31000n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.send([
       {
         cashaddr: charlie.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
       {
         cashaddr: alice.cashaddr!,
-        value: 2100,
-        unit: "satoshis",
+        value: 2100n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.
-    const bobHistory = await getAddressHistory({
-      address: bob.getDepositAddress(),
-      provider: bob.provider!,
+    const bobHistory = await bob.getHistory({
       unit: "sat",
       start: 0,
       count: 2,
@@ -269,36 +248,30 @@ test("Should handle input and fee from many utxos", async () => {
     let sendResponse = await alice.send([
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
       {
         cashaddr: bob.cashaddr!,
-        value: 600,
-        unit: "satoshis",
+        value: 600n,
       },
     ]);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
     await bob.sendMax(charlie.cashaddr!);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
     expect(sendResponse!.txId!.length).toBe(64);
-    expect(sendResponse.balance!.bch).toBeGreaterThan(0.01);
+    expect(toBch(sendResponse.balance!)).toBeGreaterThan(0.01);
     await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
 
     // Build Bob's wallet from a public address, check his balance.
-    const bobHistory = await getAddressHistory({
-      address: bob.getDepositAddress(),
-      provider: bob.provider!,
+    const bobHistory = await bob.getHistory({
       unit: "sat",
     });
 

package/src/history/{electrumTransformer.ts → getHistory.ts}

@@ -22,8 +22,8 @@ type Transaction = TransactionCommon & {
   hash: string;
 };
 
-export const getAddressHistory = async ({
-  address,
+export const getHistory = async ({
+  addresses,
   provider,
   unit = "sat",
   fromHeight = 0,
@@ -31,7 +31,7 @@ export const getAddressHistory = async ({
   start = 0,
   count = -1,
 }: {
-  address: string;
+  addresses: string[];
   provider: NetworkProvider;
   unit?: UnitEnum;
   fromHeight?: number;
@@ -39,24 +39,39 @@ export const getAddressHistory = async ({
   start?: number;
   count?: number;
 }): Promise<TransactionHistoryItem[]> => {
+  if (!addresses.length) {
+    return [];
+  }
+
   if (count === -1) {
     count = 1e10;
   }
 
-  const history = (await provider.getHistory(address, fromHeight, toHeight))
+  const history = (
+    await Promise.all(
+      addresses.map(async (address) =>
+        provider.getHistory(address, fromHeight, toHeight)
+      )
+    )
+  )
+    .flat()
+    .filter(
+      (value, index, array) =>
+        array.findIndex((item) => item.tx_hash === value.tx_hash) === index
+    )
     .sort((a, b) =>
       a.height <= 0 || b.height <= 0 ? a.height - b.height : b.height - a.height
     )
     .slice(start, start + count);
 
   // fill transaction timestamps by requesting headers from network and parsing them
-  const heights = history
+  const uniqueHeights = history
     .map((tx) => tx.height)
     .filter((height) => height > 0)
     .filter((value, index, array) => array.indexOf(value) === index);
   const timestampMap = (
     await Promise.all(
-      heights.map(async (height) => [
+      uniqueHeights.map(async (height) => [
         height,
         ((await provider.getHeader(height, true)) as HeaderI).timestamp,
       ])
@@ -118,10 +133,8 @@ export const getAddressHistory = async ({
     {} as { [hash: string]: TransactionCommon }
   );
 
-  const decoded = decodeCashAddress(address);
-  if (typeof decoded === "string") {
-    throw decoded;
-  }
+  const decoded = assertSuccess(decodeCashAddress(addresses[0]));
+  const prefix = decoded.prefix as CashAddressNetworkPrefix;
 
   const addressCache: Record<any, string> = {};
 
@@ -165,7 +178,7 @@ export const getAddressHistory = async ({
         address = assertSuccess(
           lockingBytecodeToCashAddress({
             bytecode: prevoutOutput.lockingBytecode,
-            prefix: decoded.prefix as CashAddressNetworkPrefix,
+            prefix: prefix,
           })
         ).address;
         addressCache[prevoutOutput.lockingBytecode as any] = address;
@@ -203,7 +216,7 @@ export const getAddressHistory = async ({
           address = assertSuccess(
             lockingBytecodeToCashAddress({
               bytecode: output.lockingBytecode,
-              prefix: decoded.prefix as CashAddressNetworkPrefix,
+              prefix: prefix,
             })
           ).address;
           addressCache[output.lockingBytecode as any] = address;
@@ -253,7 +266,7 @@ export const getAddressHistory = async ({
     const nftTokenBalances: Record<string, bigint> = {};
 
     tx.inputs.forEach((input) => {
-      if (input.address === address) {
+      if (addresses.includes(input.address)) {
         satoshiBalance -= input.value;
 
         if (input.token?.amount) {
@@ -269,7 +282,7 @@ export const getAddressHistory = async ({
       }
     });
     tx.outputs.forEach((output) => {
-      if (output.address === address) {
+      if (addresses.includes(output.address)) {
         satoshiBalance += Number(output.value);
 
         if (output.token?.amount) {
@@ -319,7 +332,10 @@ export const getAddressHistory = async ({
   );
 
   // backfill the balances
-  let prevBalance = await provider.getBalance(address);
+  let prevBalance = (
+    await Promise.all(addresses.map((address) => provider.getBalance(address)))
+  ).reduce((a, b) => a + b, 0);
+
   let prevValueChange = 0;
   historyItems.forEach((tx) => {
     tx.balance = prevBalance - prevValueChange;

package/src/index.ts

@@ -7,7 +7,9 @@ export * from "./network/index.js";
 export { SignedMessage } from "./message/signed.js";
 
 export * from "./wallet/Base.js";
+export * from "./wallet/Watch.js";
 export * from "./wallet/Wif.js";
+export * from "./wallet/HDWallet.js";
 export * from "./wallet/createWallet.js";
 
 // provider
@@ -27,7 +29,7 @@ export * from "./wallet/model.js";
 import * as Mainnet from "./util/index.js";
 export { Mainnet };
 export * from "./util/index.js";
-export { getAddressHistory } from "./history/electrumTransformer.js";
+export { getHistory } from "./history/getHistory.js";
 
 // libauth
 export * as libauth from "./libauth.js";

package/src/interface.ts

@@ -15,13 +15,19 @@ export const Network = {
 };
 export type Network = typeof Network[keyof typeof Network];
 
-export interface UtxoI {
+export interface Utxo {
   txid: string;
   vout: number;
-  satoshis: number;
+  satoshis: bigint;
   height?: number;
   coinbase?: boolean;
   token?: TokenI;
+  address: string;
+}
+
+export interface UtxoId {
+  txid: string;
+  vout: number;
 }
 
 export interface ElectrumBalanceI {

package/src/message/interface.ts

@@ -1,37 +1,11 @@
-// interface EncryptedMessageFunc {
-//     (message: string, privateKey: string): string;
-//   }
-
-//   interface DecryptedMessageFunc {
-//     (message: string, publicKeyHash: string): string;
-//   }
-
-// export interface EncryptedMessageI{
-//     encrypt: EncryptedMessageFunc
-//     decrypt: DecryptedMessageFunc
-// }
-
-// interface SignMessageFunc {
-//   sign(message: string, privateKey: Uint8Array): Promise<string>
-// }
-
-// interface VerifyMessageFunc {
-//   verify(message: string,
-//     signature: string,
-//     cashaddr: string): Promise<boolean>;
-// }
-
 export interface SignedMessageI {
-  sign(
-    message: string,
-    privateKey: Uint8Array
-  ): Promise<SignedMessageResponseI>;
+  sign(message: string, privateKey: Uint8Array): SignedMessageResponseI;
   verify(
     message: string,
     signature: string,
     cashaddr: string,
     publicKey?: Uint8Array
-  ): Promise<VerifyMessageResponseI>;
+  ): VerifyMessageResponseI;
 }
 
 export interface SignedMessageRawI {