1906564629

Build # 1906564629

Build Type

github

Committed by GitHub

Commit Message

Merge aacd3e1f4 into 2a93f5ca4

Pull Request Pull Request #63: Merge dev into master

Run Details

483 of 514 branches covered (93.97%)

Branch coverage included in aggregate %.

1633 of 1696 new or added lines in 27 files covered. (96.29%)

1 existing line in 1 file now uncovered.

13014 of 13109 relevant lines covered (99.28%)

34.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.07

/src/internal/minirpc.ts

import fetch from "isomorphic-fetch";
import type {ExternalProvider} from "@ethersproject/providers";

const JSONRPC_VERSION: string = "2.0";

export class RequestError extends Error {
    readonly code: number;
    readonly data: any;

    constructor(message: string, code: number, data: any) {
        super(message)
        this.code = code
        this.data = data
        this.name = this.constructor.name // dafuq
        this.message = message // dafuq message
    }
}

export interface JsonRpcRequest {
    method:  string,
    params?: Array<any>,
}

interface MiniRpcBatchRequest extends JsonRpcRequest {
    jsonrpc: string,
    id:      number,
}

interface MiniRpcBatchItem {
    request: MiniRpcBatchRequest;
    resolve: (value: unknown) => void;
    reject:  (reason?: any)   => void,
}

export class MiniRpcProvider implements ExternalProvider {
    readonly isMetaMask:      boolean;
    readonly chainId:         number;

    readonly url:             string;
    readonly parsedUrl:       URL;
    readonly host:            string;
    readonly path:            string;
    readonly batchWaitTimeMs: number;

    private _nextId:         number;
    private batchTimeoutId: NodeJS.Timeout;
    private batch:          MiniRpcBatchItem[];

    constructor(chainId: number, url: string, batchWaitTimeMs?: number) {
        this.isMetaMask = false;
        this._nextId = 1;
        this.batchTimeoutId = null;
        this.batch = [];

        this.chainId = chainId;
        this.url = url;
        const parsed = new URL(url);
        this.parsedUrl = parsed;
        this.host = parsed.host;
        this.path = parsed.pathname;

        // how long to wait to batch calls
        this.batchWaitTimeMs = batchWaitTimeMs ?? 50;
    }

    async request(request: JsonRpcRequest): Promise<any> {
        if (request.method === 'eth_chainId') {
            return `0x${this.chainId.toString(16)}`
        }

        let batchProm: Promise<any> = new Promise((resolve, reject) => {
            let req = {
                jsonrpc: JSONRPC_VERSION,
                id:      this._nextId++,
                method:  request.method,
                params:  request.params,
            };

            this.batch.push({
                request: req,
                resolve,
                reject,
            });

            return
        });

        this.batchTimeoutId = this.batchTimeoutId ?? setTimeout(() => this.clearBatch(), this.batchWaitTimeMs);

        return batchProm
    }

    async clearBatch() {
        const currentBatch = this.batch;

        this.batch = [];
        this.batchTimeoutId = null;

        const handleRpcResponse = (response: any): any => {
            if (!response.ok) {
                const err: RequestError = new RequestError(
                    response.statusText,
                    response.status,
                    null
                );

                this.rejectBatch(currentBatch, err);
                return null
            }

            return response
        }

        const rpcResponseProm: Promise<any> = this.fetchBatch(currentBatch)
            .then(handleRpcResponse)
            .catch(error => {
                let errStr = `Failed to send batch call: ${error}`;

                this.rejectBatch(
                    currentBatch,
                    errStr
                );

                // console.error(errStr);

                return null;
            })

        const loadJsonResponse = (resp: any): Promise<any> => resp === null ? null : resp.json()

        let rpcResponse: any;
        try {
            rpcResponse = await rpcResponseProm;
            if (rpcResponse === null) {
                return
            }
        } catch (e) {
            // console.error(e);
            return
        }

        const jsonResponseProm: Promise<any> = loadJsonResponse(rpcResponse)
            .then(d => d)
            .catch(error => {
                this.rejectBatch(
                    currentBatch,
                    `Failed to parse JSON response, error: ${error}`
                );

                return null
            })

        Promise.resolve(jsonResponseProm)
            .then(this.handleJsonResponse(currentBatch))
            .catch(() => {})
    }

    private fetchBatch(batch: MiniRpcBatchItem[]): Promise<any> {
        return fetch(this.url, {
            method: "POST",
            headers: {
                "content-type": "application/json",
                "accept":       "application/json"
            },
            body: JSON.stringify(batch.map(item => item.request))
        });
    }

    private rejectBatchItem(reason: any): (item: MiniRpcBatchItem) => void {
        return ({reject}) => reject(reason instanceof Error ? reason : new Error(reason));
    }

