mainnet-js 0.5.7 → 0.5.9

package/src/Wallet.test.ts

@@ -422,8 +422,76 @@ describe(`Test Wallet library`, () => {
     const sendMaxResponse = await bob.sendMax(alice.cashaddr);
     expect(sendMaxResponse.txId!.length).toBe(64);
 
-    // Assume fulcrum node polling is 1s
+    //
     const bobBalanceFinal = (await bob.getBalance()) as BalanceResponse;
     expect(bobBalanceFinal.sat).toBe(0);
   });
+
+  test("Send all coins back on regtest", async () => {
+    // Build Alice's wallet from Wallet Import Format string, send some sats
+
+    const alice = await RegTestWallet.fromWIF(process.env.PRIVATE_WIF!);
+    const bob = await createWallet({
+      type: WalletTypeEnum.Seed,
+      network: "regtest",
+      name: "Bob's random wallet",
+    });
+
+    const charlie = await createWallet({
+      type: WalletTypeEnum.Seed,
+      network: "regtest",
+      name: "Charlie's random wallet",
+    });
+    if (!alice.cashaddr || !bob.cashaddr) {
+      throw Error("Alice or Bob's wallet are missing addresses");
+    }
+    if (!alice.privateKey || !bob.privateKey) {
+      throw Error("Alice or Bob's wallet are missing private keys");
+    }
+
+    // Assume fulcrum node polling is 1s
+    await alice.send([
+      {
+        cashaddr: bob.cashaddr,
+        value: 3400,
+        unit: UnitEnum.SAT,
+      },
+      {
+        cashaddr: bob.cashaddr,
+        value: 3400,
+        unit: UnitEnum.SAT,
+      },
+      {
+        cashaddr: bob.cashaddr,
+        value: 3400,
+        unit: UnitEnum.SAT,
+      },
+      {
+        cashaddr: bob.cashaddr,
+        value: 3400,
+        unit: UnitEnum.SAT,
+      },
+      {
+        cashaddr: bob.cashaddr,
+        value: 3400,
+        unit: UnitEnum.SAT,
+      },
+    ]);
+
+    // Send ALL of Bob's coins to Charlie.
+    const sendMaxResponse = await bob.sendMax(charlie.cashaddr!);
+    expect(sendMaxResponse.txId!.length).toBe(64);
+    expect(sendMaxResponse.balance!.sat!).toBe(0);
+
+    const bobFinalBalance = await bob.getBalance("sat");
+    expect(bobFinalBalance).toBe(0);
+
+    // Send ALL of Charlie's coins to Alice.
+    const sendMaxResponse2 = await charlie.sendMax(alice.cashaddr);
+    expect(sendMaxResponse2.txId!.length).toBe(64);
+    expect(sendMaxResponse2.balance!.sat!).toBe(0);
+
+    const charlieFinalBalance = await charlie.getBalance("sat");
+    expect(charlieFinalBalance).toBe(0);
+  });
 });

package/src/history/electrumTransformer.test.ts

