How to use the web3-provider-engine 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() {

// BUG: This never finds window.web3, and thus always falls back to localStorage keys
      this.web3 = new Web3(window.web3.currentProvider);
    } else {
      var privateKey = options.privateKey || localStorage.getItem("localPrivateKey");
      if(!privateKey) {
        privateKey = Wallet.generate().getPrivateKeyString().slice(2);
        if(localStorage) {
        localStorage.setItem("localPrivateKey", privateKey)}
      }
      // This uses web3-provider-engine and ethereumjs-wallet to construct a
      // wallet in-browser, without needing Metamask, Toshi, etc.
      //
      // Note that the current version of ethereumjs-wallet on npm has a bug,
      // but the latest on Github works just fine.
      var wallet = Wallet.fromPrivateKey(new Buffer(privateKey, "hex"));
      this.engine = new ProviderEngine();
      this.web3 = new Web3(this.engine);
      console.log(this.web3)
      // static results
      this.engine.addProvider(new FixtureSubprovider({
        web3_clientVersion: 'ProviderEngine/v0.0.0/javascript',
        net_listening: true,
        eth_hashrate: '0x00',
        eth_mining: false,
        eth_syncing: true,
      }))

      // filters
      this.engine.addProvider(new FilterSubprovider())

      // id mgmt
      this.engine.addProvider(new WalletSubprovider(wallet, {}))

} else if (props.connectionType === 'inject') {
      // set up the injected web3 object in the event that it indeed exists
      if (typeof window.web3 !== 'undefined' &&
          typeof window.web3.currentProvider !== 'undefined') {
        // TODO: how can we support a ledger AND the current provider?
        console.log('found existing web3 provider, initializing...')
        this.web3 = new Web3(window.web3.currentProvider)

        // TODO: can we detect if the current provider is websocket-enabled?
        console.log(`attempting to connect event listener to websocket provider at ${infura}...`)
        this.wsWeb3 = new Web3(new Web3.providers.WebsocketProvider(infura))
      }
    } else if (props.connectionType === 'ledger') {
      // connect to the ledger via u2f, then add infura subprovider & websocket
      console.log('attempting to connect to ledger...')
      const engine = new ProviderEngine()
      const getTransport = () => TransportU2F.create(1000, 2000)
      const ledger = createLedgerSubprovider(getTransport, {
        networkId,
        accountsLength: config.ledgerAccountsLength,
        accountsOffset: config.ledgerAccountsOffset
      })
      engine.addProvider(ledger)

      console.log(`attempting to connect to provider at ${infura}...`)
      let infuraWsProvider = new WebsocketSubprovider({ rpcUrl: infura })
      /* these commands don't work, need to monitor websocket connection health

      infuraWsProvider.on('start', e => console.error('WS start:', e))
      infuraWsProvider.on('error', e => console.error('WS error:', e))
      infuraWsProvider.on('end', e => console.error('WS end:', e))

async function initializeStore() {
  let store; // Declare the eventual store so it can be closed over by getState.
  const keystoreSubprovider = new identity.keystore.KeystoreSubprovider({
    getState: () => store.getState().keystore,
  });
  const signingProvider = new ProviderEngine();
  signingProvider.addProvider(keystoreSubprovider);
  signingProvider.addProvider(new Web3Subprovider(httpProvider));
  signingProvider.start();

  const identitySubprovider = new identity.IdentitySubprovider({
    getState: () => store.getState().identity,
  });
  const identityProvider = new ProviderEngine();
  identityProvider.addProvider(identitySubprovider);
  identityProvider.addProvider(new Web3Subprovider(httpProvider));
  identityProvider.start();

  const initialIdentityState = {
    identities: [],
    signingProvider,
  };

async connect(account: LedgerAccount) {
    const selectedAddress = account.address
    const path = this.calculatePath(this.selectedPath, this.accounts.indexOf(account))
    const networkId = Number(this.state.ethereum.networkId)
    const rpcUrl = this.state.ethereum.endpoint
    const engine = new ProviderEngine()
    const transport = await this.transport()
    const ledger = createLedgerSubprovider(
      () => transport, {
        networkId,
        accountsLength: 1,
        path,
      })

    ledger.signMessage = ledger.signPersonalMessage
    engine.addProvider(ledger)
    engine.addProvider(
      // new RpcSubprovider({ rpcUrl }),
      new FetchSubprovider({
        rpcUrl,
      }),
    )

async switchToLedgerWallet(accountsOffset = 0, accountsQuantity = 6) {
		const engine = new ProviderEngine();
		this.getLedgerTransport = () => HWTransportNodeHid.create();
		const ledger = Web3SubProvider(this.getLedgerTransport, {
			networkId: CONFIG.chainId,
			accountsLength: accountsQuantity,
			accountsOffset: accountsOffset
		});
		const subscriptionSubprovider = new SubscriptionSubprovider();
		subscriptionSubprovider.on('data', (err, notification) => {
			engine.emit('data', err, notification);
		});

		engine.addProvider(ledger);
		engine.addProvider(subscriptionSubprovider);
		engine.addProvider(new FetchSubprovider({ rpcUrl: SELECTED_SERVER_URL }));
		engine.start();

const getCachedInstance = (network, wallet = null) => {
    const key = network.unique() + (wallet ? wallet.getAccounts()[0] : '');
    if(cachedInstances.hasOwnProperty(key)) return cachedInstances[key];
    else {
        const engine = new ProviderEngine();
        const web3 = new Web3(engine);
        if(wallet) engine.addProvider(new HookedWalletSubprovider(wallet));

        const rpcUrl = network.host === 'ethnodes.get-scatter.com' ? 'https://commonly-classic-katydid.quiknode.io/d0bf98e7-a866-43d4-ac71-2397fd1b3aba/dQsznyrZRg2dr4DQJNPDgw==/' : network.fullhost();
        engine.addProvider(new RpcSubprovider({rpcUrl}));
        engine.start();
        cachedInstances[key] = [web3, engine];
        return cachedInstances[key];
    }
}

return new Promise(async (resolve, reject) => {
    const engine = new ProviderEngine()
    const getTransport = () => TransportU2F.create()
    const ledger = createLedgerSubprovider(getTransport, {
      networkId: 1,
      accountsLength: 5,
    })

    ledger.getAccounts = () => ["123"]

    ledger.signMessage = ledger.signPersonalMessage
    engine.addProvider(ledger)
    engine.addProvider(
      new FetchSubprovider({
        rpcUrl: "https://mainnet.infura.io/5Ic91y0T9nLh6qUg33K0",
      }),
    )
    engine.start()

return new Promise(async (resolve, reject) => {
    const engine = new ProviderEngine()
    const getTransport = () => TransportU2F.create()
    const ledger = createLedgerSubprovider(getTransport, {
      networkId: 1,
      accountsLength: 10,
      path,
    })
    const accounts = ledger.getAccounts((err, val) => {
      if (err) reject(err)
      resolve(val)
    })
  })
}

public async activate(): Promise {
    if (!this.provider) {
      const { default: TrezorConnect } = await import('trezor-connect')
      TrezorConnect.manifest({
        email: this.manifestEmail,
        appUrl: this.manifestAppUrl
      })
      const engine = new Web3ProviderEngine({ pollingInterval: this.pollingInterval })
      engine.addProvider(new TrezorSubprovider({ trezorConnectClientApi: TrezorConnect, ...this.config }))
      engine.addProvider(new RPCSubprovider(this.url, this.requestTimeoutMs))
      this.provider = engine
    }

    this.provider.start()

    return { provider: this.provider, chainId: this.chainId }
  }