How to use the web3-provider-engine/subproviders/nonce-tracker function in web3-provider-engine

init(cb) {
    if (this.initialized) { return cb(); }
    this.initialized = true;
    this.opts.serialized = fs.readFileSync(this.opts.keystore).toString();
    this.opts.ks = Lightwallet.keystore.deserialize(this.opts.serialized);
    // this.opts.addresses = this.opts.ks.getAddresses().map(a => `0x${a}`);
    this.opts.addresses = this.opts.ks.getAddresses().map(a => a); // removed prefix 0x
    // pass opts
    const { pollingInterval } = this.opts;
    this.engine = new ProviderEngine({ pollingInterval });
    this.engine.addProvider(new FilterProvider());
    this.engine.addProvider(new NonceSubprovider());
    this.engine.addProvider(new LighwalletSubprovider(this.opts));
    this.engine.addProvider(new RpcSubprovider(this.opts));
    // this.engine._fetchLatestBlock();
    this.engine.start();
    if (this.opts.prefund) {
      console.log(`Ensuring all lightwallet accounts have ${this.opts.prefund / 1e18} Ether`);
      return prefund(this.opts).then(cb);
    }
    return cb();
  }
  send() {

import NonceSubProvider from "web3-provider-engine/subproviders/nonce-tracker";
import HookedSubprovider from "web3-provider-engine/subproviders/hooked-wallet";
import ProviderSubprovider from "web3-provider-engine/subproviders/provider";
import Url from "url";
import Web3 from "web3";
import { JSONRPCRequestPayload, JSONRPCErrorCallback } from "ethereum-protocol";
import { Callback, JsonRPCResponse } from "web3/providers";

// Important: do not use debug module. Reason: https://github.com/trufflesuite/truffle/issues/2374#issuecomment-536109086

// This line shares nonce state across multiple provider instances. Necessary
// because within truffle the wallet is repeatedly newed if it's declared in the config within a
// function, resetting nonce from tx to tx. An instance can opt out
// of this behavior by passing `shareNonce=false` to the constructor.
// See issue #65 for more
const singletonNonceSubProvider = new NonceSubProvider();

class HDWalletProvider {
  private hdwallet?: EthereumHDKey;
  private walletHdpath: string;
  private wallets: { [address: string]: ethJSWallet };
  private addresses: string[];

  public engine: ProviderEngine;

  constructor(
    mnemonic: string | string[],
    provider: string | any,
    addressIndex: number = 0,
    numAddresses: number = 10,
    shareNonce: boolean = true,
    walletHdpath: string = `m/44'/60'/0'/0/`

}
          let pkey = tmp_wallets[from].getPrivateKey();
          const dataBuff = EthUtil.toBuffer(dataIfExists);
          const msgHashBuff = EthUtil.hashPersonalMessage(dataBuff);
          const sig = EthUtil.ecsign(msgHashBuff, pkey);
          const rpcSig = EthUtil.toRpcSig(sig.v, sig.r, sig.s);
          cb(null, rpcSig);
        },
        signPersonalMessage(...args: any[]) {
          this.signMessage(...args);
        }
      })
    );

    !shareNonce
      ? this.engine.addProvider(new NonceSubProvider())
      : this.engine.addProvider(singletonNonceSubProvider);

    this.engine.addProvider(new FiltersSubprovider());
    if (typeof provider === "string") {
      // shim Web3 to give it expected sendAsync method. Needed if web3-engine-provider upgraded!
      // Web3.providers.HttpProvider.prototype.sendAsync =
      // Web3.providers.HttpProvider.prototype.send;
      this.engine.addProvider(
        new ProviderSubprovider(
          // @ts-ignore
          new Web3.providers.HttpProvider(provider, { keepAlive: false })
        )
      );
    } else {
      this.engine.addProvider(new ProviderSubprovider(provider));
    }

export function configureEngine(engine, config) {
  let supportsSubscribe = websocketRegex.test(config.rpcUrl)
  normaliseConfig(config)
  if (config.debug) engine.addProvider(new LoggingSubprovider())
  if (config.useHacks) {
    var syncCacheProvider = new SyncCacheSubprovider({cache: config.cache || window.localStorage, lastChanged: config.lastChanged})
    engine.addProvider(syncCacheProvider)
    syncCacheProvider.patchSend(engine)
  }
  engine.addProvider(new DefaultFixture({ web3_clientVersion: `SpaceSuit/${version}/javascript` }))
  engine.addProvider(new DefaultBlockParameterSubprovider())
  engine.addProvider(new NonceTrackerSubprovider())
  engine.addProvider(new SanitizingSubprovider())
  engine.addProvider(new CacheSubprovider())
  if (supportsSubscribe) {
    engine.addProvider(new FilterSubprovider({ pendingBlockTimeout: 5000 }))
  } else {
    let subscriptionSubprovider = new SubscriptionSubprovider({ pendingBlockTimeout: 5000 })
    subscriptionSubprovider.on('data', (err, notification) => {
      engine.emit('data', err, notification)
    })
    engine.addProvider(subscriptionSubprovider)
  }
  engine.addProvider(new InflightCacheSubprovider())
  if (config.useHacks) engine.addProvider(new LowerCaseAddressesSubprovider())
  if (config.useHacks) engine.addProvider(new GasPaddingSubprovider())
  engine.addProvider(new SignToPersonalSignSubprovider({ stripPrefix: config.useHacks }))
  engine.addProvider(new MinMaxGasPriceSubprovider({ minGasPrice: config.minGasPrice, maxGasPrice: config.maxGasPrice }))

new FixtureSubprovider({
        eth_hashrate: '0x00',
        eth_mining: false,
        eth_syncing: true,
        net_listening: true,
        web3_clientVersion: `WalletConnect/v${pkg.version}/javascript`
      })
    )

    this.addProvider(new CacheSubprovider())

    this.addProvider(new SubscriptionsSubprovider())

    this.addProvider(new FilterSubprovider())

    this.addProvider(new NonceSubprovider())

    this.addProvider(
      new HookedWalletSubprovider({
        getAccounts: async cb => {
          try {
            const wc = await this.getWalletConnector()
            const accounts = wc.accounts
            if (accounts && accounts.length) {
              cb(null, accounts)
            } else {
              cb(new Error('Failed to get accounts'))
            }
          } catch (error) {
            cb(error)
          }
        },