Function providerFromEngine

src/jrpc/jrpcEngine.ts:468–511

(engine: JRPCEngine)

 * @deprecated Use {@link providerFromEngineV2} instead.
 */
export function providerFromEngine(engine: JRPCEngine): SafeEventEmitterProvider {
  const provider: SafeEventEmitterProvider = new SafeEventEmitter<ProviderEvents>() as SafeEventEmitterProvider;
  // handle both rpc send methods
  provider.sendAsync = async <T extends JRPCParams, U>(req: JRPCRequest<T>) => {
    const res = await engine.handle(req);
    if (res.error) {
      if (typeof res.error === "object" && Object.keys(res.error).includes("stack") === false) res.error.stack = "Stack trace is not available.";
      log.error(res.error);
      const err = serializeJrpcError(res.error, {
        fallbackError: constructFallbackError(res.error),
        shouldIncludeStack: true,
      });

      const errorCode = err?.code ?? errorCodes.rpc.internal;
      const error = new JsonRpcError(errorCode, err?.message ?? getMessageFromCode(errorCode), err?.data);
      throw error;
    }
    return res.result as U;
  };

  provider.send = <T extends JRPCParams, U>(req: JRPCRequest<T>, callback: (error: unknown, providerRes: JRPCResponse<U>) => void) => {
    if (typeof callback !== "function") {
      throw new Error('Must provide callback to "send" method.');
    }
    engine.handle(req as JRPCRequest<JRPCParams>, callback);
  };
  // forward notifications
  if (engine.on) {
    engine.on("notification", (message) => {
      provider.emit("data", null, message);
    });
  }

  provider.request = async <T extends JRPCParams, U>(args: RequestArguments<T>) => {
    const req: JRPCRequest<JRPCParams> = {
      ...args,
      id: Math.random().toString(36).slice(2),
      jsonrpc: "2.0",
    };
    const res = await provider.sendAsync(req);
    return res as U;
  };
  return provider;
}

/**
 * @deprecated Use {@link providerFromMiddlewareV2} instead.