    private rejectBatch(batch: MiniRpcBatchItem[], reason: any): void {
        batch.forEach(this.rejectBatchItem(reason));
        return
    }

    private handleJsonResponse(batch: MiniRpcBatchItem[]): (json: any) => void {
        return (json: any): void => {
            if (json === null) {
                return
            }

            if (json?.error?.code === -32700) {
                console.error(`${this.chainId} RPC gave invalid response`)
                return
            }

            const byKey = batch.reduce((memo, current) => {
                memo[current.request.id] = current
                return memo
            }, {});

            for (const result of json) {
                const { resolve, reject, request: { method } } = byKey[result.id]

                if (resolve && reject) {
                    if ("error" in result) {
                        reject(result?.error)
                    } else if ("result" in result) {
                        resolve(result.result)
                    } else {
                        let err: RequestError = new RequestError(
                            `Received unexpected JSON-RPC response to ${method} request.`,
                            -32000,
                            result
                        );

                        reject(err);
                    }
                }
            }
        }
    }
}

1	import fetch from "isomorphic-fetch";	2✔
2	import type {ExternalProvider} from "@ethersproject/providers";	2✔
3		2✔
4	const JSONRPC_VERSION: string = "2.0";	2✔
5		2✔
6	export class RequestError extends Error {	2✔
7	readonly code: number;	2✔
8	readonly data: any;	2✔
9		2✔
10	constructor(message: string, code: number, data: any) {	2✔
NEW 11	super(message)	×
NEW 12	this.code = code	×
NEW 13	this.data = data	×
NEW 14	this.name = this.constructor.name // dafuq	×
NEW 15	this.message = message // dafuq message	×
NEW 16	}	×
17	}	2✔
18		2✔
19	export interface JsonRpcRequest {	2✔
20	method: string,	2✔
21	params?: Array<any>,	2✔
22	}	2✔
23		2✔
24	interface MiniRpcBatchRequest extends JsonRpcRequest {	2✔
25	jsonrpc: string,	2✔
26	id: number,	2✔
27	}	2✔
28		2✔
29	interface MiniRpcBatchItem {	2✔
30	request: MiniRpcBatchRequest;	2✔
31	resolve: (value: unknown) => void;	2✔
32	reject: (reason?: any) => void,	2✔
33	}	2✔
34		2✔
35	export class MiniRpcProvider implements ExternalProvider {	2✔
36	readonly isMetaMask: boolean;	2✔
37	readonly chainId: number;	196✔
38		196✔
39	readonly url: string;	196✔
40	readonly parsedUrl: URL;	196✔
41	readonly host: string;	196✔
42	readonly path: string;	196✔
43	readonly batchWaitTimeMs: number;	196✔
44		196✔
45	private _nextId: number;	196✔
46	private batchTimeoutId: NodeJS.Timeout;	196✔
47	private batch: MiniRpcBatchItem[];	2✔
48		2✔
49	constructor(chainId: number, url: string, batchWaitTimeMs?: number) {	2✔
50	this.isMetaMask = false;	196✔
51	this._nextId = 1;	196✔
52	this.batchTimeoutId = null;	196✔
53	this.batch = [];	196✔
54		196✔
55	this.chainId = chainId;	196✔
56	this.url = url;	196✔
57	const parsed = new URL(url);	196✔
58	this.parsedUrl = parsed;	196✔
59	this.host = parsed.host;	196✔
60	this.path = parsed.pathname;	196✔
61		196✔
62	// how long to wait to batch calls	196✔
63	this.batchWaitTimeMs = batchWaitTimeMs ?? 50;	196!
64	}	196✔
65		2✔
66	async request(request: JsonRpcRequest): Promise<any> {	2✔
67	if (request.method === 'eth_chainId') {	1,262✔
68	return `0x${this.chainId.toString(16)}`	686✔
69	}	686✔
70		1,262✔
71	let batchProm: Promise<any> = new Promise((resolve, reject) => {	1,262✔
72	let req = {	576✔
73	jsonrpc: JSONRPC_VERSION,	576✔
74	id: this._nextId++,	576✔
75	method: request.method,	576✔
76	params: request.params,	576✔
77	};	576✔
78		576✔
79	this.batch.push({	576✔
80	request: req,	576✔
81	resolve,	576✔
82	reject,	576✔
83	});	576✔
84		576✔
85	return	576✔
86	});	1,262✔
87		1,262✔
88	this.batchTimeoutId = this.batchTimeoutId ?? setTimeout(() => this.clearBatch(), this.batchWaitTimeMs);	1,262✔
89		1,262✔
90	return batchProm	1,262✔
91	}	1,262✔
92		2✔
93	async clearBatch() {	2✔
94	const currentBatch = this.batch;	486✔
95		486✔
96	this.batch = [];	486✔
97	this.batchTimeoutId = null;	486✔
98		486✔
99	const handleRpcResponse = (response: any): any => {	486✔
100	if (!response.ok) {	486!
NEW 101	const err: RequestError = new RequestError(	×
NEW 102	response.statusText,	×
NEW 103	response.status,	×
NEW 104	null	×
NEW 105	);	×
NEW 106		×
NEW 107	this.rejectBatch(currentBatch, err);	×
NEW 108	return null	×
NEW 109	}	×
110		486✔
111	return response	486✔
112	}	486✔
113		486✔
114	const rpcResponseProm: Promise<any> = this.fetchBatch(currentBatch)	486✔
115	.then(handleRpcResponse)	486✔
116	.catch(error => {	486✔
NEW 117	let errStr = `Failed to send batch call: ${error}`;	×
NEW 118		×
NEW 119	this.rejectBatch(	×
NEW 120	currentBatch,	×
NEW 121	errStr	×
NEW 122	);	×
NEW 123		×
NEW 124	// console.error(errStr);	×
NEW 125		×
NEW 126	return null;	×
127	})	486✔
128		486✔
129	const loadJsonResponse = (resp: any): Promise<any> => resp === null ? null : resp.json()	486!
130		486✔
131	let rpcResponse: any;	486✔
132	try {	486✔
133	rpcResponse = await rpcResponseProm;	486✔
134	if (rpcResponse === null) {	486!
NEW 135	return	×
NEW 136	}	×
137	} catch (e) {	486!
NEW 138	// console.error(e);	×
NEW 139	return	×
NEW 140	}	×
141		486✔
142	const jsonResponseProm: Promise<any> = loadJsonResponse(rpcResponse)	486✔
143	.then(d => d)	486✔
144	.catch(error => {	486✔
NEW 145	this.rejectBatch(	×
NEW 146	currentBatch,	×
NEW 147	`Failed to parse JSON response, error: ${error}`	×
NEW 148	);	×
NEW 149		×
NEW 150	return null	×
151	})	486✔
152		486✔
153	Promise.resolve(jsonResponseProm)	486✔
154	.then(this.handleJsonResponse(currentBatch))	486✔
155	.catch(() => {})	486✔
156	}	486✔
157		2✔
158	private fetchBatch(batch: MiniRpcBatchItem[]): Promise<any> {	2✔
159	return fetch(this.url, {	486✔
160	method: "POST",	486✔
161	headers: {	486✔
162	"content-type": "application/json",	486✔
163	"accept": "application/json"	486✔
164	},	486✔
165	body: JSON.stringify(batch.map(item => item.request))	486✔
166	});	486✔
167	}	486✔
168		2✔
169	private rejectBatchItem(reason: any): (item: MiniRpcBatchItem) => void {	2✔
NEW 170	return ({reject}) => reject(reason instanceof Error ? reason : new Error(reason));	×
NEW 171	}	×
172		2✔
173	private rejectBatch(batch: MiniRpcBatchItem[], reason: any): void {	2✔
NEW 174	batch.forEach(this.rejectBatchItem(reason));	×
NEW 175	return	×
NEW 176	}	×
177		2✔
178	private handleJsonResponse(batch: MiniRpcBatchItem[]): (json: any) => void {	2✔
179	return (json: any): void => {	486✔
180	if (json === null) {	486!
NEW 181	return	×
NEW 182	}	×
183		486✔
184	if (json?.error?.code === -32700) {	486!
NEW 185	console.error(`${this.chainId} RPC gave invalid response`)	×
NEW 186	return	×
NEW 187	}	×
188		486✔
189	const byKey = batch.reduce((memo, current) => {	486✔
190	memo[current.request.id] = current	576✔
191	return memo	576✔
192	}, {});	486✔
193		486✔
194	for (const result of json) {	486✔
195	const { resolve, reject, request: { method } } = byKey[result.id]	576✔
196		576✔
197	if (resolve && reject) {	576✔
198	if ("error" in result) {	576✔
199	reject(result?.error)	20✔
200	} else if ("result" in result) {	576✔
201	resolve(result.result)	556✔
202	} else {	556!
NEW 203	let err: RequestError = new RequestError(	×
NEW 204	`Received unexpected JSON-RPC response to ${method} request.`,	×
NEW 205	-32000,	×
NEW 206	result	×
NEW 207	);	×
NEW 208		×
NEW 209	reject(err);	×
NEW 210	}	×
211	}	576✔
212	}	576✔
213	}	486✔
214	}	486✔
215	}	2✔

synapsecns / sdk / 1906564629

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous