1913716963

Build # 1913716963

Build Type

github

Committed by GitHub

Commit Message

Merge 9ec1283e4 into 2a93f5ca4

Pull Request Pull Request #63: Merge dev into master

Run Details

477 of 498 branches covered (95.78%)

Branch coverage included in aggregate %.

1636 of 1656 new or added lines in 29 files covered. (98.79%)

1 existing line in 1 file now uncovered.

13000 of 13052 relevant lines covered (99.6%)

33.5 hits per line

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

92.31

/src/internal/minirpc.ts

import {fetchJson} from "@ethersproject/web";
import type {ExternalProvider} from "@ethersproject/providers";

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
    }
}

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

interface JsonRPCRequest extends RPCRequest {
    jsonrpc: "2.0",
    id:      number,
}

interface BatchItem {
    request: JsonRPCRequest;
    resolve: (result:  any) => void;
    reject:  (reason?: any) => void,
}

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

    private _url:             string;
    private _host:            string;
    private _path:            string;

    protected _batchInterval: number;

    private _nextId:          number         = 1;
    private _batchAggregator: NodeJS.Timeout = null;
    private _pendingBatch:    BatchItem[]    = null;

    constructor(chainId: number, url: string, batchWaitTimeMs: number=50) {
        this.chainId = chainId;

        const parsed = new URL(url);
        this._url  = parsed.toString();
        this._host = parsed.host;
        this._path = parsed.pathname;

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

    /**
     * Amount of time, in milliseconds, between batch RPC calls
     */
    get batchInterval(): number {
        return this._batchInterval
    }

    /**
     * Sets the provider's interval for sending batch RPC calls.
     * @param interval amount of time in milliseconds the provider will wait between sending batch RPC calls
     * @internal
     */
    set batchInterval(interval: number) {
        this._batchInterval = interval;
    }

    get url(): string {
        return this._url
    }

    /**
     * @internal
     */
    set url(newUrl: string | URL) {
        const parsed = newUrl instanceof URL ? newUrl : new URL(newUrl);
        this._host = parsed.host;
        this._path = parsed.pathname;
        this._url  = parsed.toString();
    }

    get host(): string {
        return this._host
    }

    get path(): string {
        return this._path
    }

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

        if (this._pendingBatch === null) {
            this._pendingBatch = [];
        }

        const batchItem: BatchItem = {
            request: {
                jsonrpc: "2.0",
                id:     (this._nextId++),
                ...request
            },
            resolve: null,
            reject:  null,
        };

        const prom: Promise<any> = new Promise((resolve, reject) => {
            batchItem.resolve = resolve;
            batchItem.reject  = reject;
        });

        this._pendingBatch.push(batchItem);

        if (!this._batchAggregator) {
            setTimeout(() => this._processBatch(), this._batchInterval);
        }

        return prom
    }

    private async _processBatch() {
        const currentBatch = this._pendingBatch;

        this._pendingBatch    = null;
        this._batchAggregator = null;

        const requests: JsonRPCRequest[] = currentBatch.map(req => req.request);

        return fetchJson(this._url, JSON.stringify(requests))
            .then(result =>
                currentBatch.forEach((req, idx) => {
                    const payload = result[idx];
                    if (payload.error) {
                        const {message, code, data} = payload.error;
                        req.reject(new RequestError(message, code, data));
                    } else {
                        req.resolve(payload.result);
                    }
                })
            )
            .catch(error => currentBatch.forEach(batchItem => batchItem.reject(error)))
    }
}

