Skip to content

Commit cd5f0fe

Browse files
ricmooricmoo
committedOct 9, 2023
Merge branch 'v5.8-progress'
·
v6.13.5v6.8.0
2 parents 9a4b753 + 0c9c23b commit cd5f0fe

File tree

6 files changed

+246
-134
lines changed

6 files changed

+246
-134
lines changed
 

‎package.json

+5-5
Original file line numberDiff line numberDiff line change
@@ -9,9 +9,9 @@
99
"./lib.esm/wordlists/wordlists.js": "./lib.esm/wordlists/wordlists-browser.js"
1010
},
1111
"dependencies": {
12-
"@adraffy/ens-normalize": "1.9.2",
13-
"@noble/hashes": "1.1.2",
14-
"@noble/secp256k1": "1.7.1",
12+
"@adraffy/ens-normalize": "1.9.4",
13+
"@noble/curves": "1.2.0",
14+
"@noble/hashes": "1.3.2",
1515
"@types/node": "18.15.13",
1616
"aes-js": "4.0.0-beta.5",
1717
"tslib": "2.4.0",
@@ -93,7 +93,7 @@
9393
"url": "https://www.buymeacoffee.com/ricmoo"
9494
}
9595
],
96-
"gitHead": "7d4173049edc3b4ff2de1971c3ecca3b08588651",
96+
"gitHead": "9541f2f70cd7f5c6f3caf93f5a3d5e34eae5281a",
9797
"homepage": "https://ethers.org",
9898
"keywords": [
9999
"ethereum",
@@ -131,5 +131,5 @@
131131
"test-esm": "mocha --reporter ./reporter.cjs ./lib.esm/_tests/test-*.js"
132132
},
133133
"sideEffects": false,
134-
"version": "6.7.1"
134+
"version": "6.8.0"
135135
}

‎src.ts/crypto/signing-key.ts

+16-24
Original file line numberDiff line numberDiff line change
@@ -4,28 +4,20 @@
44
* @_subsection: api/crypto:Signing [about-signing]
55
*/
66

7-
import * as secp256k1 from "@noble/secp256k1";
7+
import { secp256k1 } from "@noble/curves/secp256k1";
88

99
import {
1010
concat, dataLength, getBytes, getBytesCopy, hexlify, toBeHex,
1111
assertArgument
1212
} from "../utils/index.js";
1313

14-
import { computeHmac } from "./hmac.js";
1514
import { Signature } from "./signature.js";
1615

1716
import type { BytesLike } from "../utils/index.js";
1817

1918
import type { SignatureLike } from "./index.js";
2019

2120

