mainnet-js 0.5.9 → 1.0.0-rc.1

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,
@@ -146,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,
             });
           }
@@ -165,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}`);
@@ -203,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 {
@@ -220,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,
         });
@@ -256,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 () => {

package/src/network/configuration.ts

@@ -1,31 +1,48 @@
-import { getRuntimePlatform } from "../util/index";
-import * as primary from "./constant";
+import { Network } from "../interface.js";
+import { getRuntimePlatform } from "../util/index.js";
+import * as primary from "./constant.js";
 
 let mainnetServers: string[],
   testnetServers: string[],
   regtestServers: string[];
 
-export function getDefaultServers() {
+export class DefaultProvider {
+  static servers: { [name: string]: string[] } = {
+    mainnet: [] as string[],
+    testnet: [] as string[],
+    regtest: [] as string[],
+  };
+}
+
+export function getDefaultServers(network: Network) {
+  let env: any;
   if (getRuntimePlatform() == "node") {
-    mainnetServers = process.env.ELECTRUM
-      ? process.env.ELECTRUM.split(",")
-      : primary.mainnetServers;
-    testnetServers = process.env.ELECTRUM_TESTNET
-      ? process.env.ELECTRUM_TESTNET.split(",")
-      : primary.testnetServers;
-    regtestServers = process.env.ELECTRUM_REGTEST
-      ? process.env.ELECTRUM_REGTEST.split(",")
-      : primary.regtestServers;
+    env = process.env;
   } else {
-    mainnetServers = primary.mainnetServers;
-    testnetServers = primary.testnetServers;
-    regtestServers = primary.regtestServers;
+    env = {};
   }
+
+  mainnetServers = DefaultProvider.servers.mainnet.length
+    ? DefaultProvider.servers.mainnet
+    : env.ELECTRUM
+    ? env.ELECTRUM.split(",")
+    : primary.mainnetServers;
+  testnetServers = DefaultProvider.servers.testnet.length
+    ? DefaultProvider.servers.testnet
+    : env.ELECTRUM_TESTNET
+    ? env.ELECTRUM_TESTNET.split(",")
+    : primary.testnetServers;
+  regtestServers = DefaultProvider.servers.regtest.length
+    ? DefaultProvider.servers.regtest
+    : env.ELECTRUM_REGTEST
+    ? env.ELECTRUM_REGTEST.split(",")
+    : primary.regtestServers;
+
   return {
     mainnet: mainnetServers,
     testnet: testnetServers,
     regtest: regtestServers,
-  };
+  }[network];
 }
 
 export function getUserAgent() {
@@ -53,5 +70,3 @@ export function getConfidence() {
   }
   return confidence;
 }
-
-export const defaultServers = getDefaultServers();

package/src/network/constant.ts

@@ -12,13 +12,13 @@ export const mainnetServers = [
   "wss://bch.imaginary.cash:50004",
   //"wss://blackie.c3-soft.com:50004",
   "wss://electrum.imaginary.cash:50004",
-  "wss://fulcrum.fountainhead.cash",
+  // "wss://fulcrum.fountainhead.cash",
 ];
 
 export const testnetServers = [
-  "wss://tbch.loping.net:60004",
-  //"wss://blackie.c3-soft.com:60004",
-  //"wss://testnet.bitcoincash.network:60004",
+  // "wss://tbch.loping.net:60004",
+  "wss://blackie.c3-soft.com:60004",
+  // "wss://testnet.bitcoincash.network:60004",
   //,"wss://unavailable.invalid:50004"
 ];
 
@@ -29,6 +29,11 @@ export const testnetServers = [
 //   //,"wss://unavailable.invalid:50004"
 // ];
 
+// // chipnet
+// export const testnetServers = [
+//   "wss://chipnet.imaginary.cash:50004",
+// ];
+
 export const regtestServers = ["ws://127.0.0.1:60003"];
 
 export const defaultServers = {