mainnet-js 0.5.9 → 1.0.0-rc.3

package/src/network/default.ts

@@ -1,12 +1,16 @@
-import { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider";
+import { default as ElectrumNetworkProvider } from "./ElectrumNetworkProvider.js";
 import { ElectrumCluster, ElectrumClient } from "electrum-cash";
-import { default as NetworkProvider } from "./NetworkProvider";
-import { defaultServers, getConfidence, getUserAgent } from "./configuration";
-import { parseElectrumUrl } from "./util";
-import { ElectrumHostParams, ElectrumClusterParams } from "./interface";
-import { Network } from "../interface";
-import { networkTickerMap, clusterParams } from "./constant";
-import { ELECTRUM_CASH_PROTOCOL_VERSION } from "./constant";
+import { default as NetworkProvider } from "./NetworkProvider.js";
+import {
+  getConfidence,
+  getDefaultServers,
+  getUserAgent,
+} from "./configuration.js";
+import { parseElectrumUrl } from "./util.js";
+import { ElectrumHostParams, ElectrumClusterParams } from "./interface.js";
+import { Network } from "../interface.js";
+import { networkTickerMap, clusterParams } from "./constant.js";
+import { ELECTRUM_CASH_PROTOCOL_VERSION } from "./constant.js";
 
 export function setGlobalProvider(
   network: Network,
@@ -50,8 +54,7 @@ export function getNetworkProvider(
   manualConnectionManagement = manualConnectionManagement
     ? manualConnectionManagement
     : false;
-  servers = servers ? servers : defaultServers[network];
-
+  servers = servers ? servers : getDefaultServers(network);
   // If the user has passed a single string, assume a single client connection
   if (typeof servers === "string") {
     servers = [servers as string];

package/src/network/getRelayFeeCache.ts

@@ -1,6 +1,6 @@
-import { bchParam } from "../chain";
-import { networkTickerMap } from "./constant";
-import { default as NetworkProvider } from "./NetworkProvider";
+import { bchParam } from "../chain.js";
+import { networkTickerMap } from "./constant.js";
+import { default as NetworkProvider } from "./NetworkProvider.js";
 
 export async function getRelayFeeCache(provider: NetworkProvider) {
   let relayFeePerKbInCoins;

package/src/network/index.ts

@@ -1,2 +1,6 @@
-export { getNetworkProvider } from "./default";
-export { Connection, initProviders, disconnectProviders } from "./Connection";
+export { getNetworkProvider } from "./default.js";
+export {
+  Connection,
+  initProviders,
+  disconnectProviders,
+} from "./Connection.js";

package/src/network/util.ts

@@ -1,5 +1,5 @@
 import { ElectrumTransport, TransportScheme } from "electrum-cash";
-import { ElectrumHostParams } from "./interface";
+import { ElectrumHostParams } from "./interface.js";
 
 export function parseElectrumUrl(givenUrl: string): ElectrumHostParams {
   let url = new URL(givenUrl);

package/src/qr/Qr.ts

@@ -1,6 +1,6 @@
-var QRCode = require("qrcode-svg");
-import { ImageI } from "./interface";
-import { btoa } from "../util/base64";
+import QRCode from "qrcode-svg";
+import { ImageI } from "./interface.js";
+import { btoa } from "../util/base64.js";
 
 /**
  * qrAddress returns a qr code for a given cashaddress as raw utf-8 svg

package/src/rate/ExchangeRate.ts

@@ -1,12 +1,11 @@
-import { EXCHANGE_RATE_TTL } from "../constant";
+import { EXCHANGE_RATE_TTL } from "../constant.js";
 import {
   RuntimePlatform,
   getRuntimePlatform,
-} from "../util/getRuntimePlatform";
-import ExchangeRateProvider from "../db/ExchangeRateProvider";
-import { indexedDbIsAvailable } from "../db/util";
-
-const axios = require("axios").default;
+} from "../util/getRuntimePlatform.js";
+import ExchangeRateProvider from "../db/ExchangeRateProvider.js";
+import { indexedDbIsAvailable } from "../db/util.js";
+import axios from "axios";
 
 export class ExchangeRate {
   symbol: string;
@@ -27,20 +26,20 @@ export class ExchangeRate {
   }
 
   static setupAxiosMock(mockUrl, responseData) {
-    if (!axios.interceptors.mocks) {
-      axios.interceptors.mocks = {};
+    if (!(axios.interceptors as any).mocks) {
+      (axios.interceptors as any).mocks = {};
 
       // install our interceptors
-      axios.interceptors.request.use((config) => {
+      (axios.interceptors as any).request.use((config) => {
         const url = config.url!;
 
-        if (axios.interceptors.mocks[url]) {
+        if ((axios.interceptors as any).mocks[url]) {
           // if we have set up a mocked response for this url, cancel the actual request with a cancelToken containing our mocked data
-          const mockedResponse = axios.interceptors.mocks[url];
+          const mockedResponse = (axios.interceptors as any).mocks[url];
           return {
             ...config,
             cancelToken: new axios.CancelToken((cancel) =>
-              cancel({ status: 200, data: mockedResponse })
+              cancel({ status: 200, data: mockedResponse } as any)
             ),
           };
         }
@@ -49,7 +48,7 @@ export class ExchangeRate {
         return config;
       });
 
-      axios.interceptors.response.use(
+      (axios.interceptors as any).response.use(
         function (response) {
           return response;
         },
@@ -65,11 +64,11 @@ export class ExchangeRate {
       );
     }
 
-    axios.interceptors.mocks[mockUrl] = responseData;
+    (axios.interceptors as any).mocks[mockUrl] = responseData;
   }
 
   static removeAxiosMock(mockUrl) {
-    delete (axios.interceptors.mocks || {})[mockUrl];
+    delete ((axios.interceptors as any).mocks || {})[mockUrl];
   }
 
   toString() {

package/src/slp/GsppProvider.test.ts

@@ -1,7 +1,7 @@
 import { Network, RegTestWallet, toCashAddress } from "..";
 import { GsppProvider } from "./GsppProvider";
 import { base64ToBin, binToBase64, binToHex, hexToBin } from "@bitauth/libauth";
-const cashaddrjs = require("cashaddrjs");
+import cashaddrjs from "cashaddrjs";
 
 const rotate = function (str) {
   return str
@@ -21,7 +21,7 @@ const addressToScriptpubkey = (address) => {
   ).toString("base64");
 };
 
-describe("Gspp Provider tests", () => {
+describe.skip("Gspp Provider tests", () => {
   // other GsppProvider tests are covered in the Slp.test.ts integration test suite
 
   test("Test graphsearch methods", async () => {

package/src/slp/GsppProvider.ts

@@ -1,11 +1,11 @@
-import { Network, TxI } from "../interface";
+import { Network, TxI } from "../interface.js";
 import {
   GsppTx,
   SlpTokenBalance,
   SlpTokenInfo,
   SlpTxI,
   SlpUtxoI,
-} from "./interface";
+} from "./interface.js";
 import BigNumber from "bignumber.js";
 import {
   SlpCancelWatchFn,
@@ -13,13 +13,16 @@ import {
   SlpWatchBalanceCallback,
   SlpWatchTransactionCallback,
   _emptyTokenBalance,
-} from "./SlpProvider";
+} from "./SlpProvider.js";
 import axios from "axios";
-import { btoa } from "../util/base64";
+import { btoa } from "../util/base64.js";
 
-//import EventSource from "../../polyfill/eventsource";
-import EventSource from "../util/eventsource";
-import { Mainnet } from "../index";
+//import EventSource from "../../polyfill/eventsource.js";
+import EventSource from "../util/eventsource.js";
+import {
+  getRuntimePlatform,
+  RuntimePlatform,
+} from "../util/getRuntimePlatform.js";
 
 export class GsppProvider implements SlpProvider {
   public static defaultServers = {
@@ -42,7 +45,7 @@ export class GsppProvider implements SlpProvider {
   public caching: boolean = false;
 
   constructor(public network: Network = Network.MAINNET) {
-    if (Mainnet.getRuntimePlatform() === Mainnet.RuntimePlatform.node) {
+    if (getRuntimePlatform() === RuntimePlatform.node) {
       if (process.env.GSPP_MAINNET_DATA)
         this.servers.mainnet.dataSource = process.env.GSPP_MAINNET_DATA;
       if (process.env.GSPP_MAINNET_EVENTS)

package/src/slp/SlpDbProvider.test.ts

@@ -3,7 +3,7 @@ import { disconnectProviders, initProviders } from "../network";
 import { SlpDbProvider } from "./SlpDbProvider";
 import axios from "axios";
 
-describe("Slp tests", () => {
+describe.skip("Slp tests", () => {
   beforeAll(async () => {
     await initProviders([Network.MAINNET]);
   });

package/src/slp/SlpDbProvider.ts

@@ -1,4 +1,4 @@
-import { Network, TxI } from "../interface";
+import { Network, TxI } from "../interface.js";
 import {
   SlpDbResponse,
   SlpDbTx,
@@ -6,7 +6,7 @@ import {
   SlpTokenInfo,
   SlpTxI,
   SlpUtxoI,
-} from "./interface";
+} from "./interface.js";
 import {
   SlpAllUtxosTemplate,
   SlpAddressTransactionHistoryTemplate,
@@ -17,7 +17,7 @@ import {
   SlpAllTokenBalancesTemplate,
   SlpTokenBalanceTemplate,
   SlpAllOutpointsTemplate,
-} from "./SlpDbTemplates";
+} from "./SlpDbTemplates.js";
 import BigNumber from "bignumber.js";
 import {
   SlpCancelWatchFn,
@@ -28,14 +28,17 @@ import {
   _convertSlpTokenInfo,
   _convertUtxoBigNumbers,
   _emptyTokenBalance,
-} from "./SlpProvider";
+} from "./SlpProvider.js";
 import axios from "axios";
-import { btoa } from "../util/base64";
+import { btoa } from "../util/base64.js";
 
-//import EventSource from "../../polyfill/eventsource";
-import EventSource from "../util/eventsource";
+//import EventSource from "../../polyfill/eventsource.js";
+import EventSource from "../util/eventsource.js";
 
-import { Mainnet } from "../index";
+import {
+  getRuntimePlatform,
+  RuntimePlatform,
+} from "../util/getRuntimePlatform.js";
 
 export class SlpDbProvider implements SlpProvider {
   public static defaultServers = {
@@ -58,7 +61,7 @@ export class SlpDbProvider implements SlpProvider {
   public caching: boolean = false;
 
   constructor(public network: Network = Network.MAINNET) {
-    if (Mainnet.getRuntimePlatform() === Mainnet.RuntimePlatform.node) {
+    if (getRuntimePlatform() === RuntimePlatform.node) {
       if (process.env.SLPDB_MAINNET_DATA)
         this.servers.mainnet.dataSource = process.env.SLPDB_MAINNET_DATA;
       if (process.env.SLPDB_MAINNET_EVENTS)

package/src/slp/SlpLibAuth.test.ts

@@ -15,7 +15,7 @@ import { RegTestWallet } from "../wallet/Wif";
 import { SlpUtxoI } from "./interface";
 import BigNumber from "bignumber.js";
 
-test("Test SLP genesis txo bytecode per SLP Spec", async () => {
+test.skip("Test SLP genesis txo bytecode per SLP Spec", async () => {
   const wallet = await RegTestWallet.newRandom();
 
   const genesisOptions: SlpGenesisOptions = {

package/src/slp/SlpLibAuth.ts

@@ -3,24 +3,25 @@ import {
   bigIntToBinUint64LE,
   binToHex,
   hexToBin,
+  importAuthenticationTemplate,
+  Output,
   utf8ToBin,
-  validateAuthenticationTemplate,
 } from "@bitauth/libauth";
 import { parseSLP } from "slp-parser";
 
-import { SendRequest } from "../wallet/model";
+import { SendRequest } from "../wallet/model.js";
 import {
   SlpGenesisOptions,
   SlpMintOptions,
   SlpSendRequest,
   SlpTokenType,
   SlpUtxoI,
-} from "../slp/interface";
+} from "../slp/interface.js";
 
 import BigNumber from "bignumber.js";
-import { DUST_UTXO_THRESHOLD } from "../constant";
-import { UnitEnum } from "../enum";
-import { isValidAddress, toCashAddress } from "../util/bchaddr";
+import { DUST_UTXO_THRESHOLD } from "../constant.js";
+import { UnitEnum } from "../enum.js";
+import { isValidAddress, toCashAddress } from "../util/bchaddr.js";
 
 export const bigIntToBinUint64BE = (value) => {
   return bigIntToBinUint64LE(value).reverse();
@@ -83,7 +84,7 @@ export const SlpGetGenesisOutputs = async (options: SlpGenesisOptions) => {
       })
   );
 
-  const template = validateAuthenticationTemplate(SlpTxoTemplate);
+  const template = importAuthenticationTemplate(SlpTxoTemplate);
   if (typeof template === "string") {
     throw new Error("Transaction template error");
   }
@@ -95,19 +96,22 @@ export const SlpGetGenesisOutputs = async (options: SlpGenesisOptions) => {
 
   const batonVout = options.endBaton ? [0x4c, 0x00] : [0x01, 0x02];
 
-  let genesisTxoBytecode = compiler.generateBytecode("genesis_lock", {
-    bytecode: {
-      g_token_type: Uint8Array.from([...[0x01], ...[options.type]]),
-      g_token_ticker: stringToBin(options.ticker),
-      g_token_name: stringToBin(options.name),
-      g_token_document_url: stringToBin(options.documentUrl),
-      g_token_document_hash: stringToBin(options.documentHash, true),
-      g_decimals: Uint8Array.from([...[0x01], ...[options.decimals]]),
-      g_mint_baton_vout: Uint8Array.from(batonVout),
-      g_initial_token_mint_quantity: Uint8Array.from([
-        ...[0x08],
-        ...bigIntToBinUint64BE(rawTokenAmount),
-      ]),
+  let genesisTxoBytecode = compiler.generateBytecode({
+    scriptId: "genesis_lock",
+    data: {
+      bytecode: {
+        g_token_type: Uint8Array.from([...[0x01], ...[options.type]]),
+        g_token_ticker: stringToBin(options.ticker),
+        g_token_name: stringToBin(options.name),
+        g_token_document_url: stringToBin(options.documentUrl),
+        g_token_document_hash: stringToBin(options.documentHash, true),
+        g_decimals: Uint8Array.from([...[0x01], ...[options.decimals]]),
+        g_mint_baton_vout: Uint8Array.from(batonVout),
+        g_initial_token_mint_quantity: Uint8Array.from([
+          ...[0x08],
+          ...bigIntToBinUint64BE(rawTokenAmount),
+        ]),
+      },
     },
   });
   if (!genesisTxoBytecode.success) {
@@ -118,8 +122,8 @@ export const SlpGetGenesisOutputs = async (options: SlpGenesisOptions) => {
     SlpOutputs: [
       {
         lockingBytecode: genesisTxoBytecode.bytecode,
-        satoshis: bigIntToBinUint64LE(BigInt(0)),
-      },
+        valueSatoshis: 0n,
+      } as Output,
     ],
     FundingSlpUtxos: [],
     BchSendRequests: bchSendRequests,
@@ -160,7 +164,7 @@ export const SlpGetMintOutputs = async (
       })
   );
 
-  const template = validateAuthenticationTemplate(SlpTxoTemplate);
+  const template = importAuthenticationTemplate(SlpTxoTemplate);
   if (typeof template === "string") {
     throw new Error("Transaction template error");
   }
@@ -170,15 +174,18 @@ export const SlpGetMintOutputs = async (
 
   const batonVout = options.endBaton ? [0x4c, 0x00] : [0x01, 0x02];
 
-  let mintTxoBytecode = compiler.generateBytecode("mint_lock", {
-    bytecode: {
-      m_token_type: Uint8Array.from([...[0x01], ...[tokenType]]),
-      m_token_id: hexToBin(options.tokenId),
-      m_mint_baton_vout: Uint8Array.from(batonVout),
-      m_additional_token_quantity: Uint8Array.from([
-        ...[0x08],
-        ...bigIntToBinUint64BE(BigInt(amount.toString())),
-      ]),
+  let mintTxoBytecode = compiler.generateBytecode({
+    scriptId: "mint_lock",
+    data: {
+      bytecode: {
+        m_token_type: Uint8Array.from([...[0x01], ...[tokenType]]),
+        m_token_id: hexToBin(options.tokenId),
+        m_mint_baton_vout: Uint8Array.from(batonVout),
+        m_additional_token_quantity: Uint8Array.from([
+          ...[0x08],
+          ...bigIntToBinUint64BE(BigInt(amount.toString())),
+        ]),
+      },
     },
   });
   if (!mintTxoBytecode.success) {
@@ -189,8 +196,8 @@ export const SlpGetMintOutputs = async (
     SlpOutputs: [
       {
         lockingBytecode: mintTxoBytecode.bytecode,
-        satoshis: bigIntToBinUint64LE(BigInt(0)),
-      },
+        valueSatoshis: 0n,
+      } as Output,
     ],
     FundingSlpUtxos: slpBatonUtxos,
     BchSendRequests: bchSendRequests,
@@ -249,7 +256,7 @@ export const SlpGetSendOutputs = async (
     }
   }
 
-  const template = validateAuthenticationTemplate(SlpTxoTemplate);
+  const template = importAuthenticationTemplate(SlpTxoTemplate);
   if (typeof template === "string") {
     throw new Error("Transaction template error");
   }
@@ -286,11 +293,14 @@ export const SlpGetSendOutputs = async (
     ]);
   }
 
-  let sendTxoBytecode = compiler.generateBytecode("send_lock", {
-    bytecode: {
-      s_token_type: Uint8Array.from([...[0x01], ...[tokenType]]),
-      s_token_id: hexToBin(tokenId!),
-      s_token_output_quantities: result,
+  let sendTxoBytecode = compiler.generateBytecode({
+    scriptId: "send_lock",
+    data: {
+      bytecode: {
+        s_token_type: Uint8Array.from([...[0x01], ...[tokenType]]),
+        s_token_id: hexToBin(tokenId!),
+        s_token_output_quantities: result,
+      },
     },
   });
   if (!sendTxoBytecode.success) {
@@ -304,8 +314,8 @@ export const SlpGetSendOutputs = async (
     SlpOutputs: [
       {
         lockingBytecode: sendTxoBytecode.bytecode,
-        satoshis: bigIntToBinUint64LE(BigInt(0)),
-      },
+        valueSatoshis: 0n,
+      } as Output,
     ],
     FundingSlpUtxos: fundingSlpUtxos,
     BchSendRequests: bchSendRequests,

package/src/slp/SlpProvider.ts

@@ -1,4 +1,9 @@
-import { SlpTokenBalance, SlpTokenInfo, SlpTxI, SlpUtxoI } from "./interface";
+import {
+  SlpTokenBalance,
+  SlpTokenInfo,
+  SlpTxI,
+  SlpUtxoI,
+} from "./interface.js";
 import BigNumber from "bignumber.js";
 
 export type SlpWatchTransactionCallback = (tx: SlpTxI) => void;

package/src/slp/index.ts

@@ -1,6 +1,6 @@
-export { SlpDbProvider } from "./SlpDbProvider";
-export { GsppProvider } from "./GsppProvider";
-export { SlpProvider } from "./SlpProvider";
+export { SlpDbProvider } from "./SlpDbProvider.js";
+export { GsppProvider } from "./GsppProvider.js";
+export { SlpProvider } from "./SlpProvider.js";
 export { default as BigNumber } from "bignumber.js";
 
-export * from "./interface";
+export * from "./interface.js";

package/src/slp/interface.ts

@@ -1,5 +1,5 @@
 import BigNumber from "bignumber.js";
-import { UtxoI, TxI } from "../interface";
+import { UtxoI, TxI } from "../interface.js";
 
 export enum SlpTokenType {
   Type1 = 0x01,

package/src/test/axios.ts

@@ -0,0 +1,47 @@
+import axios from "axios";
+
+export function setupAxiosMock(mockUrl, responseData) {
+  if (!(axios.interceptors as any).mocks) {
+    (axios.interceptors as any).mocks = {};
+
+    // install our interceptors
+    (axios.interceptors as any).request.use((config) => {
+      const url = config.url!;
+
+      if ((axios.interceptors as any).mocks[url]) {
+        // if we have set up a mocked response for this url, cancel the actual request with a cancelToken containing our mocked data
+        const mockedResponse = (axios.interceptors as any).mocks[url];
+        return {
+          ...config,
+          cancelToken: new axios.CancelToken((cancel) =>
+            cancel({ status: 200, data: mockedResponse } as any)
+          ),
+        };
+      }
+
+      // otherwise proceed with usual request
+      return config;
+    });
+
+    (axios.interceptors as any).response.use(
+      function (response) {
+        return response;
+      },
+      function (error: any) {
+        // resolve response with our mocked data
+        if (axios.isCancel(error)) {
+          return Promise.resolve(error.message);
+        }
+
+        // handle all other errors gracefully
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  (axios.interceptors as any).mocks[mockUrl] = responseData;
+}
+
+export function removeAxiosMock(mockUrl) {
+  delete ((axios.interceptors as any).mocks || {})[mockUrl];
+}

package/src/test/expect.ts

@@ -1,5 +1,3 @@
-export { delay } from "../util/delay";
-
 export function expect(expected) {
   return {
     toBe: function (received) {
@@ -9,6 +7,13 @@ export function expect(expected) {
         );
       }
     },
+    toEqual: function (received) {
+      if (!(expected === received)) {
+        throw new Error(
+          `assertion failed: expected ${expected} is not equal to received ${received}`
+        );
+      }
+    },
     toBeGreaterThan: function (received) {
       if (!(expected > received)) {
         throw new Error(
@@ -30,5 +35,25 @@ export function expect(expected) {
         );
       }
     },
+    toContain: function (received) {
+      if (!(expected as String).includes(received)) {
+        throw new Error(
+          `assertion failed: expected ${expected} does not Contain received ${received}`
+        );
+      }
+    },
+    rejects: {
+      toThrow: async function (message: string): Promise<void> {
+        try {
+          await expected;
+        } catch (e: any) {
+          if (!(e.message as String).includes(message)) {
+            throw new Error(
+              `assertion failed: expected function to throw with message ${message}, but it did not.`
+            );
+          }
+        }
+      },
+    },
   };
 }