@@ -0,0 +1,251 @@
+import { RegTestWallet } from "../wallet/Wif";
+import { WalletTypeEnum } from "../wallet/enum";
+import { createWallet } from "../wallet/createWallet";
+import { getAddressHistory } from "./electrumTransformer";
+import { mine } from "../mine";
+
+// 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: 31000,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: charlie.cashaddr!,
+        value: 41000,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
+    await bob.send([
+      {
+        cashaddr: charlie.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
+    await bob.send([
+      {
+        cashaddr: alice.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+    ]);
+    expect(sendResponse!.txId!.length).toBe(64);
+    expect(sendResponse.balance!.bch).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(
+      bob.getDepositAddress(),
+      bob.provider
+    );
+    expect(bobHistory.transactions[0].value).toBe(-2100);
+    expect(bobHistory.transactions[0].to).toBe(alice.getDepositAddress());
+    expect(bobHistory.transactions[0].from).toBe(bob.getDepositAddress());
+    expect(bobHistory.transactions[1].value).toBe(-2100);
+    expect(bobHistory.transactions[1].from).toBe(bob.getDepositAddress());
+    expect(bobHistory.transactions[1].to).toBe(charlie.getDepositAddress());
+    expect(bobHistory.transactions[2].value).toBe(31000);
+    expect(bobHistory.transactions[2].balance).toBe(31000);
+    expect(bobHistory.transactions[2].fee).toBe(0);
+    expect(bobHistory.transactions[2].from).toBe(alice.getDepositAddress());
+  }
+});
+
+// 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: 31000,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
+    await bob.send([
+      {
+        cashaddr: charlie.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: alice.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
+    expect(sendResponse!.txId!.length).toBe(64);
+    expect(sendResponse.balance!.bch).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(
+      bob.getDepositAddress(),
+      bob.provider
+    );
+    expect(bobHistory.transactions[1].txn).toBe(bobHistory.transactions[0].txn);
+    expect(bobHistory.transactions[1].fee).toBe(bobHistory.transactions[0].fee);
+    expect(bobHistory.transactions[1].fee).toBeGreaterThan(120);
+    expect(bobHistory.transactions[1].fee).toBeLessThan(150);
+    expect(bobHistory.transactions[0].value).toBe(-2100);
+    expect(bobHistory.transactions[0].to).toBe(alice.getDepositAddress());
+    expect(bobHistory.transactions[0].from).toBe(bob.getDepositAddress());
+    expect(bobHistory.transactions[1].value).toBe(-2100);
+    expect(bobHistory.transactions[1].to).toBe(charlie.getDepositAddress());
+    expect(bobHistory.transactions[1].from).toBe(bob.getDepositAddress());
+
+    expect(bobHistory.transactions[2].value).toBe(31000);
+    expect(bobHistory.transactions[2].fee).toBe(0);
+    expect(bobHistory.transactions[2].from).toBe(alice.getDepositAddress());
+  }
+});
+
+// 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: 31000,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
+    await bob.send([
+      {
+        cashaddr: charlie.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: alice.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: alice.cashaddr!,
+        value: 2100,
+        unit: "satoshis",
+      },
+    ]);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 1 });
+    expect(sendResponse!.txId!.length).toBe(64);
+    expect(sendResponse.balance!.bch).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(
+      bob.getDepositAddress(),
+      bob.provider,
+      "sat",
+      0,
+      2
+    );
+    expect(bobHistory.transactions.length).toBe(4);
+
+    expect(bobHistory.transactions[0].value).toBe(-2100);
+    expect(bobHistory.transactions[0].to).toBe(alice.getDepositAddress());
+    expect(bobHistory.transactions[1].value).toBe(-2100);
+    expect(bobHistory.transactions[1].to).toBe(alice.getDepositAddress());
+  }
+});
+
+// This class transforms outputs from electrum to a standard array of history.
+test("Should handel 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: 600,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: bob.cashaddr!,
+        value: 600,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: bob.cashaddr!,
+        value: 600,
+        unit: "satoshis",
+      },
+      {
+        cashaddr: bob.cashaddr!,
+        value: 600,
+        unit: "satoshis",
+      },
+    ]);
+    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);
+    await mine({ cashaddr: alice.getDepositAddress(), blocks: 10 });
+
+    // Build Bob's wallet from a public address, check his balance.
+    const bobHistory = await getAddressHistory(
+      bob.getDepositAddress(),
+      bob.provider,
+      "sat"
+    );
+
+    expect(bobHistory.transactions[0].value).toBeLessThan(-1700);
+    expect(bobHistory.transactions[0].to).toBe(charlie.getDepositAddress());
+    expect(bobHistory.transactions[1].from).toBe(alice.getDepositAddress());
+  }
+});

package/src/history/electrumTransformer.ts

