mainnet-js 2.7.31 → 3.0.0-next.0

package/src/cache/walletCache.ts

@@ -0,0 +1,252 @@
+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 addressCache: Record<string, {
+//   privateKey: Uint8Array | undefined,
+//   publicKey: Uint8Array,
+//   publicKeyHash: Uint8Array,
+//   index: number,
+//   change: boolean,
+// }> = {};
+
+export interface WalletCacheEntry {
+  address: string;
+  tokenAddress: string;
+  privateKey: Uint8Array | undefined;
+  publicKey: Uint8Array;
+  publicKeyHash: Uint8Array;
+  index: number;
+  change: boolean;
+  status: string | null;
+  utxos: Utxo[];
+}
+
+// export const getPrivateKey = (
+//   hdNode: HdPrivateNodeValid,
+//   addressIndex: number,
+//   change: boolean,
+// ): Uint8Array => {
+//   const node = deriveHdPathRelative(
+//     hdNode,
+//     `${change ? 1 : 0}/${addressIndex}`
+//   );
+
+//   return node.privateKey;
+// }
+
+export interface WalletCacheI {
+  init(): Promise<void>;
+  persist(): Promise<void>;
+  getByIndex(addressIndex: number, change: boolean): WalletCacheEntry;
+  getByAddress(address: string): WalletCacheEntry | undefined;
+  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 = JSON.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}`,
+      JSON.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 getByAddress(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.getByAddress(address);
+    if (!entry) {
+      return;
+    }
+
+    const { index, change } = this.indexCache[address] || {};
+    if (index === undefined || change === undefined) {
+      return undefined;
+    }
+
+    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)
+    );
+  }
+}
+
+// export const getAddressFromCache = (
+//   walletId: string,
+//   hdNode: HdPublicNodeValid | HdPrivateNodeValid,
+//   networkPrefix: string,
+//   addressIndex: number,
+//   change: boolean,
+// ): WalletCacheEntry => {
+
+// };

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

@@ -2,14 +2,11 @@ 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";
 
 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);
 });
 
@@ -61,10 +58,7 @@ test("Should get an address history", async () => {
     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(
@@ -141,10 +135,7 @@ test("Should get a history with multi-party sends", async () => {
     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);
@@ -227,9 +218,7 @@ test("Should cut results with a longer history to given count", async () => {
     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,
@@ -296,9 +285,7 @@ test("Should handle input and fee from many utxos", async () => {
     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,40 @@ type Transaction = TransactionCommon & {
   hash: string;
 };
 
-export const getAddressHistory = async ({
-  address,
+// export type AddressTxI = TxI & {
+//   address: string;
+// }
+
+// export const getAddressHistory = async ({
+//   address,
+//   provider,
+//   unit = "sat",
+//   fromHeight = 0,
+//   toHeight = -1,
+//   start = 0,
+//   count = -1,
+// }: {
+//   address: string;
+//   provider: NetworkProvider;
+//   unit?: UnitEnum;
+//   fromHeight?: number;
+//   toHeight?: number;
+//   start?: number;
+//   count?: number;
+// }): Promise<TransactionHistoryItem[]> => {
+//   return getHistory({
+//     addresses: [address],
+//     provider,
+//     unit,
+//     fromHeight,
+//     toHeight,
+//     start,
+//     count,
+//   });
+// }
+
+export const getHistory = async ({
+  addresses,
   provider,
   unit = "sat",
   fromHeight = 0,
@@ -31,7 +63,7 @@ export const getAddressHistory = async ({
   start = 0,
   count = -1,
 }: {
-  address: string;
+  addresses: string[];
   provider: NetworkProvider;
   unit?: UnitEnum;
   fromHeight?: number;
@@ -39,24 +71,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 +165,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 +210,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 +248,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 +298,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 +314,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 +364,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,20 @@ export const Network = {
 };
 export type Network = typeof Network[keyof typeof Network];
 
-export interface UtxoI {
+export interface Utxo {
   txid: string;
   vout: number;
   satoshis: number;
   height?: number;
   coinbase?: boolean;
   token?: TokenI;
+  address: string;
+}
+
+export interface UtxoId {
+  txid: string;
+  vout: number;
+  satoshis: 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 {