22-
//const N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
23-
24-
// Make noble-secp256k1 sync
25-
secp256k1.utils.hmacSha256Sync = function(key: Uint8Array, ...messages: Array<Uint8Array>): Uint8Array {
26-
return getBytes(computeHmac("sha256", key, concat(messages)));
27-
}
28-
2921
/**
3022
* A **SigningKey** provides high-level access to the elliptic curve
3123
* cryptography (ECC) operations and key management.
@@ -69,16 +61,14 @@ export class SigningKey {
6961
sign(digest: BytesLike): Signature {
7062
assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
7163

72-
const [ sigDer, recid ] = secp256k1.signSync(getBytesCopy(digest), getBytesCopy(this.#privateKey), {
73-
recovered: true,
74-
canonical: true
64+
const sig = secp256k1.sign(getBytesCopy(digest), getBytesCopy(this.#privateKey), {
65+
lowS: true
7566
});
7667

77-
const sig = secp256k1.Signature.fromHex(sigDer);
7868
return Signature.from({
79-
r: toBeHex("0x" + sig.r.toString(16), 32),
80-
s: toBeHex("0x" + sig.s.toString(16), 32),
81-
v: (recid ? 0x1c: 0x1b)
69+
r: toBeHex(sig.r, 32),
70+
s: toBeHex(sig.s, 32),
71+
v: (sig.recovery ? 0x1c: 0x1b)
8272
});
8373
}
8474

@@ -106,7 +96,7 @@ export class SigningKey {
10696
*/
10797
computeSharedSecret(other: BytesLike): string {
10898
const pubKey = SigningKey.computePublicKey(other);
109-
return hexlify(secp256k1.getSharedSecret(getBytesCopy(this.#privateKey), getBytes(pubKey)));
99+
return hexlify(secp256k1.getSharedSecret(getBytesCopy(this.#privateKey), getBytes(pubKey), false));
110100
}
111101

112102
/**
@@ -151,7 +141,7 @@ export class SigningKey {
151141
bytes = pub;
152142
}
153143

154-
const point = secp256k1.Point.fromHex(bytes);
144+
const point = secp256k1.ProjectivePoint.fromHex(bytes);
155145
return hexlify(point.toRawBytes(compressed));
156146
}
157147

@@ -177,12 +167,14 @@ export class SigningKey {
177167
assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
178168

179169
const sig = Signature.from(signature);
180-
const der = secp256k1.Signature.fromCompact(getBytesCopy(concat([ sig.r, sig.s ]))).toDERRawBytes();
181170

182-
const pubKey = secp256k1.recoverPublicKey(getBytesCopy(digest), der, sig.yParity);
183-
assertArgument(pubKey != null, "invalid signature for digest", "signature", signature);
171+
let secpSig = secp256k1.Signature.fromCompact(getBytesCopy(concat([ sig.r, sig.s ])));
172+
secpSig = secpSig.addRecoveryBit(sig.yParity);
173+
174+
const pubKey = secpSig.recoverPublicKey(getBytesCopy(digest));
175+
assertArgument(pubKey != null, "invalid signautre for digest", "signature", signature);
184176

185-
return hexlify(pubKey);
177+
return "0x" + pubKey.toHex(false);
186178
}
187179

188180
/**
@@ -196,8 +188,8 @@ export class SigningKey {
196188
* addresses from parent public keys and chain codes.
197189
*/
198190
static addPoints(p0: BytesLike, p1: BytesLike, compressed?: boolean): string {
199-
const pub0 = secp256k1.Point.fromHex(SigningKey.computePublicKey(p0).substring(2));
200-
const pub1 = secp256k1.Point.fromHex(SigningKey.computePublicKey(p1).substring(2));
191+
const pub0 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p0).substring(2));
192+
const pub1 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p1).substring(2));
201193
return "0x" + pub0.add(pub1).toHex(!!compressed)
202194
}
203195
}

‎src.ts/providers/default-provider.ts

+43
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,49 @@ function isWebSocketLike(value: any): value is WebSocketLike {
2525

2626
const Testnets = "goerli kovan sepolia classicKotti optimism-goerli arbitrum-goerli matic-mumbai bnbt".split(" ");
2727

28+
/**
29+
* Returns a default provider for %%network%%.
30+
*
31+
* If %%network%% is a [[WebSocketLike]] or string that begins with
32+
* ``"ws:"`` or ``"wss:"``, a [[WebSocketProvider]] is returned backed
33+
* by that WebSocket or URL.
34+
*
35+
* If %%network%% is a string that begins with ``"HTTP:"`` or ``"HTTPS:"``,
36+
* a [[JsonRpcProvider]] is returned connected to that URL.
37+
*
38+
* Otherwise, a default provider is created backed by well-known public
39+
* Web3 backends (such as [[link-infura]]) using community-provided API
40+
* keys.
41+
*
42+
* The %%options%% allows specifying custom API keys per backend (setting
43+
* an API key to ``"-"`` will omit that provider) and ``options.exclusive``
44+
* can be set to either a backend name or and array of backend names, which
45+
* will whitelist **only** those backends.
46+
*
47+
* Current backend strings supported are:
48+
* - ``"alchemy"``
49+
* - ``"ankr"``
50+
* - ``"cloudflare"``
51+
* - ``"etherscan"``
52+
* - ``"infura"``
53+
* - ``"publicPolygon"``
54+
* - ``"quicknode"``
55+
*
56+
* @example:
57+
* // Connect to a local Geth node
58+
* provider = getDefaultProvider("http://localhost:8545/");
59+
*
60+
* // Connect to Ethereum mainnet with any current and future
61+
* // third-party services available
62+
* provider = getDefaultProvider("mainnet");
63+
*
64+
* // Connect to Polygoin, but only allow Etherscan and
65+
* // INFURA and use "MY_API_KEY" in calls to Etherscan.
66+
* provider = getDefaultProvider("matic", {
67+
* etherscan: "MY_API_KEY",
68+
* exclusive: [ "etherscan", "infura" ]
69+
* });
70+
*/
2871
export function getDefaultProvider(network: string | Networkish | WebSocketLike, options?: any): AbstractProvider {
2972
if (options == null) { options = { }; }
3073

‎src.ts/utils/fetch.ts

+47-4
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ import { assert, assertArgument } from "./errors.js";
2323
import { defineProperties } from "./properties.js";
2424
import { toUtf8Bytes, toUtf8String } from "./utf8.js"
2525

26-
import { getUrl } from "./geturl.js";
26+
import { createGetUrl } from "./geturl.js";
2727

2828
/**
2929
* An environments implementation of ``getUrl`` must return this type.
@@ -77,7 +77,7 @@ const MAX_ATTEMPTS = 12;
7777
const SLOT_INTERVAL = 250;
7878

7979
// The global FetchGetUrlFunc implementation.
80-
let getUrlFunc: FetchGetUrlFunc = getUrl;
80+
let defaultGetUrlFunc: FetchGetUrlFunc = createGetUrl();
8181

8282
const reData = new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i");
8383
const reIpfs = new RegExp("^ipfs:/\/(ipfs/)?(.*)$", "i");
@@ -201,6 +201,8 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
201201

202202
#throttle: Required<FetchThrottleParams>;
203203

204+
#getUrlFunc: null | FetchGetUrlFunc;
205+
204206
/**
205207
* The fetch URI to requrest.
206208
*/
@@ -429,6 +431,28 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
429431
this.#retry = retry;
430432
}
431433

434+
/**
435+
* This function is called to fetch content from HTTP and
436+
* HTTPS URLs and is platform specific (e.g. nodejs vs
437+
* browsers).
438+
*
439+
* This is by default the currently registered global getUrl
440+
* function, which can be changed using [[registerGetUrl]].
441+
* If this has been set, setting is to ``null`` will cause
442+
* this FetchRequest (and any future clones) to revert back to
443+
* using the currently registered global getUrl function.
444+
*
445+
* Setting this is generally not necessary, but may be useful
446+
* for developers that wish to intercept requests or to
447+
* configurege a proxy or other agent.
448+
*/
449+
get getUrlFunc(): FetchGetUrlFunc {
450+
return this.#getUrlFunc || defaultGetUrlFunc;
451+
}
452+
set getUrlFunc(value: null | FetchGetUrlFunc) {
453+
this.#getUrlFunc = value;
454+
}
455+
432456
/**
433457
* Create a new FetchRequest instance with default values.
434458
*
@@ -448,6 +472,8 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
448472
slotInterval: SLOT_INTERVAL,
449473
maxAttempts: MAX_ATTEMPTS
450474
};
475+
476+
this.#getUrlFunc = null;
451477
}
452478

453479
toString(): string {
@@ -510,7 +536,7 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
510536
// We have a preflight function; update the request
511537
if (this.preflightFunc) { req = await this.preflightFunc(req); }
512538

513-
const resp = await getUrlFunc(req, checkSignal(_request.#signal));
539+
const resp = await this.getUrlFunc(req, checkSignal(_request.#signal));
514540
let response = new FetchResponse(resp.statusCode, resp.statusMessage, resp.headers, resp.body, _request);
515541

516542
if (response.statusCode === 301 || response.statusCode === 302) {
@@ -641,6 +667,8 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
641667
clone.#process = this.#process;
642668
clone.#retry = this.#retry;
643669

670+
clone.#getUrlFunc = this.#getUrlFunc;
671+
644672
return clone;
645673
}
646674

@@ -686,7 +714,22 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
686714
*/
687715
static registerGetUrl(getUrl: FetchGetUrlFunc): void {
688716
if (locked) { throw new Error("gateways locked"); }
689-
getUrlFunc = getUrl;
717+
defaultGetUrlFunc = getUrl;
718+
}
719+
720+
/**
721+
* Creates a getUrl function that fetches content from HTTP and
722+
* HTTPS URLs.
723+
*
724+
* The available %%options%% are dependent on the platform
725+
* implementation of the default getUrl function.
726+
*
727+
* This is not generally something that is needed, but is useful
728+
* when trying to customize simple behaviour when fetching HTTP
729+
* content.
730+
*/
731+
static createGetUrlFunc(options?: Record<string, any>): FetchGetUrlFunc {
732+
return createGetUrl(options);
690733
}
691734

692735
/**

‎src.ts/utils/geturl-browser.ts

+52-38
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
import { assert } from "./errors.js";
22

3-
import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js";
3+
import type {
4+
FetchGetUrlFunc, FetchRequest, FetchCancelSignal, GetUrlResponse
5+
} from "./fetch.js";
46

57

68
declare global {
@@ -27,46 +29,58 @@ declare global {
2729

2830
// @TODO: timeout is completely ignored; start a Promise.any with a reject?
2931

30-
export async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
31-
const protocol = req.url.split(":")[0].toLowerCase();
32-
33-
assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
34-
info: { protocol },
35-
operation: "request"
36-
});
37-
38-
assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
39-
operation: "request"
40-
});
41-
42-
let signal: undefined | AbortSignal = undefined;
43-
if (_signal) {
44-
const controller = new AbortController();
45-
signal = controller.signal;
46-
_signal.addListener(() => { controller.abort(); });
32+
export function createGetUrl(options?: Record<string, any>): FetchGetUrlFunc {
33+
34+
async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
35+
const protocol = req.url.split(":")[0].toLowerCase();
36+
37+
assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
38+
info: { protocol },
39+
operation: "request"
40+
});
41+
42+
assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
43+
operation: "request"
44+
});
45+
46+
let signal: undefined | AbortSignal = undefined;
47+
if (_signal) {
48+
const controller = new AbortController();
49+
signal = controller.signal;
50+
_signal.addListener(() => { controller.abort(); });
51+
}
52+
53+
const init = {
54+
method: req.method,
55+
headers: new Headers(Array.from(req)),
56+
body: req.body || undefined,
57+
signal
58+
};
59+
60+
const resp = await fetch(req.url, init);
61+
62+
const headers: Record<string, string> = { };
63+
resp.headers.forEach((value, key) => {
64+
headers[key.toLowerCase()] = value;
65+
});
66+
67+
const respBody = await resp.arrayBuffer();
68+
const body = (respBody == null) ? null: new Uint8Array(respBody);
69+
70+
return {
71+
statusCode: resp.status,
72+
statusMessage: resp.statusText,
73+
headers, body
74+
};
4775
}
4876

49-
const init = {
50-
method: req.method,
51-
headers: new Headers(Array.from(req)),
52-
body: req.body || undefined,
53-
signal
54-
};
55-
56-
const resp = await fetch(req.url, init);
57-
58-
const headers: Record<string, string> = { };
59-
resp.headers.forEach((value, key) => {
60-
headers[key.toLowerCase()] = value;
61-
});
77+
return getUrl;
78+
}
6279

63-
const respBody = await resp.arrayBuffer();
64-
const body = (respBody == null) ? null: new Uint8Array(respBody);
80+
// @TODO: remove in v7; provided for backwards compat
81+
const defaultGetUrl: FetchGetUrlFunc = createGetUrl({ });
6582

66-
return {
67-
statusCode: resp.status,
68-
statusMessage: resp.statusText,
69-
headers, body
70-
};
83+
export async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
84+
return defaultGetUrl(req, _signal);
7185
}
7286

‎src.ts/utils/geturl.ts

+83-63
Original file line numberDiff line numberDiff line change
@@ -5,92 +5,112 @@ import { gunzipSync } from "zlib";
55
import { assert } from "./errors.js";
66
import { getBytes } from "./data.js";
77

8-
import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js";
8+
import type {
9+
FetchGetUrlFunc, FetchRequest, FetchCancelSignal, GetUrlResponse
10+
} from "./fetch.js";
911

1012
/**
1113
* @_ignore:
1214
*/
13-
export async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
15+
export function createGetUrl(options?: Record<string, any>): FetchGetUrlFunc {
1416

15-
const protocol = req.url.split(":")[0].toLowerCase();
17+
async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
1618

17-
assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
18-
info: { protocol },
19-
operation: "request"
20-
});
19+
const protocol = req.url.split(":")[0].toLowerCase();
2120

22-
assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
23-
operation: "request"
24-
});
21+
assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
22+
info: { protocol },
23+
operation: "request"
24+
});
2525

26-
const method = req.method;
27-
const headers = Object.assign({ }, req.headers);
26+
assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
27+
operation: "request"
28+
});
2829

29-
const options: any = { method, headers };
30+
const method = req.method;
31+
const headers = Object.assign({ }, req.headers);
3032

31-
const request = ((protocol === "http") ? http: https).request(req.url, options);
33+
const reqOptions: any = { method, headers };
34+
if (options) {
35+
if (options.agent) { reqOptions.agent = options.agent; }
36+
}
3237

33-
request.setTimeout(req.timeout);
38+
const request = ((protocol === "http") ? http: https).request(req.url, reqOptions);
3439

35-
const body = req.body;
36-
if (body) { request.write(Buffer.from(body)); }
40+
request.setTimeout(req.timeout);
3741

38-
request.end();
42+
const body = req.body;
43+
if (body) { request.write(Buffer.from(body)); }
3944

40-
return new Promise((resolve, reject) => {
41-
// @TODO: Node 15 added AbortSignal; once we drop support for
42-
// Node14, we can add that in here too
45+
request.end();
4346

44-
request.once("response", (resp: http.IncomingMessage) => {
45-
const statusCode = resp.statusCode || 0;
46-
const statusMessage = resp.statusMessage || "";
47-
const headers = Object.keys(resp.headers || {}).reduce((accum, name) => {
48-
let value = resp.headers[name] || "";
49-
if (Array.isArray(value)) {
50-
value = value.join(", ");
51-
}
52-
accum[name] = value;
53-
return accum;
54-
}, <{ [ name: string ]: string }>{ });
47+
return new Promise((resolve, reject) => {
48+
// @TODO: Node 15 added AbortSignal; once we drop support for
49+
// Node14, we can add that in here too
5550

56-
let body: null | Uint8Array = null;
57-
//resp.setEncoding("utf8");
51+
request.once("response", (resp: http.IncomingMessage) => {
52+
const statusCode = resp.statusCode || 0;
53+
const statusMessage = resp.statusMessage || "";
54+
const headers = Object.keys(resp.headers || {}).reduce((accum, name) => {
55+
let value = resp.headers[name] || "";
56+
if (Array.isArray(value)) {
57+
value = value.join(", ");
58+
}
59+
accum[name] = value;
60+
return accum;
61+
}, <{ [ name: string ]: string }>{ });
62+
63+
let body: null | Uint8Array = null;
64+
//resp.setEncoding("utf8");
65+
66+
resp.on("data", (chunk: Uint8Array) => {
67+
if (signal) {
68+
try {
69+
signal.checkSignal();
70+
} catch (error) {
71+
return reject(error);
72+
}
73+
}
5874

59-
resp.on("data", (chunk: Uint8Array) => {
60-
if (signal) {
61-
try {
62-
signal.checkSignal();
63-
} catch (error) {
64-
return reject(error);
75+
if (body == null) {
76+
body = chunk;
77+
} else {
78+
const newBody = new Uint8Array(body.length + chunk.length);
79+
newBody.set(body, 0);
80+
newBody.set(chunk, body.length);
81+
body = newBody;
6582
}
66-
}
67-
68-
if (body == null) {
69-
body = chunk;
70-
} else {
71-
const newBody = new Uint8Array(body.length + chunk.length);
72-
newBody.set(body, 0);
73-
newBody.set(chunk, body.length);
74-
body = newBody;
75-
}
76-
});
83+
});
7784

78-
resp.on("end", () => {
79-
if (headers["content-encoding"] === "gzip" && body) {
80-
body = getBytes(gunzipSync(body));
81-
}
85+
resp.on("end", () => {
86+
if (headers["content-encoding"] === "gzip" && body) {
87+
body = getBytes(gunzipSync(body));
88+
}
8289

83-
resolve({ statusCode, statusMessage, headers, body });
84-
});
90+
resolve({ statusCode, statusMessage, headers, body });
91+
});
8592

86-
resp.on("error", (error) => {
87-
//@TODO: Should this just return nornal response with a server error?
88-
(<any>error).response = { statusCode, statusMessage, headers, body };
89-
reject(error);
93+
resp.on("error", (error) => {
94+
//@TODO: Should this just return nornal response with a server error?
95+
(<any>error).response = { statusCode, statusMessage, headers, body };
96+
reject(error);
97+
});
9098
});
99+
100+
request.on("error", (error) => { reject(error); });
91101
});
102+
}
103+
104+
return getUrl;
105+
}
106+
107+
// @TODO: remove in v7; provided for backwards compat
108+
const defaultGetUrl: FetchGetUrlFunc = createGetUrl({ });
92109

93-
request.on("error", (error) => { reject(error); });
94-
});
110+
/**
111+
* @_ignore:
112+
*/
113+
export async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
114+
return defaultGetUrl(req, signal);
95115
}
96116

0 commit comments

Comments
 (0)
Please sign in to comment.