How to use the web3-provider-engine/subproviders/hooked-wallet function in web3-provider-engine

throw makeError(
          "Invalid networkId signature returned. Expected: " +
            networkId +
            ", Got: " +
            signedChainId,
          "InvalidNetworkId"
        );
      }

      return `0x${tx.serialize().toString("hex")}`;
    } finally {
      transport.close();
    }
  }

  const subprovider = new HookedWalletSubprovider({
    getAccounts: callback => {
      getAccounts()
        .then(res => callback(null, Object.values(res)))
        .catch(err => callback(err, null));
    },
    signPersonalMessage: (txData, callback) => {
      signPersonalMessage(txData)
        .then(res => callback(null, res))
        .catch(err => callback(err, null));
    },
    signTransaction: (txData, callback) => {
      signTransaction(txData)
        .then(res => callback(null, res))
        .catch(err => callback(err, null));
    }
  });

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)
          }
        },
        processMessage: async (msgParams, cb) => {
          try {
            const wc = await this.getWalletConnector()

return (_network, _web3, _prefix) => {
            network = Network.fromJson(_network);
            if(!network.isValid()) throw Error.noNetwork();
            const rpcUrl = `${_prefix}://${network.hostport()}`;

            const engine = new ProviderEngine();
            web3 = new _web3(engine);

            const walletSubprovider = new HookedWalletSubprovider(new ScatterEthereumWallet());
            engine.addProvider(walletSubprovider);

            if(_prefix.indexOf('http') !== -1) engine.addProvider(new RpcSubprovider({rpcUrl}));
            else engine.addProvider(new WebsocketSubprovider({rpcUrl}));

            engine.start();

            return web3;

            //

        }
    }

return (_network, _web3) => {
            ethNetwork = Network.fromJson(_network);

            const rpcUrl = `${ethNetwork.fullhost()}`;

            const engine = new ProviderEngine();
            const web3 = new _web3(engine);

            const walletSubprovider = new HookedWalletSubprovider(new ScatterEthereumWallet());
            engine.addProvider(walletSubprovider);

            if(ethNetwork.protocol.indexOf('http') > -1) engine.addProvider(new RpcSubprovider({rpcUrl}));
            else engine.addProvider(new WebsocketSubprovider({rpcUrl}));

            engine.start();

            return web3;
        }
    }

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];
    }
}

this.addresses.push(address);
          this.wallets[address] = wallet;
        }
      }
    };

    const privateKeys = normalizePrivateKeys(mnemonic);

    if (!privateKeys) checkBIP39Mnemonic(mnemonic as string);
    else ethUtilValidation(privateKeys);

    const tmp_accounts = this.addresses;
    const tmp_wallets = this.wallets;

    this.engine.addProvider(
      new HookedSubprovider({
        getAccounts(cb: any) {
          cb(null, tmp_accounts);
        },
        getPrivateKey(address: string, cb: any) {
          if (!tmp_wallets[address]) {
            return cb("Account not found");
          } else {
            cb(null, tmp_wallets[address].getPrivateKey().toString("hex"));
          }
        },
        signTransaction(txParams: any, cb: any) {
          let pkey;
          const from = txParams.from.toLowerCase();
          if (tmp_wallets[from]) {
            pkey = tmp_wallets[from].getPrivateKey();
          } else {