web3-core#AbstractProvider TypeScript Examples

/**
   * Sign a message with `personal_sign`.
   */
  protected async ethSignPersonalInternal(
    signer: string,
    message: string,
  ): Promise<string> {
    let provider = this.web3.currentProvider;
    if (provider === null) {
      throw new Error('Cannot sign since Web3 currentProvider is null');
    }
    if (typeof provider === 'string') {
      throw new Error('Cannot sign since Web3 currentProvider is a string');
    }
    provider = provider as AbstractProvider;

    const sendAsync: (param: JsonRpcPayload) => Promise<JsonRpcResponse> = (
      promisify(provider.sendAsync || provider.send).bind(provider)
    );
    const rpcMethod = 'personal_sign';

    const response = await sendAsync({
      method: rpcMethod,
      params: [signer, message],
      jsonrpc: '2.0',
      id: Date.now(),
    });

    if (response.error) {
      throw new Error((response.error as unknown as { message: string }).message);
    }
    // Note: Using createTypedSignature() fixes the signature `v` value.
    return createTypedSignature(response.result, SignatureTypes.PERSONAL);
  }

protected async ethSignTypedDataInternal(
    signer: string,
    data: {},
    signingMethod: SigningMethod,
  ): Promise<string> {
    let rpcMethod: string;
    let rpcData: {};

    let provider = this.web3.currentProvider;
    if (provider === null) {
      throw new Error('Cannot sign since Web3 currentProvider is null');
    }
    if (typeof provider === 'string') {
      throw new Error('Cannot sign since Web3 currentProvider is a string');
    }
    provider = provider as AbstractProvider;

    let sendAsync: (param: JsonRpcPayload) => Promise<JsonRpcResponse>;

    switch (signingMethod) {
      case SigningMethod.TypedData:
        sendAsync = promisify(provider.send!).bind(provider);
        rpcMethod = 'eth_signTypedData';
        rpcData = data;
        break;
      case SigningMethod.MetaMask:
        sendAsync = promisify(provider.sendAsync).bind(provider);
        rpcMethod = 'eth_signTypedData_v3';
        rpcData = JSON.stringify(data);
        break;
      case SigningMethod.MetaMaskLatest:
        sendAsync = promisify(provider.sendAsync).bind(provider);
        rpcMethod = 'eth_signTypedData_v4';
        rpcData = JSON.stringify(data);
        break;
      case SigningMethod.CoinbaseWallet:
        sendAsync = promisify(provider.sendAsync).bind(provider);
        rpcMethod = 'eth_signTypedData_v4';
        rpcData = data;
        break;
      default:
        throw new Error(`Invalid signing method ${signingMethod}`);
    }

    const response = await sendAsync({
      method: rpcMethod,
      params: [signer, rpcData],
      jsonrpc: '2.0',
      id: Date.now(),
    });

    if (response.error) {
      throw new Error((response.error as unknown as { message: string }).message);
    }
    return `0x${stripHexPrefix(response.result)}0${SignatureTypes.NO_PREPEND}`;
  }

// Concurrency: 1
export class EssentialsWeb3Provider implements AbstractProvider {
    constructor(private rpcApiUrl: string) {
    }

    private callJsonRPC(payload): Promise<any> {
        // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor
        return callJsonRPCQueue.add(() => {
            return new Promise((resolve, reject) => {
                var request = new XMLHttpRequest();

                request.open('POST', this.rpcApiUrl, true);
                request.setRequestHeader('Content-Type', 'application/json');
                request.timeout = 5000;

                request.onreadystatechange = function () {
                    if (request.readyState === 4 && request.timeout !== 1) {
                        var result = request.responseText;

                        try {
                            //Logger.log("global", "Ethereum JSON RPC call result:", result, "for payload:", payload);
                            result = JSON.parse(result);
                            resolve(result);
                        } catch (e) {
                            Logger.error("global", "Ethereum response: JSON parse error");
                            reject("Invalid JSON response returned by the JSON RPC: " + e);
                        }
                    }
                };

                request.ontimeout = function () {
                    reject("Timeout");
                };

                request.onerror = function (error) {
                    console.error("RPC call error");
                    reject(error);
                }

                try {
                    request.send(JSON.stringify(payload));
                } catch (error) {
                    reject("Connection error");
                }
            });
        });
    }

    // Mandatory method: sendAsync()
    async sendAsync(payload: JsonRpcPayload, callback: (error: Error, result?: JsonRpcResponse) => void) {
        //Logger.log("global", "Essentials Web3 provider sendAsync payload", payload);
        switch (payload.method) {
            // All methods not handled above are sent through JSON RPC API to the user-defined node url.
            default:
                try {
                    let result = await this.callJsonRPC(payload);
                    callback(null, result);
                }
                catch (e) {
                    Logger.error("global", "callJsonRPC catched");
                    callback(e);
                }
        }
    }
}

getEIP712Signer =
    (version?: string) =>
        async (txArgs): Promise<string> => {
            const web3 = getWeb3()
            const typedData = await generateTypedDataFrom(txArgs)

            let method = 'eth_signTypedData_v3'
            if (version === 'v4') {
                method = 'eth_signTypedData_v4'
            }
            if (!version) {
                method = 'eth_signTypedData'
            }

            const jsonTypedData = JSON.stringify(typedData)
            const signedTypedData = {
                jsonrpc: '2.0',
                method,
                params: version === 'v3' || version === 'v4' ? [txArgs.sender, jsonTypedData] : [jsonTypedData, txArgs.sender],
                from: txArgs.sender,
                id: new Date().getTime(),
            }

            return new Promise((resolve, reject) => {
                const provider = web3.currentProvider as AbstractProvider
                provider.sendAsync(signedTypedData, (err, signature) => {
                    if (err) {
                        reject(err)
                        return
                    }

                    if (signature?.result == null) {
                        reject(new Error(EIP712_NOT_SUPPORTED_ERROR_MSG))
                        return
                    }

                    const sig = adjustV('eth_signTypedData', signature.result)

                    resolve(sig.replace(EMPTY_DATA, ''))
                })
            })
        }

/**
   * Contains a Web3-compliant provider. Pass this module to your Web3/Ethers
   * instance for automatic compatibility with Ethereum methods.
   */
  public readonly rpcProvider: RPCProviderModule & AbstractProvider;