mainnet-js 2.3.15 → 2.4.0

package/src/history/electrumTransformer.ts

@@ -1,319 +1,314 @@
 import {
   binToHex,
-  cashAddressToLockingBytecode,
   decodeTransaction,
   hexToBin,
-  Transaction,
   lockingBytecodeToCashAddress,
-  Output,
+  CashAddressNetworkPrefix,
+  decodeCashAddress,
+  TransactionCommon,
 } from "@bitauth/libauth";
 import { UnitEnum } from "../enum.js";
 import NetworkProvider from "../network/NetworkProvider.js";
-import { derivePrefix } from "../util/derivePublicKeyHash.js";
 import { convert } from "../util/convert.js";
-import { bchParam } from "../chain.js";
-import { floor } from "../util/floor.js";
-import { TransactionHistoryI, TransactionHistoryItemI } from "./interface.js";
-
-export async function getAddressHistory(
-  cashaddr: string,
-  provider: NetworkProvider,
+import { HeaderI, TokenI } from "../interface.js";
+import { TransactionHistoryItem, InOutput } from "./interface.js";
+
+type Transaction = TransactionCommon & {
+  size: number;
+  blockHeight: number;
+  timestamp?: number;
+  hash: string;
+};
+
+export const getAddressHistory = async ({
+  address,
+  provider,
   unit = "sat",
+  fromHeight = 0,
+  toHeight = -1,
   start = 0,
-  count = 25,
-  collapseChange = true
-): Promise<TransactionHistoryI> {
-  // Get an array of raw transactions as hex
-  let txnHashes = await provider.getHistory(cashaddr);
-
-  // Assume transaction hashes will be served in chronological order
-  // Slice count in from the end and count to the provided inputs
-  let len = txnHashes.length;
-  txnHashes = txnHashes.slice(len - start - count, len - start);
-
-  // get the current balance in satoshis
-  let currentBalance = await provider.getBalance(cashaddr);
-
-  // Transform the hex transactions to and array of histroy item array promises.
-  let txItemPromises = txnHashes.map((tx) => {
-    return getDetailedHistory(
-      cashaddr,
-      tx.tx_hash,
-      tx.height,
-      provider,
-      collapseChange
-    );
-  });
+  count = -1,
+}: {
+  address: string;
+  provider: NetworkProvider;
+  unit?: UnitEnum;
+  fromHeight?: number;
+  toHeight?: number;
+  start?: number;
+  count?: number;
+}): Promise<TransactionHistoryItem[]> => {
+  if (count === -1) {
+    count = 1e10;
+  }
+
+  const history = (await provider.getHistory(address, fromHeight, toHeight))
+    .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
+    .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) => [
+        height,
+        ((await provider.getHeader(height, true)) as HeaderI).timestamp,
+      ])
+    )
+  ).reduce((acc, [height, timestamp]) => ({ ...acc, [height]: timestamp }), {});
+
+  // first load all transactions
+  const historicTransactions = await Promise.all(
+    history.map(async (tx) => {
+      const txHex = (await provider.getRawTransaction(tx.tx_hash)) as string;
+
+      const transactionCommon = decodeTransaction(hexToBin(txHex));
+      if (typeof transactionCommon === "string") {
+        throw transactionCommon;
+      }
 
-  // await the history array promises
-  let items = await Promise.all(txItemPromises);
-
-  // flatten the array of responses
-  let preprocessedTxns = Array.prototype.concat.apply([], items);
-
-  // Reverse chronological order (again), so list appear as newest first.
-  preprocessedTxns = preprocessedTxns.reverse();
-
-  // Get the factor to apply the requested unit of measure
-  let factor =
-    (await convert(bchParam.subUnits, "sat", unit)) / bchParam.subUnits;
-
-  // Apply the unit factor and
-  let txns = applyBalance(preprocessedTxns, currentBalance, unit, factor);
-
-  return {
-    transactions: txns,
-  };
-}
-
-export async function getDetailedHistory(
-  cashaddr: string,
-  hash: string,
-  height: number,
-  provider: NetworkProvider,
-  collapseChange: boolean
-): Promise<TransactionHistoryItemI[]> {
-  let transactionHex = await provider.getRawTransaction(hash);
-
-  collapseChange;
-  let addressBytecode = cashAddressToLockingBytecode(cashaddr);
-  if (typeof addressBytecode === "string") throw Error(addressBytecode);
-
-  let transaction = decodeTransaction(hexToBin(transactionHex));
-  if (typeof transaction === "string") throw Error(transaction);
-
-  let r: TransactionHistoryItemI[] = [];
-  r.push(
-    ...(await getMatchingInputs(
-      transaction,
-      cashaddr,
-      height,
-      hash,
-      provider,
-      collapseChange
-    ))
+      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;
+    })
   );
-  return r;
-}
-
-async function getMatchingInputs(
-  transaction: Transaction,
-  cashaddr: string,
-  height: number,
-  hash: string,
-  provider,
-  collapseChange
-) {
-  let addressBytecode = cashAddressToLockingBytecode(cashaddr);
-  if (typeof addressBytecode === "string") throw Error(addressBytecode);
-  let lockingBytecodeHex = binToHex(addressBytecode.bytecode);
-  let prefix = derivePrefix(cashaddr);
-
-  let inputUtxos = await getInputTransactions(transaction, provider);
-
-  let fee = getFee(
-    inputUtxos,
-    transaction.outputs,
-    lockingBytecodeHex,
-    collapseChange
+
+  // then load their prevout transactions
+  const prevoutTransactionHashes = historicTransactions
+    .map((tx) =>
+      tx.inputs.map((input) => binToHex(input.outpointTransactionHash))
+    )
+    .flat()
+    .filter((value, index, array) => array.indexOf(value) === index);
+  const prevoutTransactionMap = (
+    await Promise.all(
+      prevoutTransactionHashes.map(async (hash) => {
+        const txHex = (await provider.getRawTransaction(hash)) as string;
+
+        const transaction = decodeTransaction(hexToBin(txHex));
+        if (typeof transaction === "string") {
+          throw transaction;
+        }
+
+        return [hash, transaction];
+      })
+    )
+  ).reduce(
+    (acc, [hash, transaction]) => ({
+      ...acc,
+      [hash as string]: transaction as TransactionCommon,
+    }),
+    {} as { [hash: string]: TransactionCommon }
   );
 
-  let r: TransactionHistoryItemI[] = [];
+  const decoded = decodeCashAddress(address);
+  if (typeof decoded === "string") {
+    throw decoded;
+  }
 
-  let txIds: string[] = [];
+  const addressCache: Record<any, string> = {};
 
-  for (let input of transaction.inputs) {
-    let outpoint = inputUtxos[transaction.inputs.indexOf(input)];
+  // map decoded transaction data to TransactionHistoryItem
+  const historyItems = historicTransactions.map((tx) => {
+    const result = {} as TransactionHistoryItem;
 
-    // if the utxo of the input matches the address in question
-    if (binToHex(outpoint.lockingBytecode) === lockingBytecodeHex) {
-      for (let output of transaction.outputs) {
-        let idx = transaction.outputs.indexOf(output);
-        let from = lockingBytecodeToCashAddress(
-          outpoint.lockingBytecode,
-          prefix
+    let inputTotalValue = 0n;
+    let outputTotalValue = 0n;
+
+    result.inputs = tx.inputs.map((input) => {
+      const prevoutTx =
+        prevoutTransactionMap[binToHex(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 = lockingBytecodeToCashAddress(
+          prevoutOutput.lockingBytecode,
+          decoded.prefix as CashAddressNetworkPrefix
         ) as string;
+        addressCache[prevoutOutput.lockingBytecode as any] = address;
+      } else {
+        address = cached;
+      }
 
-        // the output was change
-        if (binToHex(output.lockingBytecode) === lockingBytecodeHex) {
-          if (!collapseChange) {
-            r.push({
-              from: from,
-              to: cashaddr,
-              unit: "sat",
-              index: idx,
-              blockheight: height,
-              txn: `${hash}`,
-              txId: `${hash}:i:${idx}`,
-              value: -Number(output.valueSatoshis),
-              fee: 0,
-            });
-          }
+      inputTotalValue += prevoutOutput.valueSatoshis;
+
+      return {
+        address: address,
+        value: Number(prevoutOutput.valueSatoshis),
+        token: prevoutOutput.token
+          ? {
+              tokenId: binToHex(prevoutOutput.token.category),
+              amount: prevoutOutput.token.amount,
+              capability: prevoutOutput.token.nft?.capability
+                ? prevoutOutput.token.nft.capability
+                : undefined,
+              commitment: prevoutOutput.token.nft?.capability
+                ? binToHex(prevoutOutput.token.nft.commitment)
+                : undefined,
+            }
+          : undefined,
+      } as InOutput;
+    });
+
+    result.outputs = tx.outputs.map((output) => {
+      const cached = addressCache[output.lockingBytecode as any];
+      let address: string;
+      if (!cached) {
+        if (output.valueSatoshis === 0n) {
+          address = `OP_RETURN: ${binToHex(output.lockingBytecode)}`;
         } else {
-          if (!txIds.find((str) => str === `${hash}:i:${idx}`)) {
-            // the utxo was sent to another address
-            let to = lockingBytecodeToCashAddress(
-              output.lockingBytecode,
-              prefix
-            ) as string;
-            r.push({
-              from: from,
-              to: to,
-              unit: "sat",
-              index: idx,
-              blockheight: height,
-              txn: `${hash}`,
-              txId: `${hash}:i:${idx}`,
-              value: -Number(output.valueSatoshis),
-              fee: fee,
-            });
-            txIds.push(`${hash}:i:${idx}`);
-          }
+          address = lockingBytecodeToCashAddress(
+            output.lockingBytecode,
+            decoded.prefix as CashAddressNetworkPrefix
+          ) as string;
+          addressCache[output.lockingBytecode as any] = address;
         }
+      } else {
+        address = cached;
       }
-    }
-  }
 
-  // check the transaction outputs for receiving transactions
-  for (let output of transaction.outputs) {
-    // the output was a utxo for the address in question
-    if (binToHex(output.lockingBytecode) === lockingBytecodeHex) {
-      // the input was from a single address
-      if (transaction.inputs.length == 1) {
-        const input = transaction.inputs[0];
-        const inHash = binToHex(input.outpointTransactionHash);
-        const transactionHex = await provider.getRawTransaction(inHash);
-        const inTransaction = decodeTransaction(hexToBin(transactionHex));
-        if (typeof inTransaction === "string") throw Error(inTransaction);
-
-        let outpoint = inTransaction.outputs[input.outpointIndex];
-        let from = lockingBytecodeToCashAddress(
-          outpoint.lockingBytecode,
-          prefix
-        ) as string;
+      outputTotalValue += output.valueSatoshis;
+
+      return {
+        address: address,
+        value: Number(output.valueSatoshis),
+        token: output.token
+          ? {
+              tokenId: binToHex(output.token.category),
+              amount: output.token.amount,
+              capability: output.token.nft?.capability
+                ? output.token.nft.capability
+                : undefined,
+              commitment: output.token.nft?.capability
+                ? binToHex(output.token.nft.commitment)
+                : undefined,
+            }
+          : undefined,
+      } as InOutput;
+    });
+
+    result.blockHeight = tx.blockHeight;
+    result.timestamp = tx.timestamp;
+    result.hash = tx.hash;
+    result.size = tx.size;
+    result.fee = Number(inputTotalValue - outputTotalValue);
+
+    return result;
+  });
 
-        // if the utxo was from a different address and change is not being output...
-        if (from !== cashaddr || !collapseChange) {
-          r.push({
-            from: from,
-            to: cashaddr,
-            unit: "sat",
-            index: transaction.outputs.indexOf(output),
-            blockheight: height,
-            txn: `${hash}`,
-            txId: `${hash}:o:${transaction.outputs.indexOf(output)}`,
-            value: Number(output.valueSatoshis),
-          });
+  // compute value changes
+  historyItems.forEach((tx) => {
+    let satoshiBalance = 0;
+    const ftTokenBalances: Record<string, bigint> = {};
+    const nftTokenBalances: Record<string, bigint> = {};
+
+    tx.inputs.forEach((input) => {
+      if (input.address === address) {
+        satoshiBalance -= input.value;
+
+        if (input.token?.amount) {
+          ftTokenBalances[input.token.tokenId] =
+            (ftTokenBalances[input.token.tokenId] || BigInt(0)) -
+            input.token.amount;
+        }
+
+        if (input.token?.capability) {
+          nftTokenBalances[input.token.tokenId] =
+            (nftTokenBalances[input.token.tokenId] || BigInt(0)) - 1n;
         }
+      }
+    });
+    tx.outputs.forEach((output) => {
+      if (output.address === address) {
+        satoshiBalance += Number(output.value);
+
+        if (output.token?.amount) {
+          ftTokenBalances[output.token.tokenId] =
+            (ftTokenBalances[output.token.tokenId] || BigInt(0)) +
+            output.token.amount;
+        }
+
+        if (output.token?.capability) {
+          nftTokenBalances[output.token.tokenId] =
+            (nftTokenBalances[output.token.tokenId] || BigInt(0)) + 1n;
+        }
+      }
+    });
+
+    tx.valueChange = satoshiBalance;
+    tx.tokenAmountChanges = Object.entries(ftTokenBalances).map(
+      ([tokenId, amount]) => ({
+        tokenId,
+        amount,
+        nftAmount: BigInt(0),
+      })
+    );
+
+    for (const [tokenId, nftAmount] of Object.entries(nftTokenBalances)) {
+      const tokenChange = tx.tokenAmountChanges.find(
+        (tokenChange) => tokenChange.tokenId === tokenId
+      );
+      if (tokenChange) {
+        tokenChange.nftAmount = nftAmount;
       } else {
-        let from = transaction.inputs
-          .map(
-            (i) => `${binToHex(i.outpointTransactionHash)}:o:${i.outpointIndex}`
-          )
-          .join(";");
-        r.push({
-          from: from,
-          to: cashaddr,
-          unit: "sat",
-          index: transaction.outputs.indexOf(output),
-          blockheight: height,
-          txn: `${hash}`,
-          txId: `${hash}:o:${transaction.outputs.indexOf(output)}`,
-          value: Number(output.valueSatoshis),
-          // incoming transactions pay no fee.
-          fee: 0,
+        tx.tokenAmountChanges.push({
+          tokenId,
+          amount: BigInt(0),
+          nftAmount,
         });
       }
     }
-  }
+  });
 
-  return r;
-}
-
-async function getInputTransactions(
-  transaction: Transaction,
-  provider: NetworkProvider
-) {
-  let inputTransactions: Output[] = [];
-  for (let input of transaction.inputs) {
-    let inHash = binToHex(input.outpointTransactionHash);
-    let transactionHex = await provider.getRawTransaction(inHash);
-    let inTransaction = decodeTransaction(hexToBin(transactionHex));
-    if (typeof inTransaction === "string") throw Error(inTransaction);
-
-    inputTransactions.push(inTransaction.outputs[input.outpointIndex]);
-  }
-  return inputTransactions;
-}
-
-function getFee(
-  inputUtxos: Output[],
-  utxos: Output[],
-  lockingBytecodeHex,
-  collapseChange
-) {
-  let inValues = 0;
-  for (let outpoint of inputUtxos) {
-    if (binToHex(outpoint.lockingBytecode)) {
-      inValues += Number(outpoint.valueSatoshis);
-    }
-  }
+  // 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
+  );
 
-  const outValues = utxos
-    .map((utxo) => Number(utxo.valueSatoshis))
-    .reduce((a: number, b: number) => a + b, 0);
-
-  let fee = 0;
-  if (collapseChange) {
-    const nonChangeOutputs = utxos
-      .map((output) =>
-        binToHex(output.lockingBytecode) === lockingBytecodeHex ? 0 : 1
-      )
-      .reduce((a: number, b: number) => a + b, 0);
-    fee = floor((inValues - outValues) / nonChangeOutputs, 0);
-  } else {
-    fee = floor((inValues - outValues) / utxos.length, 0);
-  }
-  return fee;
-}
-
-function applyBalance(
-  preprocessedTxns: TransactionHistoryItemI[],
-  currentBalance: number,
-  unit: string,
-  factor: number
-): TransactionHistoryItemI[] {
-  // balance in satoshis
-  let bal = currentBalance;
-
-  let r: TransactionHistoryItemI[] = [];
-  for (let txn of preprocessedTxns) {
-    // set the balance to the current balance in the appropriate unit
-    txn.balance = bal;
-
-    // If fee is not defined, configure it to zero.
-    txn.fee = txn.fee ? txn.fee : 0;
-
-    // update the running balance in satoshis for the next record
-    // a receiving value is positive, a send is negative
-    // The sign is reversed in cronological order from the current balance.
-    bal -= txn.value;
-    bal += txn.fee;
-
-    // transform the value of the transaction
-    txn.value = txn.value * factor;
-    txn.fee = txn.fee! * factor;
-
-    // If unit is usd, round to two decimal places.
-    if (unit.toLowerCase() == "usd") {
-      txn.value = floor(txn.value, 2);
-      txn.fee = floor(txn.fee, 2);
-    }
+  // backfill the balances
+  let prevBalance = await provider.getBalance(address);
+  let prevValueChange = 0;
+  historyItems.forEach((tx) => {
+    tx.balance = prevBalance - prevValueChange;
+    prevBalance = tx.balance;
+    prevValueChange = tx.valueChange;
+  });
+
+  // convert units if needed
+  if (!(unit as string).includes("sat")) {
+    for (const tx of historyItems) {
+      for (const input of tx.inputs) {
+        input.value = await convert(input.value, "sat", unit);
+      }
 
-    // note the unit
-    txn.unit = unit as UnitEnum;
+      for (const output of tx.outputs) {
+        output.value = await convert(output.value, "sat", unit);
+      }
 
-    r.push(txn);
+      tx.valueChange = await convert(tx.valueChange, "sat", unit);
+      tx.balance = await convert(tx.balance, "sat", unit);
+    }
   }
-  return r;
-}
+
+  return historyItems;
+};

package/src/history/interface.ts

@@ -1,18 +1,24 @@
-import { UnitEnum } from "../enum.js";
+import { TokenI } from "../interface.js";
 
-export interface TransactionHistoryItemI {
-  to: string;
-  from: string;
-  unit: UnitEnum;
-  index: number;
-  blockheight: number;
-  txn: string;
-  txId: string;
+export interface InOutput {
+  address: string;
   value: number;
-  fee?: number;
-  balance?: number;
+  token?: TokenI;
 }
 
-export interface TransactionHistoryI {
-  transactions: TransactionHistoryItemI[];
+export interface TransactionHistoryItem {
+  inputs: InOutput[];
+  outputs: InOutput[];
+  blockHeight: number;
+  timestamp?: number;
+  hash: string;
+  size: number;
+  fee: number;
+  balance: number;
+  valueChange: number;
+  tokenAmountChanges: {
+    tokenId: string;
+    amount: bigint;
+    nftAmount: bigint;
+  }[];
 }

package/src/interface.ts

@@ -35,11 +35,21 @@ export interface TxI {
   fee?: number;
 }
 
-export interface HeaderI {
+export interface HexHeaderI {
   height: number;
   hex: string;
 }
 
+export interface HeaderI {
+  version: number;
+  previousBlockHash: string;
+  merkleRoot: string;
+  timestamp: number;
+  bits: number;
+  nonce: number;
+  height: number;
+}
+
 export interface TokenI {
   amount: bigint;
   tokenId: string;