edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/network/Socket.js

@@ -0,0 +1,362 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _utils = require('../../plugin/utils');
+
+var _MakeSocketEmitter = require('./MakeSocketEmitter');
+var _nodejsWS = require('./nodejsWS');
+var _socketQueue = require('./socketQueue');
+var _types3 = require('./types');
+var _windowWS = require('./windowWS');
+
+const TIMER_SLACK = 500
+const KEEP_ALIVE_MS = 60000 // interval at which we keep the connection alive
+const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSpace
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function makeSocket(uri, config) {
+  let socket
+  const { emitter, log, queueSize = 50, walletId } = config
+  log('makeSocket connects to', uri)
+  const version = ''
+  const socketQueueId = walletId + '==' + uri
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const subscriptions = {}
+  let onQueueSpace = config.onQueueSpaceCB
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let pendingMessages = {}
+  let nextId = 0
+  let lastKeepAlive = 0
+  let lastWakeUp = 0
+  let connected = false
+  let cancelConnect = false
+  const timeout = 1000 * (_nullishCoalesce(config.timeout, () => ( 30)))
+  let error
+  let timer
+
+  const handleError = (e) => {
+    if (error == null) error = e
+    if (connected && socket != null && socket.readyState === _types3.ReadyState.OPEN)
+      disconnect()
+    else cancelConnect = true
+    log.error('handled error!', e)
+  }
+
+  const disconnect = () => {
+    log.warn('disconnecting from socket', uri)
+    clearTimeout(timer)
+    connected = false
+    if (socket != null) socket.disconnect()
+    _socketQueue.removeIdFromQueue.call(void 0, socketQueueId)
+  }
+
+  const onSocketClose = () => {
+    const err = _nullishCoalesce(error, () => ( new Error('Socket close')))
+    log.warn(`onSocketClose due to ${err.message} with server ${uri}`)
+    clearTimeout(timer)
+    connected = false
+    socket = null
+    cancelConnect = false
+    for (const message of Object.values(pendingMessages)) {
+      try {
+        message.task.deferred.reject(err)
+      } catch (e) {
+        log.error(e.message)
+      }
+    }
+    pendingMessages = {}
+    try {
+      emitter.emit(_MakeSocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, err)
+    } catch (e) {
+      log.error(e.message)
+    }
+  }
+
+  const onSocketConnect = () => {
+    log(`onSocketConnect with server ${uri}`)
+    if (cancelConnect) {
+      if (socket != null) socket.disconnect()
+      return
+    }
+    connected = true
+    lastKeepAlive = Date.now()
+    try {
+      emitter.emit(_MakeSocketEmitter.SocketEvent.CONNECTION_OPEN, uri)
+    } catch (e) {
+      handleError(e)
+    }
+    for (const [id, message] of Object.entries(pendingMessages)) {
+      transmitMessage(id, message)
+    }
+
+    wakeUp()
+    cancelConnect = false
+  }
+
+  const wakeUp = () => {
+    log(`wakeUp socket with server ${uri}`)
+    _socketQueue.pushUpdate.call(void 0, {
+      id: socketQueueId,
+      updateFunc: () => {
+        doWakeUp().catch(err => {
+          throw new Error(`wake up error from: ${err.message}`)
+        })
+      }
+    })
+  }
+
+  const doWakeUp = async () => {
+    log(`doWakeUp socket with server ${uri}`)
+    lastWakeUp = Date.now()
+    if (connected && version != null) {
+      while (Object.keys(pendingMessages).length < queueSize) {
+        const task = await _optionalChain([onQueueSpace, 'optionalCall', _ => _(uri)])
+        if (task == null) break
+        if (typeof task === 'boolean') {
+          if (task) continue
+          break
+        }
+        submitTask(task)
+      }
+    }
+  }
+
+  // add any exception, since the passed in template parameter needs to be re-assigned
+  const subscribe = (subscription) => {
+    if (socket != null && socket.readyState === _types3.ReadyState.OPEN && connected) {
+      const id = subscription.method
+      const message = {
+        id,
+        method: subscription.method,
+        params: _nullishCoalesce(subscription.params, () => ( {}))
+      }
+      subscriptions[id] = subscription
+      socket.send(JSON.stringify(message))
+    }
+  }
+
+  // add any exception, since the passed in template parameter needs to be re-assigned
+  const submitTask = (task) => {
+    const id = (nextId++).toString()
+    const message = { task, startTime: Date.now() }
+    pendingMessages[id] = message
+    transmitMessage(id, message)
+  }
+
+  const transmitMessage = (id, pending) => {
+    const now = Date.now()
+    if (
+      socket != null &&
+      socket.readyState === _types3.ReadyState.OPEN &&
+      connected &&
+      !cancelConnect
+    ) {
+      pending.startTime = now
+      const message = {
+        id,
+        method: pending.task.method,
+        params: _nullishCoalesce(pending.task.params, () => ( {}))
+      }
+      socket.send(JSON.stringify(message))
+    }
+  }
+
+  const onTimer = () => {
+    log(`socket timer with server ${uri} expired, check if healthCheck needed`)
+    const now = Date.now() - TIMER_SLACK
+    if (lastKeepAlive + KEEP_ALIVE_MS < now) {
+      log(`submitting healthCheck to server ${uri}`)
+      lastKeepAlive = now
+      config
+        .healthCheck()
+        .then(() => {
+          emitter.emit(_MakeSocketEmitter.SocketEvent.CONNECTION_TIMER, uri, now)
+        })
+        .catch((e) => handleError(e))
+    }
+
+    for (const [id, message] of Object.entries(pendingMessages)) {
+      if (message.startTime + timeout < now) {
+        try {
+          message.task.deferred.reject(new Error('Timeout'))
+        } catch (e) {
+          log.error(e.message)
+        }
+        _utils.removeItem.call(void 0, pendingMessages, id)
+      }
+    }
+    wakeUp()
+    setupTimer()
+  }
+
+  const setupTimer = () => {
+    log(`setupTimer with server ${uri}`)
+    let nextWakeUp = lastWakeUp + WAKE_UP_MS
+    for (const message of Object.values(pendingMessages)) {
+      const to = message.startTime + timeout
+      if (to < nextWakeUp) nextWakeUp = to
+    }
+
+    const now = Date.now() - TIMER_SLACK
+    const delay = nextWakeUp < now ? 0 : nextWakeUp - now
+    timer = setTimeout(() => onTimer(), delay)
+  }
+
+  const onMessage = (messageJson) => {
+    try {
+      const json = JSON.parse(messageJson)
+      if (json.id != null) {
+        const id = json.id.toString()
+        for (const cId of Object.keys(subscriptions)) {
+          if (id === cId) {
+            const subscription = subscriptions[id]
+            if (subscription == null) {
+              throw new Error(`cannot find subscription for ${id}`)
+            }
+            if (_optionalChain([json, 'access', _2 => _2.data, 'optionalAccess', _3 => _3.subscribed]) != null) {
+              subscription.subscribed = true
+              subscription.deferred.resolve(json.data)
+              return
+            }
+            if (!subscription.subscribed) {
+              subscription.deferred.reject()
+            }
+            subscription.cb(subscription.cleaner(json.data))
+            return
+          }
+        }
+        const message = pendingMessages[id]
+        if (message == null) {
+          throw new Error(`Bad response id in ${messageJson}`)
+        }
+        _utils.removeItem.call(void 0, pendingMessages, id)
+        const { error } = json
+        try {
+          if (error != null) {
+            const errorMessage =
+              error.message != null ? error.message : error.connected
+            throw new Error(errorMessage)
+          }
+          if (message.task.cleaner != null) {
+            message.task.deferred.resolve(message.task.cleaner(json.data))
+          } else {
+            message.task.deferred.resolve(json.data)
+          }
+        } catch (e) {
+          if (e instanceof TypeError) console.log({ json, message })
+          message.task.deferred.reject(e)
+        }
+      }
+    } catch (e) {
+      handleError(e)
+    }
+    wakeUp()
+  }
+
+  setupTimer()
+
+  // return a Socket
+  return {
+    get readyState() {
+      return _nullishCoalesce(_optionalChain([socket, 'optionalAccess', _4 => _4.readyState]), () => ( _types3.ReadyState.CLOSED))
+    },
+
+    async connect() {
+      _optionalChain([socket, 'optionalAccess', _5 => _5.disconnect, 'call', _6 => _6()])
+
+      return await new Promise(resolve => {
+        const cbs = {
+          onOpen: () => {
+            onSocketConnect()
+            resolve()
+          },
+          onMessage: onMessage,
+          onError: event => {
+            error = new Error(JSON.stringify(event))
+          },
+          onClose: onSocketClose
+        }
+
+        // Append "/websocket" if needed:
+        const fullUri = uri.replace(/\/websocket\/?$/, '') + '/websocket'
+        try {
+          socket = _windowWS.setupBrowser.call(void 0, fullUri, cbs)
+        } catch (e2) {
+          socket = _nodejsWS.setupWS.call(void 0, fullUri, cbs)
+        }
+      })
+    },
+
+    disconnect() {
+      _optionalChain([socket, 'optionalAccess', _7 => _7.disconnect, 'call', _8 => _8()])
+      socket = null
+      disconnect()
+    },
+
+    isConnected() {
+      return _optionalChain([socket, 'optionalAccess', _9 => _9.readyState]) === _types3.ReadyState.OPEN
+    },
+
+    submitTask,
+
+    onQueueSpace(cb) {
+      onQueueSpace = cb
+    },
+
+    subscribe
+  }
+} exports.makeSocket = makeSocket;

