edge-currency-plugins 2.6.1 → 3.0.0

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

@@ -1,6 +1,16 @@
 "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 _cleaners = require('cleaners');
+
+
 var _utils = require('../../plugin/utils');
 
 var _nodejsWS = require('./nodejsWS');
@@ -67,18 +77,49 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
 
 
 
+
+
+
+
+
+
+const asSubscriptionAck = _cleaners.asObject.call(void 0, { subscribed: _cleaners.asBoolean })
+
+
+
+
+
+const asResponseMessageDefault = _cleaners.asJSON.call(void 0, 
+  _cleaners.asObject({
+    id: _cleaners.asString,
+    data: _cleaners.asOptional.call(void 0, _cleaners.asUnknown),
+    error: _cleaners.asOptional.call(void 0, 
+      _cleaners.asEither.call(void 0, 
+        _cleaners.asObject.call(void 0, { message: _cleaners.asString }),
+        _cleaners.asObject.call(void 0, { connected: _cleaners.asString })
+      )
+    )
+  })
+)
+const asResponseDefault = (raw) => [
+  asResponseMessageDefault(raw)
+]
 
  function makeSocket(uri, config) {
   let socket
-  const { emitter, log, queueSize = 50, walletId } = config
+  const {
+    asResponse = asResponseDefault,
+    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 pendingRequests = {}
   let nextId = 0
   let lastKeepAlive = 0
   let lastWakeUp = 0
@@ -111,14 +152,14 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
     connected = false
     socket = null
     cancelConnect = false
-    for (const message of Object.values(pendingMessages)) {
+    for (const request of Object.values(pendingRequests)) {
       try {
-        message.task.deferred.reject(err)
+        request.task.deferred.reject(err)
       } catch (e) {
         log.error(e.message)
       }
     }
-    pendingMessages = {}
+    pendingRequests = {}
     try {
       emitter.emit(_SocketEmitter.SocketEvent.CONNECTION_CLOSE, uri, err)
     } catch (e) {
@@ -139,8 +180,8 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
     } catch (e) {
       handleError(e)
     }
-    for (const [id, message] of Object.entries(pendingMessages)) {
-      transmitMessage(id, message)
+    for (const [id, request] of Object.entries(pendingRequests)) {
+      transmitRequest(id, request)
     }
 
     wakeUp()
@@ -163,8 +204,8 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
     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)])
+      while (Object.keys(pendingRequests).length < queueSize) {
+        const task = await onQueueSpace(uri)
         if (task == null) break
         if (typeof task === 'boolean') {
           if (task) continue
@@ -192,12 +233,12 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
   // 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 request = { task, startTime: Date.now() }
+    pendingRequests[id] = request
+    transmitRequest(id, request)
   }
 
-  const transmitMessage = (id, pending) => {
+  const transmitRequest = (id, request) => {
     const now = Date.now()
     if (
       socket != null &&
@@ -205,13 +246,13 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
       connected &&
       !cancelConnect
     ) {
-      pending.startTime = now
+      request.startTime = now
       const message = {
         id,
-        method: pending.task.method,
-        params: _nullishCoalesce(pending.task.params, () => ( {}))
+        method: request.task.method,
+        params: _nullishCoalesce(request.task.params, () => ( {}))
       }
-      socket.send(JSON.stringify(message))
+      socket.send(JSON.stringify(message) + '\n')
     }
   }
 
@@ -229,14 +270,14 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
         .catch((e) => handleError(e))
     }
 
-    for (const [id, message] of Object.entries(pendingMessages)) {
-      if (message.startTime + timeout < now) {
+    for (const [id, request] of Object.entries(pendingRequests)) {
+      if (request.startTime + timeout < now) {
         try {
-          message.task.deferred.reject(new Error('Timeout'))
+          request.task.deferred.reject(new Error(`Timeout for request ${id}`))
         } catch (e) {
           log.error(e.message)
         }
-        _utils.removeItem.call(void 0, pendingMessages, id)
+        _utils.removeItem.call(void 0, pendingRequests, id)
       }
     }
     wakeUp()
@@ -246,8 +287,8 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
   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
+    for (const request of Object.values(pendingRequests)) {
+      const to = request.startTime + timeout
       if (to < nextWakeUp) nextWakeUp = to
     }
 
@@ -256,54 +297,67 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
     timer = setTimeout(() => onTimer(), delay)
   }
 
-  const onMessage = (messageJson) => {
+  const onMessage = (message) => {
     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) {
+      const response = asResponse(message)
+      for (const responseMessage of response) {
+        if (responseMessage.id != null) {
+          const id = responseMessage.id.toString()
+
+          // Handle subscription message
+          const subscription = subscriptions[id]
+          if (subscription != null) {
+            const cleanData = _cleaners.asMaybe.call(void 0, asSubscriptionAck)(responseMessage.data)
+            if (_optionalChain([cleanData, 'optionalAccess', _ => _.subscribed]) != null) {
               subscription.subscribed = true
-              subscription.deferred.resolve(json.data)
-              return
+              subscription.deferred.resolve(responseMessage.data)
+              continue
             }
             if (!subscription.subscribed) {
               subscription.deferred.reject()
             }
             try {
-              subscription.cb(subscription.cleaner(json.data))
+              subscription.cb(subscription.cleaner(responseMessage.data))
             } catch (error) {
-              console.log({ uri, error, json, subscription })
+              console.log({
+                uri,
+                error,
+                response: responseMessage,
+                subscription
+              })
               throw error
             }
-            return
+            continue
           }
-        }
-        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)
+
+          // Handle response message
+          const request = pendingRequests[id]
+          if (request != null) {
+            _utils.removeItem.call(void 0, pendingRequests, id)
+            const { error } = responseMessage
+            try {
+              if (error != null) {
+                const errorMessage =
+                  'message' in error ? error.message : error.connected
+                throw new Error(errorMessage)
+              }
+              if (request.task.cleaner != null) {
+                request.task.deferred.resolve(
+                  request.task.cleaner(responseMessage.data)
+                )
+              } else {
+                request.task.deferred.resolve(responseMessage.data)
+              }
+            } catch (error) {
+              console.log({ uri, error, response: responseMessage, request })
+              request.task.deferred.reject(error)
+            }
+            continue
           }
-        } catch (error) {
-          console.log({ uri, error, json, message })
-          message.task.deferred.reject(error)
+
+          throw new Error(
+            `Unknown message id from incoming ws message: ${message}`
+          )
         }
       }
     } catch (e) {
@@ -317,11 +371,11 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
   // return a Socket
   return {
     get readyState() {
-      return _nullishCoalesce(_optionalChain([socket, 'optionalAccess', _4 => _4.readyState]), () => ( _types3.ReadyState.CLOSED))
+      return _nullishCoalesce(_optionalChain([socket, 'optionalAccess', _2 => _2.readyState]), () => ( _types3.ReadyState.CLOSED))
     },
 
     async connect() {
-      _optionalChain([socket, 'optionalAccess', _5 => _5.disconnect, 'call', _6 => _6()])
+      _optionalChain([socket, 'optionalAccess', _3 => _3.disconnect, 'call', _4 => _4()])
 
       return await new Promise(resolve => {
         const cbs = {
@@ -337,7 +391,17 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
         }
 
         // Append "/websocket" if needed:
-        const fullUri = uri.replace(/\/websocket\/?$/, '') + '/websocket'
+        let fullUri = uri
+        if (uri.startsWith('wss:') || uri.startsWith('ws:')) {
+          fullUri = uri.replace(/\/websocket\/?$/, '') + '/websocket'
+        }
+        if (uri.startsWith('electrumwss:')) {
+          fullUri = uri.replace(/^electrumwss:/, 'wss:')
+        }
+        if (uri.startsWith('electrumws:')) {
+          fullUri = uri.replace(/^electrumws:/, 'ws:')
+        }
+
         try {
           socket = _windowWS.setupBrowser.call(void 0, fullUri, cbs)
         } catch (e2) {
@@ -347,13 +411,13 @@ const WAKE_UP_MS = 5000 // interval at which we wakeUp and potentially onQueueSp
     },
 
     disconnect() {
-      _optionalChain([socket, 'optionalAccess', _7 => _7.disconnect, 'call', _8 => _8()])
+      _optionalChain([socket, 'optionalAccess', _5 => _5.disconnect, 'call', _6 => _6()])
       socket = null
       disconnect()
     },
 
     isConnected() {
-      return _optionalChain([socket, 'optionalAccess', _9 => _9.readyState]) === _types3.ReadyState.OPEN
+      return _optionalChain([socket, 'optionalAccess', _7 => _7.readyState]) === _types3.ReadyState.OPEN
     },
 
     submitTask,

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

@@ -11,7 +11,6 @@
 
 var _cleaners = require('cleaners');
 
-
 /**
  * Websocket Task
  */
@@ -227,11 +226,11 @@ var _cleaners = require('cleaners');
  * Send Transaction
  */
  const broadcastTxMessage = (
-  transaction
+  signedTx
 ) => {
   return {
     method: 'sendTransaction',
-    params: { hex: transaction.signedTx },
+    params: { hex: signedTx },
     cleaner: exports.asBlockbookResponse.call(void 0, exports.asBroadcastTxResponse)
   }
 }; exports.broadcastTxMessage = broadcastTxMessage
@@ -279,9 +278,10 @@ var _cleaners = require('cleaners');
 
 
 
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
- const asAddressResponse = (asAddress = _cleaners.asString) =>
-  _cleaners.asObject.call(void 0, {
+ const asAddressResponse = (
+  asAddress = _cleaners.asString
+) =>
+  _cleaners.asObject({
     // details: basic
     address: asAddress,
     balance: _cleaners.asString,

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

@@ -0,0 +1,203 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _cleaners = require('cleaners');
+
+/**
+ * Websocket Task
+ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asElectrumUtxo = _cleaners.asObject.call(void 0, {
+  tx_pos: _cleaners.asNumber,
+  value: _cleaners.asNumber,
+  tx_hash: _cleaners.asString,
+  height: _cleaners.asNumber
+}); exports.asElectrumUtxo = asElectrumUtxo
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asElectrumTransaction = (
+  asAddress = _cleaners.asString
+) =>
+  _cleaners.asObject.call(void 0, {
+    blockhash: _cleaners.asString,
+    blocktime: _cleaners.asNumber,
+    confirmations: _cleaners.asNumber,
+    hash: _cleaners.asString,
+    hex: _cleaners.asString,
+    locktime: _cleaners.asNumber,
+    size: _cleaners.asNumber,
+    time: _cleaners.asNumber,
+    txid: _cleaners.asString,
+    version: _cleaners.asNumber,
+    vin: _cleaners.asArray.call(void 0, 
+      _cleaners.asObject.call(void 0, {
+        scriptSig: _cleaners.asObject.call(void 0, {
+          asm: _cleaners.asString,
+          hex: _cleaners.asString
+        }),
+        sequence: _cleaners.asNumber,
+        txid: _cleaners.asString,
+        vout: _cleaners.asNumber
+      })
+    ),
+    vout: _cleaners.asArray.call(void 0, 
+      _cleaners.asObject.call(void 0, {
+        n: _cleaners.asNumber,
+        scriptPubKey: _cleaners.asObject.call(void 0, {
+          addresses: _cleaners.asArray.call(void 0, asAddress),
+          asm: _cleaners.asString,
+          hex: _cleaners.asString,
+          reqSigs: _cleaners.asNumber,
+          type: _cleaners.asString
+        }),
+        value: _cleaners.asNumber
+      })
+    )
+  }); exports.asElectrumTransaction = asElectrumTransaction
+
+// ---------------------------------------------------------------------
+// Electrum API Response Types
+// ---------------------------------------------------------------------
+
+/**
+ * Error Response
+ */
+
+ const asElectrumErrorResponse = _cleaners.asObject.call(void 0, {
+  error: _cleaners.asObject.call(void 0, {
+    message: _cleaners.asString
+  })
+}); exports.asElectrumErrorResponse = asElectrumErrorResponse
+
+/**
+ * Electrum Response Generic
+ */
+
+ const asElectrumResponse = (asT) => raw => {
+  const errResponse = _cleaners.asMaybe.call(void 0, (0, exports.asElectrumErrorResponse))(raw)
+
+  if (errResponse != null)
+    throw new Error(`Electrum Error: ${errResponse.error.message}`)
+
+  return asT(raw)
+}; exports.asElectrumResponse = asElectrumResponse
+
+// ---------------------------------------------------------------------
+// Electrum API Messages
+// ---------------------------------------------------------------------
+
+/**
+ * Ping Message
+ */
+ const pingMessage = () => {
+  return {
+    method: 'server.ping',
+    params: undefined,
+    cleaner: exports.asElectrumResponse.call(void 0, exports.asPingResponse)
+  }
+}; exports.pingMessage = pingMessage
+
+ const asPingResponse = _cleaners.asMaybe.call(void 0, _cleaners.asUndefined); exports.asPingResponse = asPingResponse
+
+/**
+ * List Unspent (Get UTXOs)
+ */
+ const listUnspentMessage = (
+  scriptHash
+) => {
+  return {
+    method: 'blockchain.scripthash.listunspent',
+    params: [scriptHash],
+    cleaner: exports.asElectrumResponse.call(void 0, exports.asListUnspentResponse)
+  }
+}; exports.listUnspentMessage = listUnspentMessage
+
+ const asListUnspentResponse = _cleaners.asArray.call(void 0, 
+  exports.asElectrumUtxo
+); exports.asListUnspentResponse = asListUnspentResponse
+
+/**
+ * Get Address Transactions
+ */
+ const addressTransactionsMessage = (
+  scriptHash
+) => ({
+  method: 'blockchain.scripthash.get_history',
+  params: [scriptHash],
+  cleaner: exports.asElectrumResponse.call(void 0, exports.asAddressTransactionsResponse)
+}); exports.addressTransactionsMessage = addressTransactionsMessage
+
+
+
+ const asAddressTransactionsResponse = _cleaners.asArray.call(void 0, 
+  _cleaners.asObject.call(void 0, {
+    height: _cleaners.asNumber,
+    tx_hash: _cleaners.asString
+  })
+); exports.asAddressTransactionsResponse = asAddressTransactionsResponse
+
+/**
+ * Get Transaction
+ */
+ const transactionMessage = (
+  txHash,
+  asAddress = _cleaners.asString
+) => ({
+  method: 'blockchain.transaction.get',
+  params: [txHash, true],
+  cleaner: exports.asElectrumResponse.call(void 0, exports.asTransactionResponse.call(void 0, asAddress))
+}); exports.transactionMessage = transactionMessage
+
+ const asTransactionResponse = exports.asElectrumTransaction; exports.asTransactionResponse = asTransactionResponse

package/lib/{types.js → declare-modules.d.js}

@@ -5,3 +5,5 @@
 
 
 
+
+

package/lib/index.js

@@ -1,4 +1,4 @@
-"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; }
+"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 _CurrencyPlugin = require('./common/plugin/CurrencyPlugin');
 var _all = require('./common/utxobased/info/all');
@@ -10,10 +10,14 @@ for (const info of _all.all) {
     _CurrencyPlugin.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/react-native.js

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+var _reactnative = require('react-native');
+
+const { EdgeCurrencyPluginsModule } = _reactnative.NativeModules
+const { sourceUri } = EdgeCurrencyPluginsModule.getConstants()
+
+ const pluginUri = sourceUri; exports.pluginUri = pluginUri
+ const debugUri = 'http://localhost:8081/edge-currency-plugins.js'; exports.debugUri = debugUri
+
+
+
+
+
+
+
+
+
+ function makePluginIo(
+  options = {}
+) {
+  const { memletConfig } = options
+
+  return {
+    memletConfig
+  }
+} exports.makePluginIo = makePluginIo;

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

@@ -1,4 +1,3 @@
-export declare const IMAGE_SERVER_URL = "https://content.edge.app";
 export declare const INFO_SERVER_URI = "https://info1.edge.app";
 export declare const FEES_PATH = "fees.json";
 export declare const MAX_FEE = 999999999;

package/lib/src/common/utxobased/db/Processor.d.ts

@@ -13,7 +13,12 @@ interface FetchTransactionArgs {
     blockHeight?: number;
     blockHeightMax?: number;
     txId?: string;
-    options?: EdgeGetTransactionsOptions;
+    options?: EdgeGetTransactionsOptions & {
+        endDate?: Date;
+        startDate?: Date;
+        startEntries?: number;
+        startIndex?: number;
+    };
 }
 interface FetchUtxosArgs {
     utxoIds?: string[];

package/lib/src/common/utxobased/engine/ServerStates.d.ts

@@ -4,6 +4,7 @@ import { PluginState } from '../../plugin/PluginState';
 import { PluginInfo } from '../../plugin/types';
 import { SafeWalletInfo } from '../keymanager/cleaners';
 import { Blockbook } from '../network/Blockbook';
+import { AddressResponse, AddressUtxosResponse, BlockbookTransaction } from '../network/blockbookApi';
 import Deferred from '../network/Deferred';
 import { WsTask } from '../network/Socket';
 import { UtxoInitOptions } from './types';
@@ -37,6 +38,13 @@ export interface ServerStates {
     watchAddresses: (uri: string, addresses: string[], deferredAddressSub?: Deferred<unknown>) => void;
     watchBlocks: (uri: string) => void;
     getBlockHeight: (uri: string) => number;
+    addressQueryTask: (serverUri: string, address: string, params: {
+        lastQueriedBlockHeight: number;
+        page: number;
+    }, deferred: Deferred<AddressResponse>) => WsTask<AddressResponse>;
+    transactionQueryTask: (serverUri: string, txId: string, deferred: Deferred<BlockbookTransaction>) => WsTask<BlockbookTransaction>;
+    transactionSpecialQueryTask: (serverUri: string, txId: string, deferred: Deferred<unknown>) => WsTask<unknown>;
+    utxoListQueryTask: (serverUri: string, address: string, deferred: Deferred<AddressUtxosResponse>) => WsTask<AddressUtxosResponse>;
 }
 export declare function makeServerStates(config: ServerStateConfig): ServerStates;
 export {};

package/lib/src/common/utxobased/engine/UtxoEngineState.d.ts

@@ -114,8 +114,5 @@ interface TransactionChangedArgs {
     processor: Processor;
 }
 export declare const transactionChanged: (args: TransactionChangedArgs) => Promise<void>;
-interface NextTaskArgs extends CommonArgs {
-    uri: string;
-}
-export declare const pickNextTask: (args: NextTaskArgs) => Promise<WsTask<any> | undefined | boolean>;
+export declare const pickNextTask: (args: CommonArgs, serverUri: string) => Promise<WsTask<any> | undefined | boolean>;
 export {};