@moonsong-labs/moonwall-cli/dist/chunk-75ODDMN6.js

Testing framework for the Moon family of projects

// src/internal/providers.ts
import { rpcDefinitions, types } from "moonbeam-types-bundle";
import { ApiPromise, WsProvider } from "@polkadot/api";
import { Web3 } from "web3";
import { WebSocketProvider as Web3ProviderWs } from "web3-providers-ws";
import { ethers, Wallet } from "ethers";
import Debug from "debug";
import chalk from "chalk";
import { ALITH_PRIVATE_KEY } from "@moonsong-labs/moonwall-util";
var debug = Debug("global:providers");
function prepareProviders(providerConfigs) {
  return providerConfigs.map(({ name, endpoints, type }) => {
    const url = endpoints.includes("ENV_VAR") ? process.env.WSS_URL : endpoints[0];
    switch (type) {
      case "polkadotJs":
        debug(`\u{1F7E2}  PolkadotJs provider ${name} details prepared`);
        return {
          name,
          type,
          connect: async () => {
            const api = await ApiPromise.create({
              provider: new WsProvider(url),
              initWasm: false,
              noInitWarn: true
            });
            await api.isReady;
            return api;
          },
          ws: () => new WsProvider(url)
        };
      case "moon":
        debug(`\u{1F7E2}  Moonbeam provider ${name} details prepared`);
        return {
          name,
          type,
          connect: async () => {
            const moonApi = await ApiPromise.create({
              provider: new WsProvider(url),
              rpc: rpcDefinitions,
              typesBundle: types,
              noInitWarn: true
            });
            await moonApi.isReady;
            return moonApi;
          },
          ws: () => new WsProvider(url)
        };
      case "web3":
        debug(`\u{1F7E2}  Web3 provider ${name} details prepared`);
        return {
          name,
          type,
          connect: () => {
            const provider = new Web3ProviderWs(
              url,
              {},
              { delay: 50, autoReconnect: false, maxAttempts: 10 }
            );
            provider.on("error", () => {
              throw new Error(
                `Cannot connect to Web3 provider ${chalk.bgWhiteBright.blackBright(url)}`
              );
            });
            return new Web3(provider);
          }
        };
      case "ethers":
        debug(`\u{1F7E2}  Ethers provider ${name} details prepared`);
        return {
          name,
          type,
          connect: () => {
            const provider = new ethers.WebSocketProvider(url);
            return new Wallet(ALITH_PRIVATE_KEY, provider);
          }
        };
      default:
        return {
          name,
          type,
          connect: () => console.log(`\u{1F6A7}  provider ${name} not yet implemented`)
        };
    }
  });
}
async function populateProviderInterface(name, type, connect) {
  switch (type) {
    case "polkadotJs":
      const pjsApi = await connect();
      return {
        name,
        api: pjsApi,
        type,
        greet: () => {
          debug(
            `\u{1F44B}  Provider ${name} is connected to chain ${pjsApi.consts.system.version.specName.toString()} RT${pjsApi.consts.system.version.specVersion.toNumber()}`
          );
          return {
            rtVersion: pjsApi.consts.system.version.specVersion.toNumber(),
            rtName: pjsApi.consts.system.version.specName.toString()
          };
        },
        disconnect: async () => pjsApi.disconnect()
      };
    case "moon":
      const mbApi = await connect();
      return {
        name,
        api: mbApi,
        type,
        greet: () => {
          debug(
            `\u{1F44B}  Provider ${name} is connected to chain ${mbApi.consts.system.version.specName.toString()} RT${mbApi.consts.system.version.specVersion.toNumber()}`
          );
          return {
            rtVersion: mbApi.consts.system.version.specVersion.toNumber(),
            rtName: mbApi.consts.system.version.specName.toString()
          };
        },
        disconnect: async () => mbApi.disconnect()
      };
    case "ethers":
      const ethApi = await connect();
      return {
        name,
        api: ethApi,
        type,
        greet: async () => debug(
          `\u{1F44B}  Provider ${name} is connected to chain ` + (await ethApi.provider.getNetwork()).chainId
        ),
        disconnect: async () => {
          ethApi.provider.destroy();
        }
      };
    case "web3":
      const web3Api = await connect();
      return {
        name,
        api: web3Api,
        type,
        greet: async () => console.log(
          `\u{1F44B} Provider ${name} is connected to chain ` + await web3Api.eth.getChainId()
        ),
        disconnect: async () => {
          web3Api.currentProvider.disconnect();
        }
      };
    default:
      throw new Error("UNKNOWN TYPE");
  }
}

export {
  prepareProviders,
  populateProviderInterface
};