package/lib/common/utxobased/network/nodejsWS.js

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var _ws = require('ws'); var _ws2 = _interopRequireDefault(_ws);
+
+var _types = require('./types');
+
+ function setupWS(
+  uri,
+  callbacks
+) {
+  const ws = new (0, _ws2.default)(uri, {
+    headers: {
+      'User-Agent': 'NodeJS-WS-agent'
+    }
+  })
+
+  ws.on('open', () => {
+    callbacks.onOpen()
+  })
+  ws.on('message', (data) => {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    callbacks.onMessage(data.toString())
+  })
+  ws.on('error', error => {
+    callbacks.onError(error)
+  })
+  ws.on('close', _event => {
+    callbacks.onClose()
+  })
+
+  return {
+    get readyState() {
+      switch (ws.readyState) {
+        case _ws2.default.CONNECTING:
+          return _types.ReadyState.CONNECTING
+        case _ws2.default.OPEN:
+          return _types.ReadyState.OPEN
+        case _ws2.default.CLOSING:
+          return _types.ReadyState.CLOSING
+        case _ws2.default.CLOSED:
+        default:
+          return _types.ReadyState.CLOSED
+      }
+    },
+
+    disconnect() {
+      if (
+        ws == null ||
+        ws.readyState === _ws2.default.CLOSING ||
+        ws.readyState === _ws2.default.CLOSED
+      )
+        return
+      ws.removeAllListeners()
+      ws.close()
+    },
+
+    send(data) {
+      ws.send(data)
+    }
+  }
+} exports.setupWS = setupWS;

