mainnet-js 3.1.7 → 4.0.0-next.10

package/src/history/getHistory.test.ts

@@ -1,290 +0,0 @@
-import { RegTestWallet, Wallet } from "../wallet/Wif";
-import { WalletTypeEnum } from "../wallet/enum";
-import { createWallet } from "../wallet/createWallet";
-import { mine } from "../mine";
-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 alice.getHistory();
-  expect(history.length).toBeGreaterThan(0);
-});
-
-// // This class transforms outputs from electrum to a standard array of history.
-test("Should get an address history", async () => {
-  // Build Alice's wallet from Wallet Import Format string
-  if (!process.env.PRIVATE_WIF) {
-    throw Error("Attempted to pass an empty WIF");
-  } else {
-    let alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF); // insert WIF from #1
-    const bob = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    const charlie = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    let sendResponse = await alice.send([
-      {
-        cashaddr: bob.cashaddr!,
-        value: 31000n,
-      },
-      {
-        cashaddr: charlie.cashaddr!,
-        value: 41000n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
-    await bob.send([
-      {
-        cashaddr: charlie.cashaddr!,
-        value: 2100n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
-    await bob.send([
-      {
-        cashaddr: alice.cashaddr!,
-        value: 2100n,
-      },
-    ]);
-    expect(sendResponse!.txId!.length).toBe(64);
-    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 bob.getHistory();
-    expect(bobHistory[0].valueChange).toBe(-2320);
-    expect(
-      bobHistory[0].outputs.some(
-        (output) => output.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(
-      bobHistory[0].inputs.some(
-        (input) => input.address === bob.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(bobHistory[1].valueChange).toBe(-2320);
-    expect(
-      bobHistory[1].inputs.some(
-        (input) => input.address === bob.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(
-      bobHistory[1].outputs.some(
-        (output) => output.address === charlie.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(bobHistory[2].valueChange).toBe(31000);
-    expect(bobHistory[2].balance).toBe(31000);
-    expect(bobHistory[2].fee).not.toBe(0);
-    expect(
-      bobHistory[2].inputs.some(
-        (input) => input.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-  }
-});
-
-// This class transforms outputs from electrum to a standard array of history.
-test("Should get a history with multi-party sends", async () => {
-  // Build Alice's wallet from Wallet Import Format string
-  if (!process.env.PRIVATE_WIF) {
-    throw Error("Attempted to pass an empty WIF");
-  } else {
-    let alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF); // insert WIF from #1
-    const bob = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    const charlie = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    let sendResponse = await alice.send([
-      {
-        cashaddr: bob.cashaddr!,
-        value: 31000n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
-    await bob.send([
-      {
-        cashaddr: charlie.cashaddr!,
-        value: 2100n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
-    await bob.send([
-      {
-        cashaddr: alice.cashaddr!,
-        value: 2100n,
-      },
-    ]);
-    expect(sendResponse!.txId!.length).toBe(64);
-    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 bob.getHistory();
-
-    expect(bobHistory[1].fee).toBeGreaterThan(120);
-    expect(bobHistory[1].fee).toBe(220);
-    expect(bobHistory[0].valueChange).toBe(-2320);
-    expect(
-      bobHistory[0].outputs.some(
-        (output) => output.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(
-      bobHistory[0].inputs.some(
-        (input) => input.address === bob.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(bobHistory[1].valueChange).toBe(-2320);
-    expect(
-      bobHistory[1].outputs.some(
-        (output) => output.address === charlie.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(
-      bobHistory[1].inputs.some(
-        (input) => input.address === bob.getDepositAddress()
-      )
-    ).toBe(true);
-
-    expect(bobHistory[2].valueChange).toBe(31000);
-    expect(bobHistory[2].fee).not.toBe(0);
-    expect(
-      bobHistory[2].inputs.some(
-        (input) => input.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-  }
-});
-
-// This class transforms outputs from electrum to a standard array of history.
-test("Should cut results with a longer history to given count", async () => {
-  // Build Alice's wallet from Wallet Import Format string
-  if (!process.env.PRIVATE_WIF) {
-    throw Error("Attempted to pass an empty WIF");
-  } else {
-    let alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF); // insert WIF from #1
-    const bob = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    const charlie = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    let sendResponse = await alice.send([
-      {
-        cashaddr: bob.cashaddr!,
-        value: 31000n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
-    await bob.send([
-      {
-        cashaddr: charlie.cashaddr!,
-        value: 2100n,
-      },
-      {
-        cashaddr: alice.cashaddr!,
-        value: 2100n,
-      },
-      {
-        cashaddr: alice.cashaddr!,
-        value: 2100n,
-      },
-    ]);
-    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
-    expect(sendResponse!.txId!.length).toBe(64);
-    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 bob.getHistory({
-      unit: "sat",
-      start: 0,
-      count: 2,
-    });
-    expect(bobHistory.length).toBe(2);
-
-    expect(bobHistory[0].valueChange).toBe(-6588);
-    expect(
-      bobHistory[0].outputs.some(
-        (output) => output.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(bobHistory[1].valueChange).toBe(31000);
-    expect(
-      bobHistory[1].outputs.some(
-        (output) => output.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-  }
-});
-
-// This class transforms outputs from electrum to a standard array of history.
-test("Should handle input and fee from many utxos", async () => {
-  // Build Alice's wallet from Wallet Import Format string
-  if (!process.env.PRIVATE_WIF) {
-    throw Error("Attempted to pass an empty WIF");
-  } else {
-    let alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF); // insert WIF from #1
-    const bob = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    const charlie = await createWallet({
-      type: WalletTypeEnum.Wif,
-      network: "regtest",
-    });
-    let sendResponse = await alice.send([
-      {
-        cashaddr: bob.cashaddr!,
-        value: 600n,
-      },
-      {
-        cashaddr: bob.cashaddr!,
-        value: 600n,
-      },
-      {
-        cashaddr: bob.cashaddr!,
-        value: 600n,
-      },
-      {
-        cashaddr: bob.cashaddr!,
-        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(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 bob.getHistory({
-      unit: "sat",
-    });
-
-    expect(bobHistory[0].valueChange).toBeLessThan(-1700);
-    expect(
-      bobHistory[0].outputs.some(
-        (output) => output.address === charlie.getDepositAddress()
-      )
-    ).toBe(true);
-    expect(
-      bobHistory[1].inputs.some(
-        (input) => input.address === alice.getDepositAddress()
-      )
-    ).toBe(true);
-  }
-});

package/src/history/getHistory.ts

@@ -1,411 +0,0 @@
-import {
-  binToHex,
-  decodeTransaction,
-  hexToBin,
-  lockingBytecodeToCashAddress,
-  CashAddressNetworkPrefix,
-  decodeCashAddress,
-  TransactionCommon,
-  assertSuccess,
-  Opcodes,
-} from "@bitauth/libauth";
-import { UnitEnum } from "../enum.js";
-import NetworkProvider from "../network/NetworkProvider.js";
-import { TxI } from "../interface.js";
-import { TransactionHistoryItem, InOutput } from "./interface.js";
-import { ExchangeRate } from "../rate/ExchangeRate.js";
-import { sanitizeUnit } from "../util/sanitizeUnit.js";
-import { bchParam } from "../chain.js";
-
-type Transaction = TransactionCommon & {
-  size: number;
-  blockHeight: number;
-  timestamp?: number;
-  hash: string;
-};
-
-export const getHistory = async ({
-  addresses,
-  provider,
-  unit = "sat",
-  fromHeight = 0,
-  toHeight = -1,
-  start = 0,
-  count = -1,
-  rawHistory,
-}: {
-  addresses: string[];
-  provider: NetworkProvider;
-  unit?: UnitEnum;
-  fromHeight?: number;
-  toHeight?: number;
-  start?: number;
-  count?: number;
-  rawHistory?: TxI[];
-}): Promise<TransactionHistoryItem[]> => {
-  if (!addresses.length) {
-    return [];
-  }
-
-  if (count === -1) {
-    count = 1e10;
-  }
-
-  let history: TxI[];
-  if (rawHistory) {
-    history = rawHistory.slice(start, start + count);
-  } else {
-    const allHistory = (
-      await Promise.all(
-        addresses.map(async (address) =>
-          provider.getHistory(address, fromHeight, toHeight)
-        )
-      )
-    ).flat();
-
-    // Dedup using Set instead of O(N²) findIndex
-    const seen = new Set<string>();
-    const deduped: TxI[] = [];
-    for (const item of allHistory) {
-      if (!seen.has(item.tx_hash)) {
-        seen.add(item.tx_hash);
-        deduped.push(item);
-      }
-    }
-
-    history = deduped
-      .sort((a, b) =>
-        a.height <= 0 || b.height <= 0
-          ? a.height - b.height
-          : b.height - a.height
-      )
-      .slice(start, start + count);
-  }
-
-  // Collect unique heights for header fetch
-  const uniqueHeightsSet = new Set<number>();
-  for (const tx of history) {
-    if (tx.height > 0) uniqueHeightsSet.add(tx.height);
-  }
-  const uniqueHeights = [...uniqueHeightsSet];
-
-  // Batch fetch headers and history transactions in parallel
-  const historyHashes = history.map((tx) => tx.tx_hash);
-  const [headerMap, txHexMap] = await Promise.all([
-    uniqueHeights.length > 0 ? provider.getHeaders(uniqueHeights) : new Map(),
-    provider.getRawTransactions(historyHashes),
-  ] as const);
-
-  const timestampMap: Record<number, number> = {};
-  for (const [height, header] of headerMap) {
-    timestampMap[height] = header.timestamp;
-  }
-
-  // Precompute binToHex for each input's outpoint hash once
-  const inputOutpointHashes = new WeakMap<Uint8Array, string>();
-  const getOutpointHash = (bytes: Uint8Array): string => {
-    let hash = inputOutpointHashes.get(bytes);
-    if (hash === undefined) {
-      hash = binToHex(bytes);
-      inputOutpointHashes.set(bytes, hash);
-    }
-    return hash;
-  };
-
-  const historicTransactions = history.map((tx) => {
-    const txHex = txHexMap.get(tx.tx_hash)!;
-    const transactionCommon = decodeTransaction(hexToBin(txHex));
-    if (typeof transactionCommon === "string") {
-      throw transactionCommon;
-    }
-
-    const transaction = transactionCommon as Transaction;
-    transaction.blockHeight = tx.height;
-    transaction.timestamp = timestampMap[tx.height];
-    transaction.hash = tx.tx_hash;
-    transaction.size = txHex.length / 2;
-
-    return transaction;
-  });
-
-  // Collect unique prevout hashes using Set, excluding already-fetched txs
-  const ZERO_HASH =
-    "0000000000000000000000000000000000000000000000000000000000000000";
-  const prevoutHashSet = new Set<string>();
-  for (const tx of historicTransactions) {
-    for (const input of tx.inputs) {
-      const hash = getOutpointHash(input.outpointTransactionHash);
-      if (hash !== ZERO_HASH && !txHexMap.has(hash)) {
-        prevoutHashSet.add(hash);
-      }
-    }
-  }
-
-  // Batch fetch prevout transactions
-  const prevoutHashes = [...prevoutHashSet];
-  const prevoutHexMap = await provider.getRawTransactions(prevoutHashes);
-
-  // Build prevout transaction map (decode all prevout txs)
-  const prevoutTransactionMap: Record<string, TransactionCommon> = {};
-  const allPrevoutSources = new Map([...txHexMap, ...prevoutHexMap]);
-  for (const tx of historicTransactions) {
-    for (const input of tx.inputs) {
-      const hash = getOutpointHash(input.outpointTransactionHash);
-      if (hash === ZERO_HASH || prevoutTransactionMap[hash]) continue;
-
-      const hex = allPrevoutSources.get(hash);
-      if (!hex) continue;
-
-      const decoded = decodeTransaction(hexToBin(hex));
-      if (typeof decoded === "string") {
-        throw decoded;
-      }
-      prevoutTransactionMap[hash] = decoded;
-    }
-  }
-
-  const decoded = assertSuccess(decodeCashAddress(addresses[0]));
-  const prefix = decoded.prefix as CashAddressNetworkPrefix;
-
-  const addressCache: Record<any, string> = {};
-  const addressSet = new Set(addresses);
-
-  // map decoded transaction data to TransactionHistoryItem
-  const historyItems = historicTransactions.map((tx) => {
-    const result = {} as TransactionHistoryItem;
-
-    let inputTotalValue = 0n;
-    let outputTotalValue = 0n;
-
-    const isCoinbase =
-      tx.inputs.length === 1 &&
-      tx.inputs[0].outpointTransactionHash.every((b) => b === 0);
-
-    result.inputs = tx.inputs.map((input): InOutput => {
-      if (isCoinbase) {
-        const halvings = Math.floor(tx.blockHeight / 210000);
-        const subsidy = Math.floor(5000000000 / 2 ** halvings);
-        inputTotalValue += BigInt(subsidy);
-
-        return {
-          address: "coinbase",
-          value: subsidy,
-        };
-      }
-
-      const prevoutTx =
-        prevoutTransactionMap[getOutpointHash(input.outpointTransactionHash)];
-      if (!prevoutTx) {
-        throw new Error("Could not find prevout transaction");
-      }
-
-      const prevoutOutput = prevoutTx.outputs[input.outpointIndex];
-      if (!prevoutOutput) {
-        throw new Error("Could not find prevout output");
-      }
-
-      const cached = addressCache[prevoutOutput.lockingBytecode as any];
-      let address: string;
-      if (!cached) {
-        address = assertSuccess(
-          lockingBytecodeToCashAddress({
-            bytecode: prevoutOutput.lockingBytecode,
-            prefix: prefix,
-          })
-        ).address;
-        addressCache[prevoutOutput.lockingBytecode as any] = address;
-      } else {
-        address = cached;
-      }
-
-      inputTotalValue += prevoutOutput.valueSatoshis;
-
-      return {
-        address: address,
-        value: Number(prevoutOutput.valueSatoshis),
-        token: prevoutOutput.token
-          ? {
-              category: binToHex(prevoutOutput.token.category),
-              amount: prevoutOutput.token.amount,
-              nft: prevoutOutput.token.nft
-                ? {
-                    capability: prevoutOutput.token.nft.capability,
-                    commitment: binToHex(prevoutOutput.token.nft.commitment),
-                  }
-                : undefined,
-            }
-          : undefined,
-      };
-    });
-
-    result.outputs = tx.outputs.map((output): InOutput => {
-      const cached = addressCache[output.lockingBytecode as any];
-      let address: string;
-      if (!cached) {
-        if (output.lockingBytecode[0] === Opcodes.OP_RETURN) {
-          address = `OP_RETURN: ${binToHex(output.lockingBytecode)}`;
-        } else {
-          address = assertSuccess(
-            lockingBytecodeToCashAddress({
-              bytecode: output.lockingBytecode,
-              prefix: prefix,
-            })
-          ).address;
-          addressCache[output.lockingBytecode as any] = address;
-        }
-      } else {
-        address = cached;
-      }
-
-      outputTotalValue += output.valueSatoshis;
-
-      return {
-        address: address,
-        value: Number(output.valueSatoshis),
-        token: output.token
-          ? {
-              category: binToHex(output.token.category),
-              amount: output.token.amount,
-              nft: output.token.nft
-                ? {
-                    capability: output.token.nft.capability,
-                    commitment: binToHex(output.token.nft.commitment),
-                  }
-                : undefined,
-            }
-          : undefined,
-      };
-    });
-
-    result.blockHeight = tx.blockHeight;
-    result.timestamp = tx.timestamp;
-    result.hash = tx.hash;
-    result.size = tx.size;
-    result.fee = Number(inputTotalValue - outputTotalValue);
-
-    if (isCoinbase && result.fee) {
-      // will indicate the fees collected by the miner
-      result.fee = -result.fee;
-    }
-
-    return result;
-  });
-
-  // compute value changes using Set for O(1) address lookup
-  historyItems.forEach((tx) => {
-    let satoshiBalance = 0;
-    const ftTokenBalances: Record<string, bigint> = {};
-    const nftTokenBalances: Record<string, bigint> = {};
-
-    tx.inputs.forEach((input) => {
-      if (addressSet.has(input.address)) {
-        satoshiBalance -= input.value;
-
-        if (input.token?.amount) {
-          ftTokenBalances[input.token.category] =
-            (ftTokenBalances[input.token.category] || BigInt(0)) -
-            input.token.amount;
-        }
-
-        if (input.token?.nft?.capability) {
-          nftTokenBalances[input.token.category] =
-            (nftTokenBalances[input.token.category] || BigInt(0)) - 1n;
-        }
-      }
-    });
-    tx.outputs.forEach((output) => {
-      if (addressSet.has(output.address)) {
-        satoshiBalance += Number(output.value);
-
-        if (output.token?.amount) {
-          ftTokenBalances[output.token.category] =
-            (ftTokenBalances[output.token.category] || BigInt(0)) +
-            output.token.amount;
-        }
-
-        if (output.token?.nft?.capability) {
-          nftTokenBalances[output.token.category] =
-            (nftTokenBalances[output.token.category] || BigInt(0)) + 1n;
-        }
-      }
-    });
-
-    tx.valueChange = satoshiBalance;
-    tx.tokenAmountChanges = Object.entries(ftTokenBalances).map(
-      ([category, amount]) => ({
-        category,
-        amount,
-        nftAmount: BigInt(0),
-      })
-    );
-
-    for (const [category, nftAmount] of Object.entries(nftTokenBalances)) {
-      const tokenChange = tx.tokenAmountChanges.find(
-        (tokenChange) => tokenChange.category === category
-      );
-      if (tokenChange) {
-        tokenChange.nftAmount = nftAmount;
-      } else {
-        tx.tokenAmountChanges.push({
-          category: category,
-          amount: BigInt(0),
-          nftAmount,
-        });
-      }
-    }
-  });
-
-  // order transactions in a way such that receives are always ordered before sends, per block
-  historyItems.sort(
-    (a, b) =>
-      (a.blockHeight <= 0 || b.blockHeight <= 0
-        ? a.blockHeight - b.blockHeight
-        : b.blockHeight - a.blockHeight) || a.valueChange - b.valueChange
-  );
-
-  // backfill the balances
-  let prevBalance = (
-    await Promise.all(addresses.map((address) => provider.getBalance(address)))
-  ).reduce((a, b) => Number(a) + Number(b), 0);
-
-  let prevValueChange = 0;
-  historyItems.forEach((tx) => {
-    tx.balance = prevBalance - prevValueChange;
-    prevBalance = tx.balance;
-    prevValueChange = tx.valueChange;
-  });
-
-  // convert units if needed — fetch exchange rate once
-  if (!(unit as string).includes("sat")) {
-    const sanitizedUnit = sanitizeUnit(unit);
-    let rate: number = 0;
-    if (sanitizedUnit !== UnitEnum.BCH && sanitizedUnit !== UnitEnum.SAT) {
-      rate = await ExchangeRate.get(unit);
-    }
-
-    const subUnits = Number(bchParam.subUnits);
-    const convertSatToUnit = (satValue: number): number => {
-      if (sanitizedUnit === UnitEnum.BCH) {
-        return satValue / subUnits;
-      }
-      // currency conversion matching satoshiToAmount behavior
-      const currencyValue = Number((satValue * (rate / subUnits)).toFixed(2));
-      return currencyValue;
-    };
-
-    for (const tx of historyItems) {
-      for (const input of tx.inputs) {
-        input.value = convertSatToUnit(input.value);
-      }
-
-      for (const output of tx.outputs) {
-        output.value = convertSatToUnit(output.value);
-      }
-
-      tx.valueChange = convertSatToUnit(tx.valueChange);
-      tx.balance = convertSatToUnit(tx.balance);
-    }
-  }
-
-  return historyItems;
-};