@polkadot/api/types#ApiOptions TypeScript Examples

getTestProvider = (urlOverwrite?: string, opts?: ApiOptions): TestProvider => {
  const url = urlOverwrite || process.env.ENDPOINT_URL || DEFAULT_URL;

  const provider = new TestProvider({
    provider: new WsProvider(url),
    ...opts
  });

  console.log(`test provider connected to ${url}`);

  return provider;
}

createApi = (endpoints: string | string[], apiOptions?: ApiOptions): ApiPromise => {
  const wsProvider = new WsProvider(endpoints);

  return new ApiPromise(
    createApiOptions({
      types: {
        ...TYPES,
        ...apiOptions?.types
      },
      provider: wsProvider,
      ...apiOptions
    })
  );
}

public async resetApi(selectedChain: ChainInfo, additionalOptions?): Promise<ApiPromise> {
    const provider = await this.createApiProvider(selectedChain.node);

    // note that we reuse the same provider and type registry to create both an rxjs
    // and a promise-based API -- this avoids creating multiple connections to the node
    const options: ApiOptions = {
      provider,
      ...additionalOptions,
    };
    this._api = await ApiPromise.create(options);
    return this._api;
  }

getProviderInfo = (chainNumber: string, types: ApiOptions['types']) => {
  const providedHasher = process.env[`REACT_APP_CHAIN_${chainNumber}_CUSTOM_HASHER`];
  const providerUrl = checkEnvVariable(`REACT_APP_CHAIN_${chainNumber}_SUBSTRATE_PROVIDER`);

  const hasher = (providedHasher && hashers && hashers[providedHasher]) || null;

  const polkadotjsUrl = createPolkadotJsUrl(types!, providerUrl);
  return {
    hasher,
    provider: new WsProvider(providerUrl),
    polkadotjsUrl,
    types
  };
}

/**
   *
   * @param _apiOptions
   * @param dataProvider
   */
  constructor(_apiOptions: ApiOptions, dataProvider?: AbstractDataProvider) {
    const apiOptions = options(_apiOptions);

    this.api = new ApiPromise(apiOptions);

    this.resolveApi = this.api.isReady;
    this._isProvider = true;

    this.dataProvider = dataProvider;
    this.scanner = new Scanner({
      wsProvider: apiOptions.provider as WsProvider,
      types: apiOptions.types,
      typesAlias: apiOptions.typesAlias,
      typesSpec: apiOptions.typesSpec,
      typesChain: apiOptions.typesChain,
      typesBundle: apiOptions.typesBundle
    });
  }

constructor(_apiOptions?: ApiOptions) {
    const provider = _apiOptions?.provider || new WsProvider('ws://127.0.0.1:9944');
    super({ provider, ..._apiOptions });
  }

defaultOptions: ApiOptions = {
  types: acalaTypes,
  rpc: acalaRpc
}

createApiOptions = ({
  types = {},
  rpc = {},
  typesAlias = {},
  typesBundle = {},
  signedExtensions,
  ...otherOptions
}: ApiOptions = {}): ApiOptions => ({
  types: {
    ...types
  },
  rpc: {
    ...acalaRpc,
    ...rpc
  },
  typesAlias: {
    ...acalaTypesAlias,
    ...typesAlias
  },
  typesBundle: {
    ...typesBundle,
    spec: {
      ...typesBundle.spec,
      acala: {
        ...acalaTypesBundle?.spec?.acala,
        ...typesBundle?.spec?.acala
      },
      mandala: {
        ...acalaTypesBundle?.spec?.mandala,
        ...typesBundle?.spec?.mandala
      },
      karura: {
        ...acalaTypesBundle?.spec?.karura,
        ...typesBundle?.spec?.mandala
      }
    }
  },
  signedExtensions: {
    ...acalaSignedExtensions,
    ...signedExtensions
  },
  ...otherOptions
})

static from(apiOptions: ApiOptions): SignerProvider {
    return new SignerProvider(apiOptions);
  }

constructor(apiOptions: ApiOptions) {
    super();
    const api = new ApiPromise(createApiOptions(apiOptions));
    this.setApi(api);
  }