@web3auth/no-modal/dist/lib.cjs/providers/base-provider/commonPrivateKeyProvider.js

Multi chain wallet aggregator for web3Auth

'use strict';

var _defineProperty = require('@babel/runtime/helpers/defineProperty');
var auth = require('@web3auth/auth');
var baseProvider = require('./baseProvider.js');

var _CommonPrivateKeyProvider;
class CommonPrivateKeyProvider extends baseProvider.BaseProvider {
  constructor({
    config,
    state
  }) {
    super({
      config,
      state
    });
    // should be Assigned in setupProvider
    _defineProperty(this, "_providerEngineProxy", null);
  }
  get provider() {
    return this._providerEngineProxy;
  }
  set provider(_) {
    throw new Error("Method not implemented.");
  }
  async setupProvider(privKey) {
    const privKeyMiddleware = this.getPrivKeyMiddleware(privKey);
    const engine = new auth.JRPCEngine();
    engine.push(privKeyMiddleware);
    const provider = auth.providerFromEngine(engine);
    this.updateProviderEngineProxy(provider);
  }
  async switchChain(_) {
    return Promise.resolve();
  }
  getProviderEngineProxy() {
    return this._providerEngineProxy;
  }
  async lookupNetwork() {
    return Promise.resolve("");
  }
  getPrivKeyMiddleware(privKey) {
    const middleware = {
      getPrivatekey: async () => {
        if (!this.config.keyExportEnabled) throw new Error("Exporting private key is disabled. Please enable it in the provider config");
        return privKey;
      }
    };
    return this.createPrivKeyMiddleware(middleware);
  }
  createPrivKeyMiddleware({
    getPrivatekey
  }) {
    async function getPrivatekeyHandler(_, res) {
      try {
        res.result = await getPrivatekey();
      } catch (error) {
        res.error = error instanceof Error ? error.message : error;
      }
    }
    return auth.createScaffoldMiddleware({
      private_key: auth.createAsyncMiddleware(getPrivatekeyHandler)
    });
  }
}
_CommonPrivateKeyProvider = CommonPrivateKeyProvider;
_defineProperty(CommonPrivateKeyProvider, "getProviderInstance", async params => {
  const providerFactory = new _CommonPrivateKeyProvider({
    config: {
      chain: params.chain,
      chains: params.chains
    }
  });
  await providerFactory.setupProvider(params.privKey);
  return providerFactory;
});

exports.CommonPrivateKeyProvider = CommonPrivateKeyProvider;