@@ -0,0 +1,320 @@
+import {
+  binToHex,
+  cashAddressToLockingBytecode,
+  decodeTransaction,
+  hexToBin,
+  binToBigIntUint64LE,
+  Transaction,
+  lockingBytecodeToCashAddress,
+  Output,
+} from "@bitauth/libauth";
+import { UnitEnum } from "../enum";
+import NetworkProvider from "../network/NetworkProvider";
+import { derivePrefix } from "../util/derivePublicKeyHash";
+import { convert } from "../util/convert";
+import { bchParam } from "../chain";
+import { floor } from "../util/floor";
+import { TransactionHistoryI, TransactionHistoryItemI } from "./interface";
+
+export async function getAddressHistory(
+  cashaddr: string,
+  provider: NetworkProvider,
+  unit = "sat",
+  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
+    );
+  });
+
+  // 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
+    ))
+  );
+  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
+  );
+
+  let r: TransactionHistoryItemI[] = [];
+
+  let txIds: string[] = [];
+
+  for (let input of transaction.inputs) {
+    let outpoint = inputUtxos[transaction.inputs.indexOf(input)];
+
+    // 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
+        ) as string;
+
+        // 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(binToBigIntUint64LE(output.satoshis)),
+              fee: 0,
+            });
+          }
+        } 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(binToBigIntUint64LE(output.satoshis)),
+              fee: fee,
+            });
+            txIds.push(`${hash}:i:${idx}`);
+          }
+        }
+      }
+    }
+  }
+
+  // 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;
+
+        // 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(binToBigIntUint64LE(output.satoshis)),
+          });
+        }
+      } 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(binToBigIntUint64LE(output.satoshis)),
+          // incoming transactions pay no fee.
+          fee: 0,
+        });
+      }
+    }
+  }
+
+  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(binToBigIntUint64LE(outpoint.satoshis));
+    }
+  }
+
+  const outValues = utxos
+    .map((utxo) => Number(binToBigIntUint64LE(utxo.satoshis)))
+    .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);
+    }
+
+    // note the unit
+    txn.unit = unit as UnitEnum;
+
+    r.push(txn);
+  }
+  return r;
+}

package/src/history/interface.ts

@@ -0,0 +1,18 @@
+import { UnitEnum } from "../enum";
+
+export interface TransactionHistoryItemI {
+  to: string;
+  from: string;
+  unit: UnitEnum;
+  index: number;
+  blockheight: number;
+  txn: string;
+  txId: string;
+  value: number;
+  fee?: number;
+  balance?: number;
+}
+
+export interface TransactionHistoryI {
+  transactions: TransactionHistoryItemI[];
+}

package/src/wallet/Wif.ts

@@ -104,6 +104,9 @@ import { amountInSatoshi } from "../util/amountInSatoshi";
 import { getXPubKey } from "../util/getXPubKey";
 import { DERIVATION_PATHS, DUST_UTXO_THRESHOLD } from "../constant";
 
+import { TransactionHistoryI } from "../history/interface";
+import { getAddressHistory } from "../history/electrumTransformer";
+
 //#endregion Imports
 
 const secp256k1Promise = instantiateSecp256k1();
@@ -1065,15 +1068,32 @@ export class Wallet extends BaseWallet {
   }
 
   // gets transaction history of this wallet
-  public async getHistory(): Promise<TxI[]> {
+  public async getRawHistory(): Promise<TxI[]> {
     return await this.provider!.getHistory(this.cashaddr!);
   }
 
+  // gets transaction history of this wallet
+  public async getHistory(
+    unit: UnitEnum,
+    start?: number,
+    count?: number,
+    collapseChange?: boolean
+  ): Promise<TransactionHistoryI> {
+    return getAddressHistory(
+      this.cashaddr!,
+      this.provider!,
+      unit,
+      start,
+      count,
+      collapseChange
+    );
+  }
+
   // gets last transaction of this wallet
   public async getLastTransaction(
     confirmedOnly: boolean = false
   ): Promise<ElectrumRawTransaction | null> {
-    let history: TxI[] = await this.getHistory();
+    let history: TxI[] = await this.getRawHistory();
     if (confirmedOnly) {
       history = history.filter((val) => val.height > 0);
     }