package/lib/common/utxobased/network/socketQueue.js

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }const QUEUE_JOBS_PER_RUN = 3
+const QUEUE_RUN_DELAY = 1000
+
+
+
+
+
+
+
+const updateQueue = []
+let timeOut
+
+ function pushUpdate(update) {
+  const shouldRun = updateQueue.length === 0
+  let didUpdate = false
+  for (const u of updateQueue) {
+    if (u.id === update.id && u.action === update.action) {
+      u.updateFunc = update.updateFunc
+      didUpdate = true
+      break
+    }
+  }
+  if (!didUpdate) {
+    updateQueue.push(update)
+  }
+  if (shouldRun) {
+    startQueue()
+  }
+} exports.pushUpdate = pushUpdate;
+
+ function removeIdFromQueue(id) {
+  for (let i = 0; i < updateQueue.length; i++) {
+    const update = updateQueue[i]
+    if (id === update.id) {
+      updateQueue.splice(i, 1)
+      break
+    }
+  }
+  if (updateQueue.length === 0) {
+    clearTimeout(timeOut)
+  }
+} exports.removeIdFromQueue = removeIdFromQueue;
+
+function startQueue() {
+  const numJobs =
+    QUEUE_JOBS_PER_RUN < updateQueue.length
+      ? QUEUE_JOBS_PER_RUN
+      : updateQueue.length
+  for (let i = 0; i < numJobs; i++) {
+    if (updateQueue.length > 0) {
+      const u = updateQueue.shift()
+      _optionalChain([u, 'optionalAccess', _ => _.updateFunc, 'call', _2 => _2()])
+    }
+  }
+  if (updateQueue.length > 0) {
+    timeOut = setTimeout(() => {
+      startQueue()
+    }, QUEUE_RUN_DELAY)
+  }
+}

package/lib/common/utxobased/network/types.js

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var ReadyState; (function (ReadyState) {
+  const CONNECTING = 0; ReadyState[ReadyState["CONNECTING"] = CONNECTING] = "CONNECTING";
+  const OPEN = CONNECTING + 1; ReadyState[ReadyState["OPEN"] = OPEN] = "OPEN";
+  const CLOSING = OPEN + 1; ReadyState[ReadyState["CLOSING"] = CLOSING] = "CLOSING";
+  const CLOSED = CLOSING + 1; ReadyState[ReadyState["CLOSED"] = CLOSED] = "CLOSED";
+})(ReadyState || (exports.ReadyState = ReadyState = {}));
+
+
+
+
+
+

package/lib/common/utxobased/network/windowWS.js

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _types = require('./types');
+
+ function setupBrowser(
+  uri,
+  callbacks
+) {
+  if (window.WebSocket == null)
+    throw Error('Native browser WebSocket does not exists')
+
+  const socket = new window.WebSocket(uri)
+  socket.onopen = () => {
+    callbacks.onOpen()
+  }
+  socket.onmessage = (message) => {
+    callbacks.onMessage(message.data.toString())
+  }
+  socket.onerror = () => {
+    callbacks.onError()
+  }
+  socket.onclose = () => {
+    callbacks.onClose()
+  }
+
+  return {
+    get readyState() {
+      switch (socket.readyState) {
+        case WebSocket.CONNECTING:
+          return _types.ReadyState.CONNECTING
+        case WebSocket.OPEN:
+          return _types.ReadyState.OPEN
+        case WebSocket.CLOSING:
+          return _types.ReadyState.CLOSING
+        case WebSocket.CLOSED:
+        default:
+          return _types.ReadyState.CLOSED
+      }
+    },
+
+    disconnect() {
+      if (
+        socket == null ||
+        socket.readyState === WebSocket.CLOSING ||
+        socket.readyState === WebSocket.CLOSED
+      )
+        return
+
+      socket.close()
+    },
+
+    send(data) {
+      socket.send(data)
+    }
+  }
+} exports.setupBrowser = setupBrowser;

package/lib/firo.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _zcoin = require('./common/utxobased/info/zcoin');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _zcoin.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_zcoin.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/ftc.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _feathercoin = require('./common/utxobased/info/feathercoin');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _feathercoin.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_feathercoin.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createNamedExportFrom(obj, localName, importedName) { Object.defineProperty(exports, localName, {enumerable: true, get: () => obj[importedName]}); } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _all = require('./common/utxobased/info/all');
+
+const plugins = {}
+
+for (const info of _all.all) {
+  plugins[info.currencyInfo.pluginId] = (options) =>
+    _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, info)
+}
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2(plugins)])
+}
+
+exports. default = plugins
+
+var _memlet = require('memlet'); _createNamedExportFrom(_memlet, 'setMemletConfig', 'setMemletConfig');

package/lib/ltc.js

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _makeCurrencyPlugin = require('./common/plugin/makeCurrencyPlugin');
+var _litecoin = require('./common/utxobased/info/litecoin');
+
+const plugin = (options) =>
+  _makeCurrencyPlugin.makeCurrencyPlugin.call(void 0, options, _litecoin.info)
+
+if (typeof window !== 'undefined') {
+  _optionalChain([window, 'access', _ => _.addEdgeCorePlugins, 'optionalCall', _2 => _2({
+    [_litecoin.info.currencyInfo.pluginId]: plugin
+  })])
+}
+
+exports. default = plugin

package/lib/src/bch.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/bsv.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/btc.d.ts

@@ -0,0 +1,3 @@
+import { EdgeCorePluginOptions, EdgeCurrencyPlugin } from 'edge-core-js/types';
+declare const plugin: (options: EdgeCorePluginOptions) => EdgeCurrencyPlugin;
+export default plugin;

package/lib/src/common/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const IMAGE_SERVER_URL = "https://content.edge.app";
+export declare const INFO_SERVER_URI = "https://info1.edgesecure.co:8444/v1";
+export declare const FEES_PATH = "fees.json";
+export declare const MAX_FEE = 999999999;
+export declare const LOW_FEE = 2;
+export declare const MAX_HIGH_DELAY = 200;
+export declare const MAX_STANDARD_DELAY = 6;
+export declare const MIN_STANDARD_DELAY = 2;
+export declare const MIN_LOW_DELAY = 1;

package/lib/src/common/fees/calcMinerFeePerByte.d.ts

@@ -0,0 +1,13 @@
+import { EdgeSpendInfo } from 'edge-core-js/types';
+import { SimpleFeeSettings } from '../plugin/types';
+declare type NetworkFeeOption = EdgeSpendInfo['networkFeeOption'];
+/**
+ * Calculate the sat/byte mining fee given an amount to spend and a SimpleFeeSettings object
+ * @param nativeAmount
+ * @param fees
+ * @param networkFeeOption
+ * @param customNetworkFee
+ * @returns {string}
+ */
+export declare const calcMinerFeePerByte: (nativeAmount: string, fees: SimpleFeeSettings, networkFeeOption?: NetworkFeeOption, customNetworkFee?: string | undefined) => string;
+export {};

package/lib/src/common/fees/makeFees.d.ts

@@ -0,0 +1,20 @@
+import { Disklet } from 'disklet';
+import { EdgeIo, EdgeLog, EdgeSpendInfo } from 'edge-core-js/types';
+import { PluginInfo, SimpleFeeSettings } from '../plugin/types';
+interface MakeFeesConfig extends Common {
+    disklet: Disklet;
+    pluginInfo: PluginInfo;
+}
+interface Common {
+    io: EdgeIo;
+    log: EdgeLog;
+}
+export interface Fees {
+    start: () => Promise<void>;
+    stop: () => void;
+    clearCache: () => Promise<void>;
+    getRate: (edgeSpendInfo: EdgeSpendInfo) => Promise<string>;
+    fees: SimpleFeeSettings;
+}
+export declare const makeFees: (config: MakeFeesConfig) => Promise<Fees>;
+export {};