1	import {fetchJson} from "@ethersproject/web";	2✔
2	import type {ExternalProvider} from "@ethersproject/providers";	2✔
3		2✔
4	export class RequestError extends Error {	2✔
5	readonly code: number;	2✔
6	readonly data: any;	2✔
7		2✔
8	constructor(message: string, code: number, data: any) {	2✔
9	super(message)	20✔
10	this.code = code	20✔
11	this.data = data	20✔
12	this.name = this.constructor.name // dafuq	20✔
13	this.message = message // dafuq message	20✔
14	}	20✔
15	}	2✔
16		2✔
17	interface RPCRequest {	2✔
18	method: string,	2✔
19	params?: Array<any>,	2✔
20	}	2✔
21		2✔
22	interface JsonRPCRequest extends RPCRequest {	2✔
23	jsonrpc: "2.0",	2✔
24	id: number,	2✔
25	}	2✔
26		2✔
27	interface BatchItem {	2✔
28	request: JsonRPCRequest;	2✔
29	resolve: (result: any) => void;	2✔
30	reject: (reason?: any) => void,	2✔
31	}	2✔
32		2✔
33	export class MiniRpcProvider implements ExternalProvider {	2✔
34	readonly isMetaMask: boolean = false;	2✔
35	readonly chainId: number;	172✔
36		172✔
37	private _url: string;	172✔
38	private _host: string;	172✔
39	private _path: string;	172✔
40		172✔
41	protected _batchInterval: number;	172✔
42		172✔
43	private _nextId: number = 1;	172✔
44	private _batchAggregator: NodeJS.Timeout = null;	172✔
45	private _pendingBatch: BatchItem[] = null;	2✔
46		2✔
47	constructor(chainId: number, url: string, batchWaitTimeMs: number=50) {	2✔
48	this.chainId = chainId;	172✔
49		172✔
50	const parsed = new URL(url);	172✔
51	this._url = parsed.toString();	172✔
52	this._host = parsed.host;	172✔
53	this._path = parsed.pathname;	172✔
54		172✔
55	// how long to wait to batch calls	172✔
56	this._batchInterval = batchWaitTimeMs;	172✔
57	}	172✔
58		2✔
59	/**	2✔
60	* Amount of time, in milliseconds, between batch RPC calls	2✔
61	*/	2✔
62	get batchInterval(): number {	2✔
NEW 63	return this._batchInterval	×
NEW 64	}	×
65		2✔
66	/**	2✔
67	* Sets the provider's interval for sending batch RPC calls.	2✔
68	* @param interval amount of time in milliseconds the provider will wait between sending batch RPC calls	2✔
69	* @internal	2✔
70	*/	2✔
71	set batchInterval(interval: number) {	2✔
NEW 72	this._batchInterval = interval;	×
NEW 73	}	×
74		2✔
75	get url(): string {	2✔
NEW 76	return this._url	×
NEW 77	}	×
78		2✔
79	/**	2✔
80	* @internal	2✔
81	*/	2✔
82	set url(newUrl: string \| URL) {	2✔
NEW 83	const parsed = newUrl instanceof URL ? newUrl : new URL(newUrl);	×
NEW 84	this._host = parsed.host;	×
NEW 85	this._path = parsed.pathname;	×
NEW 86	this._url = parsed.toString();	×
NEW 87	}	×
88		2✔
89	get host(): string {	2✔
90	return this._host	172✔
91	}	172✔
92		2✔
93	get path(): string {	2✔
NEW 94	return this._path	×
NEW 95	}	×
96		2✔
97	async request(request: RPCRequest): Promise<any> {	2✔
98	if (request.method === 'eth_chainId') {	1,236✔
99	return `0x${this.chainId.toString(16)}`	660✔
100	}	660✔
101		1,236✔
102	if (this._pendingBatch === null) {	1,236✔
103	this._pendingBatch = [];	486✔
104	}	486✔
105		576✔
106	const batchItem: BatchItem = {	576✔
107	request: {	576✔
108	jsonrpc: "2.0",	576✔
109	id: (this._nextId++),	576✔
110	...request	576✔
111	},	576✔
112	resolve: null,	576✔
113	reject: null,	576✔
114	};	576✔
115		576✔
116	const prom: Promise<any> = new Promise((resolve, reject) => {	576✔
117	batchItem.resolve = resolve;	576✔
118	batchItem.reject = reject;	576✔
119	});	576✔
120		576✔
121	this._pendingBatch.push(batchItem);	576✔
122		576✔
123	if (!this._batchAggregator) {	576✔
124	setTimeout(() => this._processBatch(), this._batchInterval);	576✔
125	}	576✔
126		576✔
127	return prom	576✔
128	}	576✔
129		2✔
130	private async _processBatch() {	2✔
131	const currentBatch = this._pendingBatch;	576✔
132		576✔
133	this._pendingBatch = null;	576✔
134	this._batchAggregator = null;	576✔
135		576✔
136	const requests: JsonRPCRequest[] = currentBatch.map(req => req.request);	576✔
137		576✔
138	return fetchJson(this._url, JSON.stringify(requests))	576✔
139	.then(result =>	576✔
140	currentBatch.forEach((req, idx) => {	486✔
141	const payload = result[idx];	576✔
142	if (payload.error) {	576✔
143	const {message, code, data} = payload.error;	20✔
144	req.reject(new RequestError(message, code, data));	20✔
145	} else {	576✔
146	req.resolve(payload.result);	556✔
147	}	556✔
148	})	486✔
149	)	576✔
150	.catch(error => currentBatch.forEach(batchItem => batchItem.reject(error)))	576✔
151	}	576✔
152	}	2✔

synapsecns / sdk / 1913716963

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