mainnet-js 0.4.19 → 0.4.23

package/package.json

@@ -8,10 +8,16 @@
     "url": "https://github.com/mainnet-cash/mainnet-js/issues"
   },
   "name": "mainnet-js",
-  "version": "0.4.19",
+  "version": "0.4.23",
   "homepage": "https://mainnet.cash",
   "main": "dist/main/index.js",
   "module": "dist/module/index.js",
+  "browser": {
+    "http": false,
+    "https": false,
+    "fs": false,
+    "url": false
+  },
   "types": "dist/main/index.d.ts",
   "exports": {
     "require": "./dist/main/index.js",
@@ -41,12 +47,13 @@
     "bignumber.js": "^9.0.1",
     "bip39": "^3.0.3",
     "buffer": "^6.0.3",
+    "buffer-lite": "^1.0.0",
     "cashaddrjs": "^0.4.4",
-    "events": "^3.2.0",
-    "fake-indexeddb": "^3.1.2",
     "electrum-cash": "^2.0.8",
+    "events": "^3.2.0",
     "eventsource": "^1.0.7",
-    "qrcode-svg": "^1.1.0",
+    "fake-indexeddb": "^3.1.2",
+    "qrcode-svg": "git+https://github.com/2qx/qrcode-svg.git",
     "slp-parser": "^0.0.4"
   },
   "devDependencies": {},
@@ -66,10 +73,16 @@
   "testPathIgnorePatterns": [
     "dist"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "src/rate/ExchangeRate.ts",
+    "src/network/getRelayFeeCache.ts",
+    "src/network/default.ts",
+    "src/util/eventsource.ts"
+  ],
   "keywords": [
     "bch",
-    "bitcoin cash"
+    "bitcoin cash",
+    "wasm"
   ],
   "author": "readcash"
 }

package/src/Wallet.test.headless.js

@@ -298,17 +298,17 @@ describe(`Wallet should function in the browser`, () => {
         waitBalanceResult = true;
       }, 0);
 
-      let aliceWatchResult = false;
-      const aliceWatchCancel = alice.watchAddressTransactions((_tx) => {
-        aliceWatchCancel();
-        aliceWatchResult = true;
-      });
+      // let aliceWatchResult = false;
+      // const aliceWatchCancel = alice.watchAddressTransactions((_tx) => {
+      //   aliceWatchCancel();
+      //   aliceWatchResult = true;
+      // });
 
-      let bobWatchResult = false;
-      const bobWatchCancel = bob.watchAddress((_txHash) => {
-        bobWatchCancel();
-        bobWatchResult = true;
-      });
+      // let bobWatchResult = false;
+      // const bobWatchCancel = bob.watchAddress((_txHash) => {
+      //   bobWatchCancel();
+      //   bobWatchResult = true;
+      // });
 
       let bobBalanceWatchResult = false;
       const bobBalanceWatchCancel = bob.watchBalance((balance) => {
@@ -358,8 +358,8 @@ describe(`Wallet should function in the browser`, () => {
       await delay(5000);
       expect(waitTxResult).toBe(true);
       expect(waitBalanceResult).toBe(true);
-      expect(aliceWatchResult).toBe(true);
-      expect(bobWatchResult).toBe(true);
+      // expect(aliceWatchResult).toBe(true);
+      // expect(bobWatchResult).toBe(true);
       expect(bobBalanceWatchResult).toBe(true);
       // expect(blockWatchResult).toBe(true);
       // expect(blockWaitResult).toBe(true);

package/src/db/SqlProvider.test.ts

@@ -251,10 +251,27 @@ test("Should default to rejectUnauthorized false if not exactly false", async ()
   expect(c.ssl.rejectUnauthorized).toBe(true);
 });
 
-test("Should default to rejectUnauthorized when unconfigured", async () => {
+test("Should default to rejectUnauthorized when undefined", async () => {
   process.env.DATABASE_SSL_REJECT_UNAUTHORIZED = undefined;
 
   let provider = new SqlProvider(`regtest ${Math.random()}`);
   let c = provider.getConfig();
   expect(c.ssl.rejectUnauthorized).toBe(true);
 });
+
+test("Should default to rejectUnauthorized when non-existent", async () => {
+  delete process.env.DATABASE_SSL_REJECT_UNAUTHORIZED;
+  let provider = new SqlProvider(`regtest ${Math.random()}`);
+  let c = provider.getConfig();
+  expect(c.ssl.rejectUnauthorized).toBe(true);
+});
+
+test("Should not have ssl property when unconfigured", async () => {
+  delete process.env.DATABASE_SSL_REJECT_UNAUTHORIZED;
+  delete process.env.DATABASE_SSL_CA;
+  delete process.env.DATABASE_SSL_KEY;
+  delete process.env.DATABASE_SSL_CERT;
+  let provider = new SqlProvider(`regtest ${Math.random()}`);
+  let c = provider.getConfig();
+  expect(c.ssl).toBe(undefined);
+});

package/src/db/SqlProvider.ts

@@ -6,7 +6,6 @@ import { WebhookBch } from "../webhook/WebhookBch";
 import { WebhookSlp } from "../webhook/WebhookSlp";
 import { RegisterWebhookParams } from "../webhook/interface";
 import { isCashAddress } from "../util/bchaddr";
-var parseDbUrl = require("parse-database-url");
 import { getSslConfig } from "./util";
 
 export default class SqlProvider implements StorageProvider {
@@ -26,9 +25,10 @@ export default class SqlProvider implements StorageProvider {
         "Named wallets and webhooks require a postgres DATABASE_URL environment variable to be set"
       );
     }
+    const parseDbUrl = eval("require")("parse-database-url");
     let dbConfig = parseDbUrl(process.env.DATABASE_URL);
     let ssl = getSslConfig();
-    if (ssl.cert) {
+    if (ssl) {
       dbConfig.ssl = ssl;
     }
     this.config = dbConfig;

package/src/db/util.ts

@@ -23,7 +23,7 @@ export function indexedDbIsAvailable() {
   return "indexedDB" in globalThis;
 }
 
-export function getSslConfig(): sslConfigI {
+export function getSslConfig(): sslConfigI | undefined {
   const ca = process.env.DATABASE_SSL_CA
     ? Buffer.from(process.env.DATABASE_SSL_CA, "base64").toString("ascii")
     : undefined;
@@ -40,5 +40,9 @@ export function getSslConfig(): sslConfigI {
     key: key,
     cert: cert,
   };
-  return ssl;
+  if (ssl.ca || ssl.cert || ssl.key) {
+    return ssl;
+  } else {
+    return;
+  }
 }

package/src/index.ts

@@ -38,3 +38,7 @@ export { WalletRequestI, WalletResponseI } from "./wallet/interface";
 
 // TODO move this up to util (Mainnet) ?
 export * from "./util/bchaddr";
+
+export function cube(x: number) {
+  return x * x * x;
+}

package/src/mine/mine.ts

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

package/src/network/ElectrumNetworkProvider.ts

@@ -139,6 +139,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return new Promise(async (resolve, reject) => {
       let txHash = await Util.getTransactionHash(txHex);
       if (!awaitPropagation) {
+        this.performRequest("blockchain.transaction.broadcast", txHex);
         resolve(txHash);
       } else {
         const waitForTransactionCallback = async (data) => {
@@ -176,48 +177,73 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     return result;
   }
 
-  public watchAddress(
+  public watchAddressStatus(
     cashaddr: string,
-    callback: (txHash: string) => void
+    callback: (status: string) => void
   ): CancelWatchFn {
-    const watchAddressCallback = async (data) => {
+    const watchAddressStatusCallback = async (data) => {
       // subscription acknowledgement is the latest known status or null if no status is known
-      // status is an array: [ cashaddr, [tx_hashes] ]
+      // status is an array: [ cashaddr, statusHash ]
       if (data instanceof Array) {
-        let addr = data[0] as string;
+        const addr = data[0] as string;
         if (addr !== cashaddr) {
           return;
         }
 
-        for (const txHash of data[1]) {
-          if (!txHash) {
-            // data[1] can be null eventually if there are no tx for this address
-            continue;
-          }
-          callback(txHash);
-        }
+        const status = data[1];
+        callback(status);
       }
     };
 
-    this.subscribeToAddressTransactions(cashaddr, watchAddressCallback);
+    this.subscribeToAddress(cashaddr, watchAddressStatusCallback);
 
     return async () => {
-      await this.unsubscribeFromAddressTransactions(
-        cashaddr,
-        watchAddressCallback
-      );
+      await this.unsubscribeFromAddress(cashaddr, watchAddressStatusCallback);
     };
   }
 
-  public watchAddressTransactions(
-    cashaddr: string,
-    callback: (tx: ElectrumRawTransaction) => void
-  ): CancelWatchFn {
-    return this.watchAddress(cashaddr, async (txHash: string) => {
-      const tx = await this.getRawTransactionObject(txHash);
-      callback(tx);
-    });
-  }
+  // public watchAddress(
+  //   cashaddr: string,
+  //   callback: (txHash: string) => void
+  // ): CancelWatchFn {
+  //   const watchAddressCallback = async (data) => {
+  //     // subscription acknowledgement is the latest known status or null if no status is known
+  //     // status is an array: [ cashaddr, [tx_hashes] ]
+  //     if (data instanceof Array) {
+  //       let addr = data[0] as string;
+  //       if (addr !== cashaddr) {
+  //         return;
+  //       }
+
+  //       for (const txHash of data[1]) {
+  //         if (!txHash) {
+  //           // data[1] can be null eventually if there are no tx for this address
+  //           continue;
+  //         }
+  //         callback(txHash);
+  //       }
+  //     }
+  //   };
+
+  //   this.subscribeToAddressTransactions(cashaddr, watchAddressCallback);
+
+  //   return async () => {
+  //     await this.unsubscribeFromAddressTransactions(
+  //       cashaddr,
+  //       watchAddressCallback
+  //     );
+  //   };
+  // }
+
+  // public watchAddressTransactions(
+  //   cashaddr: string,
+  //   callback: (tx: ElectrumRawTransaction) => void
+  // ): CancelWatchFn {
+  //   return this.watchAddress(cashaddr, async (txHash: string) => {
+  //     const tx = await this.getRawTransactionObject(txHash);
+  //     callback(tx);
+  //   });
+  // }
 
   // Wait for the next block or a block at given blockchain height.
   public watchBlocks(callback: (header: HeaderI) => void): CancelWatchFn {

package/src/network/constant.ts

@@ -10,7 +10,12 @@ export const networkTickerMap = {
 
 export const mainnetServers = ["wss://fulcrum.fountainhead.cash"];
 
-export const testnetServers = ["wss://electroncash.de:60004"];
+export const testnetServers = [
+  "wss://electroncash.de:60004", //,
+  // "wss://testnet.bitcoincash.network:60004",
+  // "wss://blackie.c3-soft.com:60004",
+  // "wss://tbch.loping.net:60004",
+];
 
 export const regtestServers = ["ws://127.0.0.1:60003"];
 

package/src/network/electrum.test.ts

@@ -6,7 +6,9 @@ test("Should get a transaction with bare electrum", async () => {
   const electrum = new ElectrumClient(
     "Electrum client example",
     "1.4.1",
-    "bch.imaginary.cash"
+    "bch.imaginary.cash",
+    50004,
+    "wss"
   );
   await electrum.connect();
   const transactionID =

package/src/util/eventsource.ts

@@ -4,7 +4,7 @@ let EventSource;
 if (getRuntimePlatform() != "node") {
   EventSource = globalThis.EventSource;
 } else {
-  EventSource = require("eventsource/");
+  EventSource = eval("require")("eventsource/");
 }
 
 export default EventSource;

package/src/util/randomBytes.ts

@@ -3,7 +3,8 @@ import { getRuntimePlatform } from "./getRuntimePlatform";
 export function generateRandomBytes(len = 32) {
   // nodejs
   if (getRuntimePlatform() === "node") {
-    let crypto = require("crypto");
+    //
+    const crypto = eval("require")("crypto");
     return crypto.randomBytes(len);
   }
   // window, webworkers, service workers

package/src/wallet/Wif.test.ts

@@ -8,8 +8,8 @@ import { delay } from "../util/delay";
 import { OpReturnData, SendResponse } from "./model";
 import { ElectrumRawTransaction } from "../network/interface";
 import { binToHex, binToUtf8, hexToBin, utf8ToBin } from "@bitauth/libauth";
-import { ElectrumNetworkProvider } from "cashscript";
 import { mine } from "../mine";
+import ElectrumNetworkProvider from "../network/ElectrumNetworkProvider";
 
 beforeAll(async () => {
   await initProviders();
@@ -358,6 +358,62 @@ describe(`Wallet subscriptions`, () => {
     await bobWallet.sendMax(aliceWallet.cashaddr!);
   });
 
+  test("Should await and skip transaction propagation", async () => {
+    const aliceWallet = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bobWallet = await RegTestWallet.newRandom();
+
+    let balance, newBalance;
+    balance = await aliceWallet.getBalance("sat");
+
+    aliceWallet
+      .send(
+        [
+          {
+            cashaddr: bobWallet.cashaddr!,
+            value: 1000,
+            unit: "satoshis",
+          },
+        ],
+        { awaitTransactionPropagation: false }
+      )
+      .then(async () => {
+        newBalance = await aliceWallet.getBalance("sat");
+        expect(balance).toBe(newBalance);
+      });
+
+    await delay(1500);
+
+    balance = await aliceWallet.getBalance("sat");
+    await aliceWallet.send(
+      [
+        {
+          cashaddr: bobWallet.cashaddr!,
+          value: 1000,
+          unit: "satoshis",
+        },
+      ],
+      { awaitTransactionPropagation: false }
+    );
+
+    newBalance = await aliceWallet.getBalance("sat");
+    expect(balance).toBe(newBalance);
+
+    balance = await aliceWallet.getBalance("sat");
+    await aliceWallet.send(
+      [
+        {
+          cashaddr: bobWallet.cashaddr!,
+          value: 1000,
+          unit: "satoshis",
+        },
+      ],
+      { awaitTransactionPropagation: true }
+    );
+
+    newBalance = await aliceWallet.getBalance("sat");
+    expect(balance).toBeGreaterThan(newBalance);
+  });
+
   test("Create two wallets, get balances concurrently", async () => {
     let balance1 = 999,
       balance2 = 666;
@@ -534,13 +590,17 @@ describe(`Wallet subscriptions`, () => {
     }, 0);
 
     let aliceWatchResult = false;
-    const aliceWatchCancel = alice.watchAddressTransactions((_tx) => {
+    const aliceWatchCancel = (
+      alice.provider! as ElectrumNetworkProvider
+    ).watchAddressStatus(alice.getDepositAddress(), (_status) => {
       aliceWatchCancel();
       aliceWatchResult = true;
     });
 
     let bobWatchResult = false;
-    const bobWatchCancel = bob.watchAddress((_txHash) => {
+    const bobWatchCancel = (
+      bob.provider! as ElectrumNetworkProvider
+    ).watchAddressStatus(bob.getDepositAddress(), (_status) => {
       bobWatchCancel();
       bobWatchResult = true;
     });

package/src/wallet/Wif.ts

@@ -557,33 +557,38 @@ export class Wallet extends BaseWallet {
     }
   }
 
-  // waiting for any transaction hash of this wallet
-  public watchAddress(callback: (txHash: string) => void): CancelWatchFn {
-    return (this.provider! as ElectrumNetworkProvider).watchAddress(
-      this.getDepositAddress(),
-      callback
-    );
-  }
-
-  // waiting for any transaction of this wallet
-  public watchAddressTransactions(
-    callback: (tx: ElectrumRawTransaction) => void
-  ): CancelWatchFn {
-    return (this.provider! as ElectrumNetworkProvider).watchAddressTransactions(
-      this.getDepositAddress(),
-      callback
-    );
-  }
+  // // waiting for any transaction hash of this wallet
+  // // commented out until fulcrum supports new method https://github.com/cculianu/Fulcrum/pull/89
+  // public watchAddress(callback: (txHash: string) => void): CancelWatchFn {
+  //   return (this.provider! as ElectrumNetworkProvider).watchAddress(
+  //     this.getDepositAddress(),
+  //     callback
+  //   );
+  // }
+
+  // // waiting for any transaction of this wallet
+  // // commented out until fulcrum supports new method https://github.com/cculianu/Fulcrum/pull/89
+  // public watchAddressTransactions(
+  //   callback: (tx: ElectrumRawTransaction) => void
+  // ): CancelWatchFn {
+  //   return (this.provider! as ElectrumNetworkProvider).watchAddressTransactions(
+  //     this.getDepositAddress(),
+  //     callback
+  //   );
+  // }
 
   // sets up a callback to be called upon wallet's balance change
   // can be cancelled by calling the function returned from this one
   public watchBalance(
     callback: (balance: BalanceResponse) => void
   ): CancelWatchFn {
-    return this.watchAddress(async (_txHash: string) => {
-      const balance = (await this.getBalance()) as BalanceResponse;
-      callback(balance);
-    });
+    return (this.provider! as ElectrumNetworkProvider).watchAddressStatus(
+      this.getDepositAddress(),
+      async (_status: string) => {
+        const balance = (await this.getBalance()) as BalanceResponse;
+        callback(balance);
+      }
+    );
   }
 
   // sets up a callback to be called upon wallet's BCH or USD balance change
@@ -608,7 +613,9 @@ export class Wallet extends BaseWallet {
       }
     };
 
-    const watchCancel = this.watchAddress(_callback);
+    const watchCancel = (
+      this.provider! as ElectrumNetworkProvider
+    ).watchAddressStatus(this.getDepositAddress(), _callback);
     const interval = setInterval(_callback, usdPriceRefreshInterval);
 
     return async () => {
@@ -690,7 +697,12 @@ export class Wallet extends BaseWallet {
     });
     const spendableAmount = await sumUtxoValue(fundingUtxos);
 
-    return await balanceResponseFromSatoshi(spendableAmount - fee);
+    let result = spendableAmount - fee;
+    if (result < 0) {
+      result = 0;
+    }
+
+    return await balanceResponseFromSatoshi(result);
   }
 
   /**
@@ -788,7 +800,7 @@ export class Wallet extends BaseWallet {
     return new Promise(async (resolve) => {
       let txHashSeen = false;
 
-      const makeResponse = async (txHash: string) => {
+      const makeResponse = async (txHash?: string) => {
         const response = <WaitForTransactionResponse>{};
         const promises: any[] = [undefined, undefined];
 
@@ -797,7 +809,11 @@ export class Wallet extends BaseWallet {
         }
 
         if (options.getTransactionInfo === true) {
-          promises[1] = this.provider!.getRawTransactionObject(txHash);
+          if (!txHash) {
+            promises[1] = this.getLastTransaction();
+          } else {
+            promises[1] = this.provider!.getRawTransactionObject(txHash);
+          }
         }
 
         const result = await Promise.all(promises);
@@ -829,9 +845,11 @@ export class Wallet extends BaseWallet {
       }
 
       // waiting for any address transaction
-      const watchCancel = this.watchAddress(async (txHash) => {
+      const watchCancel = (
+        this.provider! as ElectrumNetworkProvider
+      ).watchAddressStatus(this.getDepositAddress(), async (_status) => {
         watchCancel();
-        resolve(makeResponse(txHash));
+        resolve(makeResponse());
       });
     });
   }