mainnet-js 0.5.8 → 1.0.0-rc.1

package/src/db/StorageProvider.ts

@@ -1,4 +1,4 @@
-import { WalletI } from "./interface";
+import { WalletI } from "./interface.js";
 
 export default interface StorageProvider {
   /**

package/src/db/getStorageProvider.ts

@@ -0,0 +1,20 @@
+import { getRuntimePlatform } from "../util/getRuntimePlatform.js";
+import IndexedDBProvider from "./IndexedDBProvider.js";
+import SqlProvider from "./SqlProvider.js";
+import StorageProvider from "./StorageProvider.js";
+import { indexedDbIsAvailable } from "./util.js";
+
+export function getStorageProvider(
+  dbName: string
+): StorageProvider | undefined {
+  if (getRuntimePlatform() !== "node" && indexedDbIsAvailable()) {
+    return new IndexedDBProvider(dbName);
+  } else {
+    if ("DATABASE_URL" in process.env) {
+      return new SqlProvider(dbName);
+    } else {
+      console.warn("DATABASE_URL was not configured, storage unavailable");
+      return;
+    }
+  }
+}

package/src/db/index.ts

@@ -1,3 +1,3 @@
-export { default as IndexedDBProvider } from "./IndexedDBProvider";
-export { default as SqlProvider } from "./SqlProvider";
-export { default as StorageProvider } from "./StorageProvider";
+export { default as IndexedDBProvider } from "./IndexedDBProvider.js";
+export { default as SqlProvider } from "./SqlProvider.js";
+export { default as StorageProvider } from "./StorageProvider.js";

package/src/db/util.ts

@@ -1,23 +1,4 @@
-import { StorageProvider } from ".";
-import { getRuntimePlatform } from "../util/index";
-import { default as IndexedDBProvider } from "./IndexedDBProvider";
-import { default as SqlProvider } from "./SqlProvider";
-import { sslConfigI } from "./interface";
-
-export function getStorageProvider(
-  dbName: string
-): StorageProvider | undefined {
-  if (getRuntimePlatform() !== "node" && indexedDbIsAvailable()) {
-    return new IndexedDBProvider(dbName);
-  } else {
-    if ("DATABASE_URL" in process.env) {
-      return new SqlProvider(dbName);
-    } else {
-      console.warn("DATABASE_URL was not configured, storage unavailable");
-      return;
-    }
-  }
-}
+import { sslConfigI } from "./interface.js";
 
 export function indexedDbIsAvailable() {
   return "indexedDB" in globalThis;

package/src/history/electrumTransformer.test.ts

@@ -126,7 +126,6 @@ test("Should get a history with multi-party sends", async () => {
     expect(bobHistory.transactions[1].from).toBe(bob.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());
   }
@@ -185,7 +184,7 @@ test("Should cut results with a longer history to given count", async () => {
       0,
       2
     );
-    expect(bobHistory.transactions.length).toBe(2);
+    expect(bobHistory.transactions.length).toBe(4);
 
     expect(bobHistory.transactions[0].value).toBe(-2100);
     expect(bobHistory.transactions[0].to).toBe(alice.getDepositAddress());

package/src/history/electrumTransformer.ts

@@ -3,18 +3,17 @@ import {
   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";
+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,
@@ -27,6 +26,11 @@ export async function getAddressHistory(
   // 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);
 
@@ -47,7 +51,7 @@ export async function getAddressHistory(
   // flatten the array of responses
   let preprocessedTxns = Array.prototype.concat.apply([], items);
 
-  // Revere cronological order.
+  // Reverse chronological order (again), so list appear as newest first.
   preprocessedTxns = preprocessedTxns.reverse();
 
   // Get the factor to apply the requested unit of measure
@@ -57,9 +61,6 @@ export async function getAddressHistory(
   // Apply the unit factor and
   let txns = applyBalance(preprocessedTxns, currentBalance, unit, factor);
 
-  // Slice the start and count to the provided inputs
-  txns = txns.slice(start, start + count);
-
   return {
     transactions: txns,
   };
@@ -144,7 +145,7 @@ async function getMatchingInputs(
               blockheight: height,
               txn: `${hash}`,
               txId: `${hash}:i:${idx}`,
-              value: -Number(binToBigIntUint64LE(output.satoshis)),
+              value: -Number(output.valueSatoshis),
               fee: 0,
             });
           }
@@ -163,7 +164,7 @@ async function getMatchingInputs(
               blockheight: height,
               txn: `${hash}`,
               txId: `${hash}:i:${idx}`,
-              value: -Number(binToBigIntUint64LE(output.satoshis)),
+              value: -Number(output.valueSatoshis),
               fee: fee,
             });
             txIds.push(`${hash}:i:${idx}`);
@@ -201,7 +202,7 @@ async function getMatchingInputs(
             blockheight: height,
             txn: `${hash}`,
             txId: `${hash}:o:${transaction.outputs.indexOf(output)}`,
-            value: Number(binToBigIntUint64LE(output.satoshis)),
+            value: Number(output.valueSatoshis),
           });
         }
       } else {
@@ -218,7 +219,7 @@ async function getMatchingInputs(
           blockheight: height,
           txn: `${hash}`,
           txId: `${hash}:o:${transaction.outputs.indexOf(output)}`,
-          value: Number(binToBigIntUint64LE(output.satoshis)),
+          value: Number(output.valueSatoshis),
           // incoming transactions pay no fee.
           fee: 0,
         });
@@ -254,12 +255,12 @@ function getFee(
   let inValues = 0;
   for (let outpoint of inputUtxos) {
     if (binToHex(outpoint.lockingBytecode)) {
-      inValues += Number(binToBigIntUint64LE(outpoint.satoshis));
+      inValues += Number(outpoint.valueSatoshis);
     }
   }
 
   const outValues = utxos
-    .map((utxo) => Number(binToBigIntUint64LE(utxo.satoshis)))
+    .map((utxo) => Number(utxo.valueSatoshis))
     .reduce((a: number, b: number) => a + b, 0);
 
   let fee = 0;

package/src/history/interface.ts

@@ -1,4 +1,4 @@
-import { UnitEnum } from "../enum";
+import { UnitEnum } from "../enum.js";
 
 export interface TransactionHistoryItemI {
   to: string;

package/src/index.ts

@@ -1,43 +1,51 @@
-export * from "./db/index";
-export * from "./mine/index";
-export * from "./slp/index";
-export * from "./test/expect";
-export * from "./webhook/index";
+export * from "./db/index.js";
+export * from "./mine/index.js";
+export * from "./slp/index.js";
+export * from "./test/expect.js";
+export * from "./test/axios.js";
+export * from "./webhook/index.js";
+export * from "./wallet/Bcmr.js";
 
-export * from "./network/index";
-export { SignedMessage } from "./message/signed";
+export * from "./network/index.js";
+export { SignedMessage } from "./message/signed.js";
 
-export { BaseWallet } from "./wallet/Base";
-export * from "./wallet/Wif";
-export * from "./wallet/createWallet";
+export { BaseWallet } from "./wallet/Base.js";
+export * from "./wallet/Wif.js";
+export * from "./wallet/createWallet.js";
+
+// provider
+export { DefaultProvider } from "./network/configuration.js";
 
 // Enum
-export { NetworkType, UnitEnum } from "./enum";
-export { WalletTypeEnum } from "./wallet/enum";
+export { NetworkType, UnitEnum } from "./enum.js";
+export { WalletTypeEnum } from "./wallet/enum.js";
 
 // models
-export { SendRequest, UtxoItem } from "./wallet/model";
+export * from "./wallet/model.js";
 
 // utils
-import * as Mainnet from "./util/index";
+import * as Mainnet from "./util/index.js";
 export { Mainnet };
+export * from "./util/index.js";
+
+// qr
+export * from "./qr/Qr.js";
 
 // constants
-import * as CONST from "./constant";
+import * as CONST from "./constant.js";
 export { CONST };
 
 // interfaces
-export { UtxoI } from "./interface";
-export { Network } from "./interface";
-export { ImageI } from "./qr/interface";
+export * from "./interface.js";
+export { ImageI } from "./qr/interface.js";
 export {
   SignedMessageResponseI,
   VerifyMessageResponseI,
-} from "./message/interface";
-export { WalletRequestI, WalletResponseI } from "./wallet/interface";
+} from "./message/interface.js";
+export { WalletRequestI, WalletResponseI } from "./wallet/interface.js";
 
 // TODO move this up to util (Mainnet) ?
-export * from "./util/bchaddr";
+export * from "./util/bchaddr.js";
 
 export function cube(x: number) {
   return x * x * x;

package/src/interface.ts

@@ -21,6 +21,7 @@ export interface UtxoI {
   satoshis: number;
   height?: number;
   coinbase?: boolean;
+  token?: TokenI;
 }
 
 export interface ElectrumBalanceI {
@@ -38,3 +39,17 @@ export interface HeaderI {
   height: number;
   hex: string;
 }
+
+export interface TokenI {
+  amount: number;
+  tokenId: string;
+  capability?: NFTCapability;
+  commitment?: string;
+}
+
+export const NFTCapability = {
+  none: literal("none"),
+  mutable: literal("mutable"),
+  minting: literal("minting"),
+};
+export type NFTCapability = typeof NFTCapability[keyof typeof NFTCapability];

package/src/message/index.ts

@@ -1,2 +1,2 @@
-export * from "./interface";
-export * from "./signed";
+export * from "./interface.js";
+export * from "./signed.js";

package/src/message/signed.test.ts

@@ -1,11 +1,11 @@
-import { SignedMessage, hash_message } from "./signed";
-import { Wallet, RegTestWallet, TestNetWallet } from "../wallet/Wif";
+import { SignedMessage, hash_message } from "./signed.js";
+import { Wallet, RegTestWallet, TestNetWallet } from "../wallet/Wif.js";
 import { binToBase64, binToHex } from "@bitauth/libauth";
 
-const fs = require("fs").promises;
+import fs from "fs";
 
 async function loadLargeMessage() {
-  const data = await fs.readFile("./jest/data/bitcoin.tex", "utf-8");
+  const data = await fs.promises.readFile("./jest/data/bitcoin.tex", "utf-8");
   return data;
 }
 

package/src/message/signed.ts

@@ -1,6 +1,7 @@
 import {
   base64ToBin,
   binToBase64,
+  CashAddressType,
   encodeCashAddress,
   hexToBin,
   instantiateSecp256k1,
@@ -9,13 +10,13 @@ import {
   utf8ToBin,
 } from "@bitauth/libauth";
 
-import { derivePrefix } from "../util/derivePublicKeyHash";
-import { hash160 } from "../util/hash160";
+import { derivePrefix } from "../util/derivePublicKeyHash.js";
+import { hash160 } from "../util/hash160.js";
 import {
   SignedMessageI,
   SignedMessageResponseI,
   VerifyMessageResponseI,
-} from "./interface";
+} from "./interface.js";
 
 /**
  * message_magic - Add "Magic", per standard bitcoin message signing.
@@ -70,8 +71,17 @@ export class SignedMessage implements SignedMessageI {
       privateKey,
       messageHash
     );
-    let sigDer = secp256k1.signMessageHashDER(privateKey, messageHash);
-    let sigSchnorr = secp256k1.signMessageHashSchnorr(privateKey, messageHash);
+    if (typeof rs === "string") {
+      throw new Error(rs);
+    }
+    let sigDer = secp256k1.signMessageHashDER(
+      privateKey,
+      messageHash
+    ) as Uint8Array;
+    let sigSchnorr = secp256k1.signMessageHashSchnorr(
+      privateKey,
+      messageHash
+    ) as Uint8Array;
     let electronEncoding = new Uint8Array([
       ...[31 + rs.recoveryId],
       ...rs.signature,
@@ -127,6 +137,9 @@ export class SignedMessage implements SignedMessageI {
         recoveryId as RecoveryId,
         messageHash
       );
+      if (typeof recoveredPk === "string") {
+        throw new Error(recoveredPk);
+      }
 
       pkh = await hash160(recoveredPk);
       signatureType = "recoverable";
@@ -138,7 +151,11 @@ export class SignedMessage implements SignedMessageI {
       if (cashaddr) {
         // Validate that the signature actually matches the provided cashaddr
         let prefix = derivePrefix(cashaddr);
-        let resultingCashaddr = encodeCashAddress(prefix, 0, pkh);
+        let resultingCashaddr = encodeCashAddress(
+          prefix,
+          CashAddressType.p2pkh,
+          pkh
+        );
         if (resultingCashaddr === cashaddr) {
           pkhMatch = true;
         }

package/src/mine/index.ts

@@ -1 +1 @@
-export * from "./mine";
+export * from "./mine.js";

package/src/mine/mine.ts

@@ -1,4 +1,5 @@
-import { browserNotSupported } from "../util/browserNotSupported";
+import { browserNotSupported } from "../util/browserNotSupported.js";
+import { spawnSync } from "child_process";
 /**
  * Mine blocks to a regtest address
  *
@@ -31,8 +32,7 @@ export async function mine({
     blocks,
     cashaddr,
   ];
-  const spawnSync = eval('require("child_process")').spawnSync;
-  const cli = await spawnSync(`docker`, generateArgs);
+  const cli = spawnSync(`docker`, generateArgs as any);
   if (cli.stderr.length > 0) {
     return console.log("Mine Error: " + cli.stderr.toString());
   }

package/src/network/Connection.ts

@@ -1,13 +1,13 @@
-import { default as NetworkProvider } from "./NetworkProvider";
+import { default as NetworkProvider } from "./NetworkProvider.js";
 import {
   getNetworkProvider,
   setGlobalProvider,
   getGlobalProvider,
   removeGlobalProvider,
-} from "./default";
-import { Network } from "../interface";
-import { networkTickerMap } from "./constant";
-import { prefixFromNetworkMap } from "../enum";
+} from "./default.js";
+import { Network } from "../interface.js";
+import { networkTickerMap } from "./constant.js";
+import { prefixFromNetworkMap } from "../enum.js";
 import { CashAddressNetworkPrefix } from "@bitauth/libauth";
 
 async function initProvider(network: Network) {

package/src/network/ElectrumNetworkProvider.ts

@@ -4,17 +4,22 @@ import {
   RequestResponse,
   ConnectionStatus,
 } from "electrum-cash";
-import { default as NetworkProvider } from "./NetworkProvider";
-import { HeaderI, TxI, UtxoI, ElectrumBalanceI } from "../interface";
-import { Network } from "../interface";
-import { delay } from "../util/delay";
-import { BlockHeader, ElectrumRawTransaction, ElectrumUtxo } from "./interface";
+import { default as NetworkProvider } from "./NetworkProvider.js";
+import { HeaderI, TxI, UtxoI, ElectrumBalanceI, TokenI } from "../interface.js";
+import { Network } from "../interface.js";
+import { delay } from "../util/delay.js";
+import { ElectrumRawTransaction, ElectrumUtxo } from "./interface.js";
 
 import { Mutex } from "async-mutex";
-import { Util } from "../wallet/Util";
-import { CancelWatchFn } from "../wallet/interface";
-import { resolve } from "path";
-import { rejects } from "assert";
+import { Util } from "../wallet/Util.js";
+import { CancelWatchFn } from "../wallet/interface.js";
+import { getTransactionHash } from "../util/transaction.js";
+import {
+  binToHex,
+  decodeTransactionBCH,
+  hexToBin,
+  TransactionBCH,
+} from "@bitauth/libauth";
 
 export default class ElectrumNetworkProvider implements NetworkProvider {
   public electrum: ElectrumCluster | ElectrumClient;
@@ -49,7 +54,9 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
             await this.connectCluster();
           } catch (e) {
             console.warn(
-              `Unable to connect to one or more electrum-cash hosts: ${e}`
+              `Unable to connect to one or more electrum-cash hosts: ${JSON.stringify(
+                e
+              )}`
             );
           }
           resolve(await this.readyCluster());
@@ -69,18 +76,64 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     clearTimeout(timeoutHandle);
   }
 
+  static utxoTxCache = {};
   async getUtxos(cashaddr: string): Promise<UtxoI[]> {
     const result = (await this.performRequest(
       "blockchain.address.listunspent",
       cashaddr
     )) as ElectrumUtxo[];
+    if (this.network === Network.MAINNET) {
+      return result.map((utxo) => ({
+        txid: utxo.tx_hash,
+        vout: utxo.tx_pos,
+        satoshis: utxo.value,
+        height: utxo.height,
+      }));
+    }
+
+    // a workaround until Fulcrum returns token info
+    const uniqueTransactionHashes = result.filter(
+      (value, index, array) => array.indexOf(value) === index
+    );
+    const transactionMap: { [hash: string]: TransactionBCH } = {};
+    for (let { tx_hash } of uniqueTransactionHashes) {
+      const key = `${this.network}-${tx_hash};`;
+
+      // check cache
+      if (ElectrumNetworkProvider.utxoTxCache[key]) {
+        transactionMap[tx_hash] = ElectrumNetworkProvider.utxoTxCache[key];
+        continue;
+      }
+      // download and decode tx from Fulcrum
+      const decoded = decodeTransactionBCH(
+        hexToBin(await this.getRawTransaction(tx_hash, false))
+      );
+      if (typeof decoded === "string") {
+        throw new Error(decoded);
+      }
+      transactionMap[tx_hash] = decoded;
+      ElectrumNetworkProvider.utxoTxCache[key] = decoded;
+    }
 
-    const utxos = result.map((utxo) => ({
-      txid: utxo.tx_hash,
-      vout: utxo.tx_pos,
-      satoshis: utxo.value,
-      height: utxo.height,
-    }));
+    const utxos = result.map((utxo) => {
+      const output = transactionMap[utxo.tx_hash].outputs[utxo.tx_pos];
+      return {
+        txid: utxo.tx_hash,
+        vout: utxo.tx_pos,
+        satoshis: utxo.value,
+        height: utxo.height,
+        token:
+          output.token &&
+          ({
+            amount: Number(output.token.amount),
+            tokenId: binToHex(output.token.category),
+            capability: output.token.nft?.capability,
+            commitment:
+              output.token.nft?.commitment &&
+              binToHex(output.token.nft?.commitment),
+          } as TokenI),
+      } as UtxoI;
+    });
 
     return utxos;
   }
@@ -107,16 +160,26 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return this.blockHeight;
   }
 
+  static rawTransactionCache = {};
   async getRawTransaction(
     txHash: string,
     verbose: boolean = false
   ): Promise<string> {
+    const key = `${this.network}-${txHash}-${verbose}`;
+    if (ElectrumNetworkProvider.rawTransactionCache[key]) {
+      return ElectrumNetworkProvider.rawTransactionCache[key];
+    }
+
     try {
-      return (await this.performRequest(
+      const result = await this.performRequest(
         "blockchain.transaction.get",
         txHash,
         verbose
-      )) as string;
+      );
+
+      ElectrumNetworkProvider.rawTransactionCache[key] = result;
+
+      return result as any;
     } catch (error: any) {
       if (
         (error.message as string).indexOf(
@@ -145,7 +208,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     awaitPropagation: boolean = true
   ): Promise<string> {
     return new Promise(async (resolve, reject) => {
-      let txHash = await Util.getTransactionHash(txHex);
+      let txHash = await getTransactionHash(txHex);
       if (!awaitPropagation) {
         this.performRequest("blockchain.transaction.broadcast", txHex);
         resolve(txHash);
@@ -491,7 +554,9 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
         return await (this.electrum as ElectrumClient).connect();
       } catch (e) {
         console.warn(
-          `Warning: Failed to connect to client on ${this.network}.`
+          `Warning: Failed to connect to client on ${this.network} at ${
+            (this.electrum as ElectrumClient).connection.host
+          }.`
         );
         return;
       }

package/src/network/NetworkProvider.ts

@@ -1,4 +1,4 @@
-import { TxI, UtxoI, Network, HeaderI } from "../interface";
+import { TxI, UtxoI, Network, HeaderI } from "../interface.js";
 
 export default interface NetworkProvider {
   /**

package/src/network/configuration.test.ts

@@ -1,11 +1,33 @@
+import { Network } from "../interface";
 import * as config from "./configuration";
 import * as primary from "./constant";
 
 test("Should get electrum settings from defaults", async () => {
-  let s = config.getDefaultServers();
-  expect(s.mainnet).toBe(primary.mainnetServers);
-  expect(s.testnet).toBe(primary.testnetServers);
-  expect(s.regtest).toBe(primary.regtestServers);
+  expect(config.getDefaultServers(Network.MAINNET)).toBe(
+    primary.mainnetServers
+  );
+  expect(config.getDefaultServers(Network.TESTNET)).toBe(
+    primary.testnetServers
+  );
+  expect(config.getDefaultServers(Network.REGTEST)).toBe(
+    primary.regtestServers
+  );
+});
+
+test("Should get electrum settings from DefaultProvider", async () => {
+  config.DefaultProvider.servers.mainnet = ["wss://example.com:777"];
+
+  expect(config.getDefaultServers(Network.MAINNET)).toStrictEqual([
+    "wss://example.com:777",
+  ]);
+  expect(config.getDefaultServers(Network.TESTNET)).toBe(
+    primary.testnetServers
+  );
+  expect(config.getDefaultServers(Network.REGTEST)).toBe(
+    primary.regtestServers
+  );
+
+  config.DefaultProvider.servers.mainnet = [];
 });
 
 test("Should get electrum settings from env", async () => {
@@ -13,13 +35,16 @@ test("Should get electrum settings from env", async () => {
   process.env.ELECTRUM_TESTNET =
     "https://test.example.com:1234,https://test.example.dk:1234";
   process.env.ELECTRUM_REGTEST = "ws://reg.example.com:1234";
-  let s = config.getDefaultServers();
-  expect(s.mainnet).toStrictEqual(["https://example.com:1234"]);
-  expect(s.testnet).toStrictEqual([
+  expect(config.getDefaultServers(Network.MAINNET)).toStrictEqual([
+    "https://example.com:1234",
+  ]);
+  expect(config.getDefaultServers(Network.TESTNET)).toStrictEqual([
     "https://test.example.com:1234",
     "https://test.example.dk:1234",
   ]);
-  expect(s.regtest).toStrictEqual(["ws://reg.example.com:1234"]);
+  expect(config.getDefaultServers(Network.REGTEST)).toStrictEqual([
+    "ws://reg.example.com:1234",
+  ]);
 });
 
 test("Should get electrum cluster confidence from defaults", async () => {