refactor: move brother_node development artifact to dev/test-nodes subdirectory

Development Artifact Cleanup:
✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location
- dev/test-nodes/brother_node/: Moved from root directory for better organization
- Contains development configuration, test logs, and test chain data
- No impact on production systems - purely development/testing artifact

✅ DEVELOPMENT ARTIFACTS IDENTIFIED:
- Chain ID: aitbc-brother-chain (test/development chain)
- Ports: 8010 (P2P) and 8011 (RPC) - different from production
- Environment: .env file with test configuration
- Logs: rpc.log and node.log from development testing session (March 15, 2026)

✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory
- brother_node/ moved to dev/test-nodes/brother_node/
- Root directory now contains only production-ready components
- Development artifacts properly organized in dev/ subdirectory

DIRECTORY STRUCTURE IMPROVEMENT:
📁 dev/test-nodes/: Development and testing node configurations
🏗️ Root Directory: Clean production structure with only essential components
🧪 Development Isolation: Test environments separated from production

BENEFITS:
✅ Clean Production Directory: No development artifacts in root
✅ Better Organization: Development nodes grouped in dev/ subdirectory
✅ Clear Separation: Production vs development environments clearly distinguished
✅ Maintainability: Easier to identify and manage development components

RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto-browser.d.ts

@@ -0,0 +1,15 @@
+declare global {
+    interface Window {
+    }
+    const window: Window;
+    const self: Window;
+}
+export interface CryptoHasher {
+    update(data: Uint8Array): CryptoHasher;
+    digest(): Uint8Array;
+}
+export declare function createHash(algo: string): CryptoHasher;
+export declare function createHmac(_algo: string, key: Uint8Array): CryptoHasher;
+export declare function pbkdf2Sync(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, _algo: "sha256" | "sha512"): Uint8Array;
+export declare function randomBytes(length: number): Uint8Array;
+//# sourceMappingURL=crypto-browser.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-browser.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/crypto-browser.ts"],"names":[],"mappings":"AAUA,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;KAAI;IAEpB,MAAM,MAAM,EAAE,MAAM,CAAC;IACrB,MAAM,IAAI,EAAE,MAAM,CAAC;CACtB;AAcD,MAAM,WAAW,YAAY;IACzB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,CAAC;IACvC,MAAM,IAAI,UAAU,CAAC;CACxB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAMrD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,YAAY,CAIvE;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAI7I;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAStD"}

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto-browser.js

@@ -0,0 +1,55 @@
+"use strict";
+/* Browser Crypto Shims */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = exports.pbkdf2Sync = exports.createHmac = exports.createHash = void 0;
+const hmac_1 = require("@noble/hashes/hmac");
+const pbkdf2_1 = require("@noble/hashes/pbkdf2");
+const sha256_1 = require("@noble/hashes/sha256");
+const sha512_1 = require("@noble/hashes/sha512");
+const index_js_1 = require("../utils/index.js");
+function getGlobal() {
+    if (typeof self !== 'undefined') {
+        return self;
+    }
+    if (typeof window !== 'undefined') {
+        return window;
+    }
+    if (typeof global !== 'undefined') {
+        return global;
+    }
+    throw new Error('unable to locate global object');
+}
+;
+const anyGlobal = getGlobal();
+const crypto = anyGlobal.crypto || anyGlobal.msCrypto;
+function createHash(algo) {
+    switch (algo) {
+        case "sha256": return sha256_1.sha256.create();
+        case "sha512": return sha512_1.sha512.create();
+    }
+    (0, index_js_1.assertArgument)(false, "invalid hashing algorithm name", "algorithm", algo);
+}
+exports.createHash = createHash;
+function createHmac(_algo, key) {
+    const algo = ({ sha256: sha256_1.sha256, sha512: sha512_1.sha512 }[_algo]);
+    (0, index_js_1.assertArgument)(algo != null, "invalid hmac algorithm", "algorithm", _algo);
+    return hmac_1.hmac.create(algo, key);
+}
+exports.createHmac = createHmac;
+function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
+    const algo = ({ sha256: sha256_1.sha256, sha512: sha512_1.sha512 }[_algo]);
+    (0, index_js_1.assertArgument)(algo != null, "invalid pbkdf2 algorithm", "algorithm", _algo);
+    return (0, pbkdf2_1.pbkdf2)(algo, password, salt, { c: iterations, dkLen: keylen });
+}
+exports.pbkdf2Sync = pbkdf2Sync;
+function randomBytes(length) {
+    (0, index_js_1.assert)(crypto != null, "platform does not support secure random numbers", "UNSUPPORTED_OPERATION", {
+        operation: "randomBytes"
+    });
+    (0, index_js_1.assertArgument)(Number.isInteger(length) && length > 0 && length <= 1024, "invalid length", "length", length);
+    const result = new Uint8Array(length);
+    crypto.getRandomValues(result);
+    return result;
+}
+exports.randomBytes = randomBytes;
+//# sourceMappingURL=crypto-browser.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto-browser.js","sourceRoot":"","sources":["../../src.ts/crypto/crypto-browser.ts"],"names":[],"mappings":";AAAA,0BAA0B;;;AAE1B,6CAA0C;AAC1C,iDAA8C;AAC9C,iDAA8C;AAC9C,iDAA8C;AAE9C,gDAA2D;AAW3D,SAAS,SAAS;IAChB,IAAI,OAAO,IAAI,KAAK,WAAW,EAAE;QAAE,OAAO,IAAI,CAAC;KAAE;IACjD,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QAAE,OAAO,MAAM,CAAC;KAAE;IACrD,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;QAAE,OAAO,MAAM,CAAC;KAAE;IACrD,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;AACpD,CAAC;AAAA,CAAC;AAEF,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC;AAC9B,MAAM,MAAM,GAAQ,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC;AAQ3D,SAAgB,UAAU,CAAC,IAAY;IACnC,QAAQ,IAAI,EAAE;QACV,KAAK,QAAQ,CAAC,CAAC,OAAO,eAAM,CAAC,MAAM,EAAE,CAAC;QACtC,KAAK,QAAQ,CAAC,CAAC,OAAO,eAAM,CAAC,MAAM,EAAE,CAAC;KACzC;IACD,IAAA,yBAAc,EAAC,KAAK,EAAE,gCAAgC,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;AAC/E,CAAC;AAND,gCAMC;AAED,SAAgB,UAAU,CAAC,KAAa,EAAE,GAAe;IACrD,MAAM,IAAI,GAAG,CAAC,EAAE,MAAM,EAAN,eAAM,EAAE,MAAM,EAAN,eAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,IAAA,yBAAc,EAAC,IAAI,IAAI,IAAI,EAAE,wBAAwB,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC3E,OAAO,WAAI,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAClC,CAAC;AAJD,gCAIC;AAED,SAAgB,UAAU,CAAC,QAAoB,EAAE,IAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,KAA0B;IAC7H,MAAM,IAAI,GAAG,CAAC,EAAE,MAAM,EAAN,eAAM,EAAE,MAAM,EAAN,eAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;IACzC,IAAA,yBAAc,EAAC,IAAI,IAAI,IAAI,EAAE,0BAA0B,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC7E,OAAO,IAAA,eAAM,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;AAC1E,CAAC;AAJD,gCAIC;AAED,SAAgB,WAAW,CAAC,MAAc;IACtC,IAAA,iBAAM,EAAC,MAAM,IAAI,IAAI,EAAE,iDAAiD,EAAE,uBAAuB,EAAE;QAC/F,SAAS,EAAE,aAAa;KAAE,CAAC,CAAC;IAEhC,IAAA,yBAAc,EAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,IAAI,MAAM,IAAI,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;IAE7G,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,MAAM,CAAC;AAClB,CAAC;AATD,kCASC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto.d.ts

@@ -0,0 +1,2 @@
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from "crypto";
+//# sourceMappingURL=crypto.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/crypto.ts"],"names":[],"mappings":"AACA,OAAO,EACH,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAClD,MAAM,QAAQ,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = exports.pbkdf2Sync = exports.createHmac = exports.createHash = void 0;
+var crypto_1 = require("crypto");
+Object.defineProperty(exports, "createHash", { enumerable: true, get: function () { return crypto_1.createHash; } });
+Object.defineProperty(exports, "createHmac", { enumerable: true, get: function () { return crypto_1.createHmac; } });
+Object.defineProperty(exports, "pbkdf2Sync", { enumerable: true, get: function () { return crypto_1.pbkdf2Sync; } });
+Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function () { return crypto_1.randomBytes; } });
+//# sourceMappingURL=crypto.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src.ts/crypto/crypto.ts"],"names":[],"mappings":";;;AACA,iCAEgB;AADZ,oGAAA,UAAU,OAAA;AAAE,oGAAA,UAAU,OAAA;AAAE,oGAAA,UAAU,OAAA;AAAE,qGAAA,WAAW,OAAA"}

dev/env/node_modules/ethers/lib.commonjs/crypto/hmac.d.ts

@@ -0,0 +1,25 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Return the HMAC for %%data%% using the %%key%% key with the underlying
+ *  %%algo%% used for compression.
+ *
+ *  @example:
+ *    key = id("some-secret")
+ *
+ *    // Compute the HMAC
+ *    computeHmac("sha256", key, "0x1337")
+ *    //_result:
+ *
+ *    // To compute the HMAC of UTF-8 data, the data must be
+ *    // converted to UTF-8 bytes
+ *    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
+ *    //_result:
+ *
+ */
+export declare function computeHmac(algorithm: "sha256" | "sha512", _key: BytesLike, _data: BytesLike): string;
+export declare namespace computeHmac {
+    var _: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike;
+    var lock: () => void;
+    var register: (func: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=hmac.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/hmac.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAIrG;yBAJe,WAAW"}

dev/env/node_modules/ethers/lib.commonjs/crypto/hmac.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeHmac = void 0;
+/**
+ *  An **HMAC** enables verification that a given key was used
+ *  to authenticate a payload.
+ *
+ *  See: [[link-wiki-hmac]]
+ *
+ *  @_subsection: api/crypto:HMAC  [about-hmac]
+ */
+const crypto_js_1 = require("./crypto.js");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _computeHmac = function (algorithm, key, data) {
+    return (0, crypto_js_1.createHmac)(algorithm, key).update(data).digest();
+};
+let __computeHmac = _computeHmac;
+/**
+ *  Return the HMAC for %%data%% using the %%key%% key with the underlying
+ *  %%algo%% used for compression.
+ *
+ *  @example:
+ *    key = id("some-secret")
+ *
+ *    // Compute the HMAC
+ *    computeHmac("sha256", key, "0x1337")
+ *    //_result:
+ *
+ *    // To compute the HMAC of UTF-8 data, the data must be
+ *    // converted to UTF-8 bytes
+ *    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
+ *    //_result:
+ *
+ */
+function computeHmac(algorithm, _key, _data) {
+    const key = (0, index_js_1.getBytes)(_key, "key");
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__computeHmac(algorithm, key, data));
+}
+exports.computeHmac = computeHmac;
+computeHmac._ = _computeHmac;
+computeHmac.lock = function () { locked = true; };
+computeHmac.register = function (func) {
+    if (locked) {
+        throw new Error("computeHmac is locked");
+    }
+    __computeHmac = func;
+};
+Object.freeze(computeHmac);
+//# sourceMappingURL=hmac.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../../src.ts/crypto/hmac.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,2CAAyC;AACzC,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,YAAY,GAAG,UAAS,SAA8B,EAAE,GAAe,EAAE,IAAgB;IAC3F,OAAO,IAAA,sBAAU,EAAC,SAAS,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AAC5D,CAAC,CAAA;AAED,IAAI,aAAa,GAAG,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,WAAW,CAAC,SAA8B,EAAE,IAAe,EAAE,KAAgB;IACzF,MAAM,GAAG,GAAG,IAAA,mBAAQ,EAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,aAAa,CAAC,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AACxD,CAAC;AAJD,kCAIC;AACD,WAAW,CAAC,CAAC,GAAG,YAAY,CAAC;AAC7B,WAAW,CAAC,IAAI,GAAI,cAAa,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACjD,WAAW,CAAC,QAAQ,GAAG,UAAS,IAAsF;IAClH,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ *  A fundamental building block of Ethereum is the underlying
+ *  cryptographic primitives.
+ *
+ *  @_section: api/crypto:Cryptographic Functions   [about-crypto]
+ */
+import { computeHmac } from "./hmac.js";
+import { keccak256 } from "./keccak.js";
+import { ripemd160 } from "./ripemd160.js";
+import { pbkdf2 } from "./pbkdf2.js";
+import { randomBytes } from "./random.js";
+import { scrypt, scryptSync } from "./scrypt.js";
+import { sha256, sha512 } from "./sha2.js";
+export { computeHmac, randomBytes, keccak256, ripemd160, sha256, sha512, pbkdf2, scrypt, scryptSync };
+export { SigningKey } from "./signing-key.js";
+export { Signature } from "./signature.js";
+/**
+ *  Once called, prevents any future change to the underlying cryptographic
+ *  primitives using the ``.register`` feature for hooks.
+ */
+declare function lock(): void;
+export { lock };
+export type { ProgressCallback } from "./scrypt.js";
+export type { SignatureLike } from "./signature.js";
+//# sourceMappingURL=index.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EACH,WAAW,EAEX,WAAW,EAEX,SAAS,EACT,SAAS,EACT,MAAM,EAAE,MAAM,EAEd,MAAM,EACN,MAAM,EAAE,UAAU,EACrB,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,iBAAS,IAAI,IAAI,IAAI,CAWpB;AAED,OAAO,EAAE,IAAI,EAAE,CAAC;AAKhB,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ *  A fundamental building block of Ethereum is the underlying
+ *  cryptographic primitives.
+ *
+ *  @_section: api/crypto:Cryptographic Functions   [about-crypto]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lock = exports.Signature = exports.SigningKey = exports.scryptSync = exports.scrypt = exports.pbkdf2 = exports.sha512 = exports.sha256 = exports.ripemd160 = exports.keccak256 = exports.randomBytes = exports.computeHmac = void 0;
+null;
+// We import all these so we can export lock()
+const hmac_js_1 = require("./hmac.js");
+Object.defineProperty(exports, "computeHmac", { enumerable: true, get: function () { return hmac_js_1.computeHmac; } });
+const keccak_js_1 = require("./keccak.js");
+Object.defineProperty(exports, "keccak256", { enumerable: true, get: function () { return keccak_js_1.keccak256; } });
+const ripemd160_js_1 = require("./ripemd160.js");
+Object.defineProperty(exports, "ripemd160", { enumerable: true, get: function () { return ripemd160_js_1.ripemd160; } });
+const pbkdf2_js_1 = require("./pbkdf2.js");
+Object.defineProperty(exports, "pbkdf2", { enumerable: true, get: function () { return pbkdf2_js_1.pbkdf2; } });
+const random_js_1 = require("./random.js");
+Object.defineProperty(exports, "randomBytes", { enumerable: true, get: function () { return random_js_1.randomBytes; } });
+const scrypt_js_1 = require("./scrypt.js");
+Object.defineProperty(exports, "scrypt", { enumerable: true, get: function () { return scrypt_js_1.scrypt; } });
+Object.defineProperty(exports, "scryptSync", { enumerable: true, get: function () { return scrypt_js_1.scryptSync; } });
+const sha2_js_1 = require("./sha2.js");
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return sha2_js_1.sha256; } });
+Object.defineProperty(exports, "sha512", { enumerable: true, get: function () { return sha2_js_1.sha512; } });
+var signing_key_js_1 = require("./signing-key.js");
+Object.defineProperty(exports, "SigningKey", { enumerable: true, get: function () { return signing_key_js_1.SigningKey; } });
+var signature_js_1 = require("./signature.js");
+Object.defineProperty(exports, "Signature", { enumerable: true, get: function () { return signature_js_1.Signature; } });
+/**
+ *  Once called, prevents any future change to the underlying cryptographic
+ *  primitives using the ``.register`` feature for hooks.
+ */
+function lock() {
+    hmac_js_1.computeHmac.lock();
+    keccak_js_1.keccak256.lock();
+    pbkdf2_js_1.pbkdf2.lock();
+    random_js_1.randomBytes.lock();
+    ripemd160_js_1.ripemd160.lock();
+    scrypt_js_1.scrypt.lock();
+    scrypt_js_1.scryptSync.lock();
+    sha2_js_1.sha256.lock();
+    sha2_js_1.sha512.lock();
+    random_js_1.randomBytes.lock();
+}
+exports.lock = lock;
+//# sourceMappingURL=index.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src.ts/crypto/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,IAAI,CAAA;AAEJ,8CAA8C;AAC9C,uCAAwC;AASpC,4FATK,qBAAW,OASL;AARf,2CAAwC;AAYpC,0FAZK,qBAAS,OAYL;AAXb,iDAA2C;AAYvC,0FAZK,wBAAS,OAYL;AAXb,2CAAqC;AAcjC,uFAdK,kBAAM,OAcL;AAbV,2CAA0C;AAOtC,4FAPK,uBAAW,OAOL;AANf,2CAAiD;AAa7C,uFAbK,kBAAM,OAaL;AAAE,2FAbK,sBAAU,OAaL;AAZtB,uCAA2C;AASvC,uFATK,gBAAM,OASL;AAAE,uFATK,gBAAM,OASL;AAMlB,mDAA8C;AAArC,4GAAA,UAAU,OAAA;AACnB,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAElB;;;GAGG;AACH,SAAS,IAAI;IACT,qBAAW,CAAC,IAAI,EAAE,CAAC;IACnB,qBAAS,CAAC,IAAI,EAAE,CAAC;IACjB,kBAAM,CAAC,IAAI,EAAE,CAAC;IACd,uBAAW,CAAC,IAAI,EAAE,CAAC;IACnB,wBAAS,CAAC,IAAI,EAAE,CAAC;IACjB,kBAAM,CAAC,IAAI,EAAE,CAAC;IACd,sBAAU,CAAC,IAAI,EAAE,CAAC;IAClB,gBAAM,CAAC,IAAI,EAAE,CAAC;IACd,gBAAM,CAAC,IAAI,EAAE,CAAC;IACd,uBAAW,CAAC,IAAI,EAAE,CAAC;AACvB,CAAC;AAEQ,oBAAI"}

dev/env/node_modules/ethers/lib.commonjs/crypto/keccak.d.ts

@@ -0,0 +1,35 @@
+/**
+ *  Cryptographic hashing functions
+ *
+ *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic KECCAK256 hash of %%data%%.
+ *
+ *  The %%data%% **must** be a data representation, to compute the
+ *  hash of UTF-8 data use the [[id]] function.
+ *
+ *  @returns DataHexstring
+ *  @example:
+ *    keccak256("0x")
+ *    //_result:
+ *
+ *    keccak256("0x1337")
+ *    //_result:
+ *
+ *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ *    // Strings are assumed to be DataHexString, otherwise it will
+ *    // throw. To hash UTF-8 data, see the note above.
+ *    keccak256("Hello World")
+ *    //_error:
+ */
+export declare function keccak256(_data: BytesLike): string;
+export declare namespace keccak256 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=keccak.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/keccak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keccak.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/keccak.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAGlD;yBAHe,SAAS"}

dev/env/node_modules/ethers/lib.commonjs/crypto/keccak.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ *  Cryptographic hashing functions
+ *
+ *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = void 0;
+const sha3_1 = require("@noble/hashes/sha3");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _keccak256 = function (data) {
+    return (0, sha3_1.keccak_256)(data);
+};
+let __keccak256 = _keccak256;
+/**
+ *  Compute the cryptographic KECCAK256 hash of %%data%%.
+ *
+ *  The %%data%% **must** be a data representation, to compute the
+ *  hash of UTF-8 data use the [[id]] function.
+ *
+ *  @returns DataHexstring
+ *  @example:
+ *    keccak256("0x")
+ *    //_result:
+ *
+ *    keccak256("0x1337")
+ *    //_result:
+ *
+ *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ *    // Strings are assumed to be DataHexString, otherwise it will
+ *    // throw. To hash UTF-8 data, see the note above.
+ *    keccak256("Hello World")
+ *    //_error:
+ */
+function keccak256(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__keccak256(data));
+}
+exports.keccak256 = keccak256;
+keccak256._ = _keccak256;
+keccak256.lock = function () { locked = true; };
+keccak256.register = function (func) {
+    if (locked) {
+        throw new TypeError("keccak256 is locked");
+    }
+    __keccak256 = func;
+};
+Object.freeze(keccak256);
+//# sourceMappingURL=keccak.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/keccak.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keccak.js","sourceRoot":"","sources":["../../src.ts/crypto/keccak.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,6CAAgD;AAEhD,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,iBAAU,EAAC,IAAI,CAAC,CAAC;AAC5B,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/pbkdf2.d.ts

@@ -0,0 +1,35 @@
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+export declare function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string;
+export declare namespace pbkdf2 {
+    var _: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike;
+    var lock: () => void;
+    var register: (func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) => void;
+}
+//# sourceMappingURL=pbkdf2.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAIpI;yBAJe,MAAM"}

dev/env/node_modules/ethers/lib.commonjs/crypto/pbkdf2.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pbkdf2 = void 0;
+const crypto_js_1 = require("./crypto.js");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _pbkdf2 = function (password, salt, iterations, keylen, algo) {
+    return (0, crypto_js_1.pbkdf2Sync)(password, salt, iterations, keylen, algo);
+};
+let __pbkdf2 = _pbkdf2;
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+function pbkdf2(_password, _salt, iterations, keylen, algo) {
+    const password = (0, index_js_1.getBytes)(_password, "password");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(__pbkdf2(password, salt, iterations, keylen, algo));
+}
+exports.pbkdf2 = pbkdf2;
+pbkdf2._ = _pbkdf2;
+pbkdf2.lock = function () { locked = true; };
+pbkdf2.register = function (func) {
+    if (locked) {
+        throw new Error("pbkdf2 is locked");
+    }
+    __pbkdf2 = func;
+};
+Object.freeze(pbkdf2);
+//# sourceMappingURL=pbkdf2.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/pbkdf2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,2CAAyC;AAEzC,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,OAAO,GAAG,UAAS,QAAoB,EAAE,IAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IAC1H,OAAO,IAAA,sBAAU,EAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAChE,CAAC,CAAA;AAED,IAAI,QAAQ,GAAG,OAAO,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,MAAM,CAAC,SAAoB,EAAE,KAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IACxH,MAAM,QAAQ,GAAG,IAAA,mBAAQ,EAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACjD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA0H;IACjJ,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACpD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/random.d.ts

@@ -0,0 +1,14 @@
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+export declare function randomBytes(length: number): Uint8Array;
+export declare namespace randomBytes {
+    var _: (length: number) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (length: number) => Uint8Array) => void;
+}
+//# sourceMappingURL=random.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAEtD;yBAFe,WAAW"}

dev/env/node_modules/ethers/lib.commonjs/crypto/random.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomBytes = void 0;
+/**
+ *  A **Cryptographically Secure Random Value** is one that has been
+ *  generated with additional care take to prevent side-channels
+ *  from allowing others to detect it and prevent others from through
+ *  coincidence generate the same values.
+ *
+ *  @_subsection: api/crypto:Random Values  [about-crypto-random]
+ */
+const crypto_js_1 = require("./crypto.js");
+let locked = false;
+const _randomBytes = function (length) {
+    return new Uint8Array((0, crypto_js_1.randomBytes)(length));
+};
+let __randomBytes = _randomBytes;
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+function randomBytes(length) {
+    return __randomBytes(length);
+}
+exports.randomBytes = randomBytes;
+randomBytes._ = _randomBytes;
+randomBytes.lock = function () { locked = true; };
+randomBytes.register = function (func) {
+    if (locked) {
+        throw new Error("randomBytes is locked");
+    }
+    __randomBytes = func;
+};
+Object.freeze(randomBytes);
+//# sourceMappingURL=random.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,2CAA2D;AAE3D,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,YAAY,GAAG,UAAS,MAAc;IACxC,OAAO,IAAI,UAAU,CAAC,IAAA,uBAAa,EAAC,MAAM,CAAC,CAAC,CAAC;AACjD,CAAC,CAAA;AAED,IAAI,aAAa,GAAG,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,MAAc;IACtC,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AACjC,CAAC;AAFD,kCAEC;AAED,WAAW,CAAC,CAAC,GAAG,YAAY,CAAC;AAC7B,WAAW,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,WAAW,CAAC,QAAQ,GAAG,UAAS,IAAoC;IAChE,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/ripemd160.d.ts

@@ -0,0 +1,25 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export declare function ripemd160(_data: BytesLike): string;
+export declare namespace ripemd160 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=ripemd160.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/ripemd160.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAGlD;yBAHe,SAAS"}

dev/env/node_modules/ethers/lib.commonjs/crypto/ripemd160.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ripemd160 = void 0;
+const ripemd160_1 = require("@noble/hashes/ripemd160");
+const index_js_1 = require("../utils/index.js");
+let locked = false;
+const _ripemd160 = function (data) {
+    return (0, ripemd160_1.ripemd160)(data);
+};
+let __ripemd160 = _ripemd160;
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+function ripemd160(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__ripemd160(data));
+}
+exports.ripemd160 = ripemd160;
+ripemd160._ = _ripemd160;
+ripemd160.lock = function () { locked = true; };
+ripemd160.register = function (func) {
+    if (locked) {
+        throw new TypeError("ripemd160 is locked");
+    }
+    __ripemd160 = func;
+};
+Object.freeze(ripemd160);
+//# sourceMappingURL=ripemd160.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/ripemd160.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ripemd160.js","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":";;;AAAA,uDAAuE;AAEvE,gDAAuD;AAKvD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,qBAAe,EAAC,IAAI,CAAC,CAAC;AACjC,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/scrypt.d.ts

@@ -0,0 +1,82 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  A callback during long-running operations to update any
+ *  UI or provide programatic access to the progress.
+ *
+ *  The %%percent%% is a value between ``0`` and ``1``.
+ *
+ *  @_docloc: api/crypto:Passwords
+ */
+export type ProgressCallback = (percent: number) => void;
+/**
+ *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
+ *  derivation to increase the resource cost to brute-force a password
+ *  for a given key.
+ *
+ *  This means this algorithm is intentionally slow, and can be tuned to
+ *  become slower. As computation and memory speed improve over time,
+ *  increasing the difficulty maintains the cost of an attacker.
+ *
+ *  For example, if a target time of 5 seconds is used, a legitimate user
+ *  which knows their password requires only 5 seconds to unlock their
+ *  account. A 6 character password has 68 billion possibilities, which
+ *  would require an attacker to invest over 10,000 years of CPU time. This
+ *  is of course a crude example (as password generally aren't random),
+ *  but demonstrates to value of imposing large costs to decryption.
+ *
+ *  For this reason, if building a UI which involved decrypting or
+ *  encrypting datsa using scrypt, it is recommended to use a
+ *  [[ProgressCallback]] (as event short periods can seem lik an eternity
+ *  if the UI freezes). Including the phrase //"decrypting"// in the UI
+ *  can also help, assuring the user their waiting is for a good reason.
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+export declare function scrypt(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback): Promise<string>;
+export declare namespace scrypt {
+    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback | undefined) => Promise<Uint8Array>;
+    var lock: () => void;
+    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback | undefined) => Promise<BytesLike>) => void;
+}
+/**
+ *  Provides a synchronous variant of [[scrypt]].
+ *
+ *  This will completely lock up and freeze the UI in a browser and will
+ *  prevent any event loop from progressing. For this reason, it is
+ *  preferred to use the [async variant](scrypt).
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+export declare function scryptSync(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number): string;
+export declare namespace scryptSync {
+    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike) => void;
+}
+//# sourceMappingURL=scrypt.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/scrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAgBzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI/J;yBAJqB,MAAM;;;;;AAa5B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIvH;yBAJe,UAAU"}

dev/env/node_modules/ethers/lib.commonjs/crypto/scrypt.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scryptSync = exports.scrypt = void 0;
+const scrypt_1 = require("@noble/hashes/scrypt");
+const index_js_1 = require("../utils/index.js");
+let lockedSync = false, lockedAsync = false;
+const _scryptAsync = async function (passwd, salt, N, r, p, dkLen, onProgress) {
+    return await (0, scrypt_1.scryptAsync)(passwd, salt, { N, r, p, dkLen, onProgress });
+};
+const _scryptSync = function (passwd, salt, N, r, p, dkLen) {
+    return (0, scrypt_1.scrypt)(passwd, salt, { N, r, p, dkLen });
+};
+let __scryptAsync = _scryptAsync;
+let __scryptSync = _scryptSync;
+/**
+ *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
+ *  derivation to increase the resource cost to brute-force a password
+ *  for a given key.
+ *
+ *  This means this algorithm is intentionally slow, and can be tuned to
+ *  become slower. As computation and memory speed improve over time,
+ *  increasing the difficulty maintains the cost of an attacker.
+ *
+ *  For example, if a target time of 5 seconds is used, a legitimate user
+ *  which knows their password requires only 5 seconds to unlock their
+ *  account. A 6 character password has 68 billion possibilities, which
+ *  would require an attacker to invest over 10,000 years of CPU time. This
+ *  is of course a crude example (as password generally aren't random),
+ *  but demonstrates to value of imposing large costs to decryption.
+ *
+ *  For this reason, if building a UI which involved decrypting or
+ *  encrypting datsa using scrypt, it is recommended to use a
+ *  [[ProgressCallback]] (as event short periods can seem lik an eternity
+ *  if the UI freezes). Including the phrase //"decrypting"// in the UI
+ *  can also help, assuring the user their waiting is for a good reason.
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+async function scrypt(_passwd, _salt, N, r, p, dkLen, progress) {
+    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));
+}
+exports.scrypt = scrypt;
+scrypt._ = _scryptAsync;
+scrypt.lock = function () { lockedAsync = true; };
+scrypt.register = function (func) {
+    if (lockedAsync) {
+        throw new Error("scrypt is locked");
+    }
+    __scryptAsync = func;
+};
+Object.freeze(scrypt);
+/**
+ *  Provides a synchronous variant of [[scrypt]].
+ *
+ *  This will completely lock up and freeze the UI in a browser and will
+ *  prevent any event loop from progressing. For this reason, it is
+ *  preferred to use the [async variant](scrypt).
+ *
+ *  @_docloc: api/crypto:Passwords
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the scrypt
+ *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
+ *    //_result:
+ */
+function scryptSync(_passwd, _salt, N, r, p, dkLen) {
+    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
+    const salt = (0, index_js_1.getBytes)(_salt, "salt");
+    return (0, index_js_1.hexlify)(__scryptSync(passwd, salt, N, r, p, dkLen));
+}
+exports.scryptSync = scryptSync;
+scryptSync._ = _scryptSync;
+scryptSync.lock = function () { lockedSync = true; };
+scryptSync.register = function (func) {
+    if (lockedSync) {
+        throw new Error("scryptSync is locked");
+    }
+    __scryptSync = func;
+};
+Object.freeze(scryptSync);
+//# sourceMappingURL=scrypt.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/scrypt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrypt.js","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":";;;AAAA,iDAAwF;AAExF,gDAA2D;AAe3D,IAAI,UAAU,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,CAAC;AAE5C,MAAM,YAAY,GAAG,KAAK,WAAU,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,UAA6B;IACnJ,OAAO,MAAM,IAAA,oBAAW,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;AAC3E,CAAC,CAAA;AACD,MAAM,WAAW,GAAG,UAAS,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC7G,OAAO,IAAA,eAAU,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxD,CAAC,CAAA;AAED,IAAI,aAAa,GAAgJ,YAAY,CAAC;AAC9K,IAAI,YAAY,GAAwG,WAAW,CAAA;AAGnI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACI,KAAK,UAAU,MAAM,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,QAA2B;IAC1I,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,MAAM,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC1E,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC;AACxB,MAAM,CAAC,IAAI,GAAG,cAAmB,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA+I;IACtK,IAAI,WAAW,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,UAAU,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC3G,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACzD,CAAC;AAJD,gCAIC;AACD,UAAU,CAAC,CAAC,GAAG,WAAW,CAAC;AAC3B,UAAU,CAAC,IAAI,GAAG,cAAmB,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACzD,UAAU,CAAC,QAAQ,GAAG,UAAS,IAAyG;IACpI,IAAI,UAAU,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;KAAE;IAC5D,YAAY,GAAG,IAAI,CAAC;AACxB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/sha2.d.ts

@@ -0,0 +1,47 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic SHA2-256 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha256("0x")
+ *    //_result:
+ *
+ *    sha256("0x1337")
+ *    //_result:
+ *
+ *    sha256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export declare function sha256(_data: BytesLike): string;
+export declare namespace sha256 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+/**
+ *  Compute the cryptographic SHA2-512 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha512("0x")
+ *    //_result:
+ *
+ *    sha512("0x1337")
+ *    //_result:
+ *
+ *    sha512(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ */
+export declare function sha512(_data: BytesLike): string;
+export declare namespace sha512 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}
+//# sourceMappingURL=sha2.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/sha2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAiBnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM;;;;;AAatB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM"}

dev/env/node_modules/ethers/lib.commonjs/crypto/sha2.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha512 = exports.sha256 = void 0;
+const crypto_js_1 = require("./crypto.js");
+const index_js_1 = require("../utils/index.js");
+const _sha256 = function (data) {
+    return (0, crypto_js_1.createHash)("sha256").update(data).digest();
+};
+const _sha512 = function (data) {
+    return (0, crypto_js_1.createHash)("sha512").update(data).digest();
+};
+let __sha256 = _sha256;
+let __sha512 = _sha512;
+let locked256 = false, locked512 = false;
+/**
+ *  Compute the cryptographic SHA2-256 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha256("0x")
+ *    //_result:
+ *
+ *    sha256("0x1337")
+ *    //_result:
+ *
+ *    sha256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+function sha256(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__sha256(data));
+}
+exports.sha256 = sha256;
+sha256._ = _sha256;
+sha256.lock = function () { locked256 = true; };
+sha256.register = function (func) {
+    if (locked256) {
+        throw new Error("sha256 is locked");
+    }
+    __sha256 = func;
+};
+Object.freeze(sha256);
+/**
+ *  Compute the cryptographic SHA2-512 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    sha512("0x")
+ *    //_result:
+ *
+ *    sha512("0x1337")
+ *    //_result:
+ *
+ *    sha512(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ */
+function sha512(_data) {
+    const data = (0, index_js_1.getBytes)(_data, "data");
+    return (0, index_js_1.hexlify)(__sha512(data));
+}
+exports.sha512 = sha512;
+sha512._ = _sha512;
+sha512.lock = function () { locked512 = true; };
+sha512.register = function (func) {
+    if (locked512) {
+        throw new Error("sha512 is locked");
+    }
+    __sha512 = func;
+};
+Object.freeze(sha256);
+//# sourceMappingURL=sha2.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/sha2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha2.js","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":";;;AAAA,2CAAyC;AAEzC,gDAAsD;AAKtD,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,IAAI,QAAQ,GAAoC,OAAO,CAAC;AACxD,IAAI,QAAQ,GAAoC,OAAO,CAAC;AAExD,IAAI,SAAS,GAAG,KAAK,EAAE,SAAS,GAAG,KAAK,CAAC;AAGzC;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAGtB;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

dev/env/node_modules/ethers/lib.commonjs/crypto/signature.d.ts

@@ -0,0 +1,183 @@
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+declare const inspect: unique symbol;
+/**
+ *  A SignatureLike
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+export type SignatureLike = Signature | string | {
+    r: string;
+    s: string;
+    v: BigNumberish;
+    yParity?: 0 | 1;
+    yParityAndS?: string;
+} | {
+    r: string;
+    yParityAndS: string;
+    yParity?: 0 | 1;
+    s?: string;
+    v?: number;
+} | {
+    r: string;
+    s: string;
+    yParity: 0 | 1;
+    v?: BigNumberish;
+    yParityAndS?: string;
+};
+/**
+ *  A Signature  @TODO
+ *
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+export declare class Signature {
+    #private;
+    /**
+     *  The ``r`` value for a signature.
+     *
+     *  This represents the ``x`` coordinate of a "reference" or
+     *  challenge point, from which the ``y`` can be computed.
+     */
+    get r(): string;
+    set r(value: BytesLike);
+    /**
+     *  The ``s`` value for a signature.
+     */
+    get s(): string;
+    set s(_value: BytesLike);
+    /**
+     *  Return the s value, unchecked for EIP-2 compliance.
+     *
+     *  This should generally not be used and is for situations where
+     *  a non-canonical S value might be relevant, such as Frontier blocks
+     *  that were mined prior to EIP-2 or invalid Authorization List
+     *  signatures.
+     */
+    get _s(): string;
+    /**
+     *  Returns true if the Signature is valid for [[link-eip-2]] signatures.
+     */
+    isValid(): boolean;
+    /**
+     *  The ``v`` value for a signature.
+     *
+     *  Since a given ``x`` value for ``r`` has two possible values for
+     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
+     *  values to use.
+     *
+     *  It is normalized to the values ``27`` or ``28`` for legacy
+     *  purposes.
+     */
+    get v(): 27 | 28;
+    set v(value: BigNumberish);
+    /**
+     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get networkV(): null | bigint;
+    /**
+     *  The chain ID for EIP-155 legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get legacyChainId(): null | bigint;
+    /**
+     *  The ``yParity`` for the signature.
+     *
+     *  See ``v`` for more details on how this value is used.
+     */
+    get yParity(): 0 | 1;
+    /**
+     *  The [[link-eip-2098]] compact representation of the ``yParity``
+     *  and ``s`` compacted into a single ``bytes32``.
+     */
+    get yParityAndS(): string;
+    /**
+     *  The [[link-eip-2098]] compact representation.
+     */
+    get compactSerialized(): string;
+    /**
+     *  The serialized representation.
+     */
+    get serialized(): string;
+    /**
+     *  @private
+     */
+    constructor(guard: any, r: string, s: string, v: 27 | 28);
+    /**
+     *  Returns the canonical signature.
+     *
+     *  This is only necessary when dealing with legacy transaction which
+     *  did not enforce canonical S values (i.e. [[link-eip-2]]. Most
+     *  developers should never require this.
+     */
+    getCanonical(): Signature;
+    /**
+     *  Returns a new identical [[Signature]].
+     */
+    clone(): Signature;
+    /**
+     *  Returns a representation that is compatible with ``JSON.stringify``.
+     */
+    toJSON(): any;
+    [inspect](): string;
+    toString(): string;
+    /**
+     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
+     *
+     *  @example:
+     *    Signature.getChainId(45)
+     *    //_result:
+     *
+     *    Signature.getChainId(46)
+     *    //_result:
+     */
+    static getChainId(v: BigNumberish): bigint;
+    /**
+     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
+     *
+     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
+     *  property to include the chain ID.
+     *
+     *  @example:
+     *    Signature.getChainIdV(5, 27)
+     *    //_result:
+     *
+     *    Signature.getChainIdV(5, 28)
+     *    //_result:
+     *
+     */
+    static getChainIdV(chainId: BigNumberish, v: 27 | 28): bigint;
+    /**
+     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
+     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
+     *
+     *  @example:
+     *    // The values 0 and 1 imply v is actually yParity
+     *    Signature.getNormalizedV(0)
+     *    //_result:
+     *
+     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
+     *    Signature.getNormalizedV(27)
+     *    //_result:
+     *
+     *    // Legacy EIP-155 transaction (i.e. >= 35)
+     *    Signature.getNormalizedV(46)
+     *    //_result:
+     *
+     *    // Invalid values throw
+     *    Signature.getNormalizedV(5)
+     *    //_error:
+     */
+    static getNormalizedV(v: BigNumberish): 27 | 28;
+    /**
+     *  Creates a new [[Signature]].
+     *
+     *  If no %%sig%% is provided, a new [[Signature]] is created
+     *  with default values.
+     *
+     *  If %%sig%% is a string, it is parsed.
+     */
+    static from(sig?: SignatureLike): Signature;
+}
+export {};
+//# sourceMappingURL=signature.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/signature.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACR,YAAY,EAAE,SAAS,EAC1B,MAAM,mBAAmB,CAAC;AAa3B,QAAA,MAAM,OAAO,eAA2C,CAAC;AAMzD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG;IAC7C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,YAAY,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG;IACA,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACd,GAAG;IACA,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IACf,CAAC,CAAC,EAAE,YAAY,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAMF;;;;;GAKG;AACH,qBAAa,SAAS;;IAMlB;;;;;OAKG;IACH,IAAI,CAAC,IAAI,MAAM,CAAoB;IACnC,IAAI,CAAC,CAAC,KAAK,EAAE,SAAS,EAGrB;IAED;;OAEG;IACH,IAAI,CAAC,IAAI,MAAM,CAGd;IACD,IAAI,CAAC,CAAC,MAAM,EAAE,SAAS,EAGtB;IAED;;;;;;;OAOG;IACH,IAAI,EAAE,IAAI,MAAM,CAAoB;IAEpC;;OAEG;IACH,OAAO,IAAI,OAAO;IAKlB;;;;;;;;;OASG;IACH,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,CAAoB;IACpC,IAAI,CAAC,CAAC,KAAK,EAAE,YAAY,EAIxB;IAED;;;OAGG;IACH,IAAI,QAAQ,IAAI,IAAI,GAAG,MAAM,CAA2B;IAExD;;;OAGG;IACH,IAAI,aAAa,IAAI,IAAI,GAAG,MAAM,CAIjC;IAED;;;;OAIG;IACH,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,CAEnB;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,MAAM,CAKxB;IAED;;OAEG;IACH,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;gBACS,KAAK,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE;IAQxD;;;;;;OAMG;IACH,YAAY,IAAI,SAAS;IAczB;;OAEG;IACH,KAAK,IAAI,SAAS;IAMlB;;OAEG;IACH,MAAM,IAAI,GAAG;IASb,CAAC,OAAO,CAAC,IAAI,MAAM;IAInB,QAAQ,IAAI,MAAM;IAOlB;;;;;;;;;OASG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM;IAY1C;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,MAAM;IAI7D;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,YAAY,GAAG,EAAE,GAAG,EAAE;IAY/C;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,aAAa,GAAG,SAAS;CAqF9C"}

dev/env/node_modules/ethers/lib.commonjs/crypto/signature.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Signature = void 0;
+const index_js_1 = require("../constants/index.js");
+const index_js_2 = require("../utils/index.js");
+// Constants
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const BN_2 = BigInt(2);
+const BN_27 = BigInt(27);
+const BN_28 = BigInt(28);
+const BN_35 = BigInt(35);
+const BN_N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
+const BN_N_2 = BN_N / BN_2; // Must be integer (floor) division; do NOT shifts
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+const _guard = {};
+function toUint256(value) {
+    return (0, index_js_2.zeroPadValue)((0, index_js_2.toBeArray)(value), 32);
+}
+/**
+ *  A Signature  @TODO
+ *
+ *
+ *  @_docloc: api/crypto:Signing
+ */
+class Signature {
+    #r;
+    #s;
+    #v;
+    #networkV;
+    /**
+     *  The ``r`` value for a signature.
+     *
+     *  This represents the ``x`` coordinate of a "reference" or
+     *  challenge point, from which the ``y`` can be computed.
+     */
+    get r() { return this.#r; }
+    set r(value) {
+        (0, index_js_2.assertArgument)((0, index_js_2.dataLength)(value) === 32, "invalid r", "value", value);
+        this.#r = (0, index_js_2.hexlify)(value);
+    }
+    /**
+     *  The ``s`` value for a signature.
+     */
+    get s() {
+        (0, index_js_2.assertArgument)(parseInt(this.#s.substring(0, 3)) < 8, "non-canonical s; use ._s", "s", this.#s);
+        return this.#s;
+    }
+    set s(_value) {
+        (0, index_js_2.assertArgument)((0, index_js_2.dataLength)(_value) === 32, "invalid s", "value", _value);
+        this.#s = (0, index_js_2.hexlify)(_value);
+    }
+    /**
+     *  Return the s value, unchecked for EIP-2 compliance.
+     *
+     *  This should generally not be used and is for situations where
+     *  a non-canonical S value might be relevant, such as Frontier blocks
+     *  that were mined prior to EIP-2 or invalid Authorization List
+     *  signatures.
+     */
+    get _s() { return this.#s; }
+    /**
+     *  Returns true if the Signature is valid for [[link-eip-2]] signatures.
+     */
+    isValid() {
+        const s = BigInt(this.#s);
+        return (s <= BN_N_2);
+    }
+    /**
+     *  The ``v`` value for a signature.
+     *
+     *  Since a given ``x`` value for ``r`` has two possible values for
+     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
+     *  values to use.
+     *
+     *  It is normalized to the values ``27`` or ``28`` for legacy
+     *  purposes.
+     */
+    get v() { return this.#v; }
+    set v(value) {
+        const v = (0, index_js_2.getNumber)(value, "value");
+        (0, index_js_2.assertArgument)(v === 27 || v === 28, "invalid v", "v", value);
+        this.#v = v;
+    }
+    /**
+     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get networkV() { return this.#networkV; }
+    /**
+     *  The chain ID for EIP-155 legacy transactions. For non-legacy
+     *  transactions, this value is ``null``.
+     */
+    get legacyChainId() {
+        const v = this.networkV;
+        if (v == null) {
+            return null;
+        }
+        return Signature.getChainId(v);
+    }
+    /**
+     *  The ``yParity`` for the signature.
+     *
+     *  See ``v`` for more details on how this value is used.
+     */
+    get yParity() {
+        return (this.v === 27) ? 0 : 1;
+    }
+    /**
+     *  The [[link-eip-2098]] compact representation of the ``yParity``
+     *  and ``s`` compacted into a single ``bytes32``.
+     */
+    get yParityAndS() {
+        // The EIP-2098 compact representation
+        const yParityAndS = (0, index_js_2.getBytes)(this.s);
+        if (this.yParity) {
+            yParityAndS[0] |= 0x80;
+        }
+        return (0, index_js_2.hexlify)(yParityAndS);
+    }
+    /**
+     *  The [[link-eip-2098]] compact representation.
+     */
+    get compactSerialized() {
+        return (0, index_js_2.concat)([this.r, this.yParityAndS]);
+    }
+    /**
+     *  The serialized representation.
+     */
+    get serialized() {
+        return (0, index_js_2.concat)([this.r, this.s, (this.yParity ? "0x1c" : "0x1b")]);
+    }
+    /**
+     *  @private
+     */
+    constructor(guard, r, s, v) {
+        (0, index_js_2.assertPrivate)(guard, _guard, "Signature");
+        this.#r = r;
+        this.#s = s;
+        this.#v = v;
+        this.#networkV = null;
+    }
+    /**
+     *  Returns the canonical signature.
+     *
+     *  This is only necessary when dealing with legacy transaction which
+     *  did not enforce canonical S values (i.e. [[link-eip-2]]. Most
+     *  developers should never require this.
+     */
+    getCanonical() {
+        if (this.isValid()) {
+            return this;
+        }
+        // Compute the canonical signature; s' = N - s, v = !v
+        const s = BN_N - BigInt(this._s);
+        const v = (55 - this.v);
+        const result = new Signature(_guard, this.r, toUint256(s), v);
+        // Populate the networkV if necessary
+        if (this.networkV) {
+            result.#networkV = this.networkV;
+        }
+        return result;
+    }
+    /**
+     *  Returns a new identical [[Signature]].
+     */
+    clone() {
+        const clone = new Signature(_guard, this.r, this._s, this.v);
+        if (this.networkV) {
+            clone.#networkV = this.networkV;
+        }
+        return clone;
+    }
+    /**
+     *  Returns a representation that is compatible with ``JSON.stringify``.
+     */
+    toJSON() {
+        const networkV = this.networkV;
+        return {
+            _type: "signature",
+            networkV: ((networkV != null) ? networkV.toString() : null),
+            r: this.r, s: this._s, v: this.v,
+        };
+    }
+    [inspect]() {
+        return this.toString();
+    }
+    toString() {
+        if (this.isValid()) {
+            return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v} }`;
+        }
+        return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v}, valid: false }`;
+    }
+    /**
+     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
+     *
+     *  @example:
+     *    Signature.getChainId(45)
+     *    //_result:
+     *
+     *    Signature.getChainId(46)
+     *    //_result:
+     */
+    static getChainId(v) {
+        const bv = (0, index_js_2.getBigInt)(v, "v");
+        // The v is not an EIP-155 v, so it is the unspecified chain ID
+        if ((bv == BN_27) || (bv == BN_28)) {
+            return BN_0;
+        }
+        // Bad value for an EIP-155 v
+        (0, index_js_2.assertArgument)(bv >= BN_35, "invalid EIP-155 v", "v", v);
+        return (bv - BN_35) / BN_2;
+    }
+    /**
+     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
+     *
+     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
+     *  property to include the chain ID.
+     *
+     *  @example:
+     *    Signature.getChainIdV(5, 27)
+     *    //_result:
+     *
+     *    Signature.getChainIdV(5, 28)
+     *    //_result:
+     *
+     */
+    static getChainIdV(chainId, v) {
+        return ((0, index_js_2.getBigInt)(chainId) * BN_2) + BigInt(35 + v - 27);
+    }
+    /**
+     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
+     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
+     *
+     *  @example:
+     *    // The values 0 and 1 imply v is actually yParity
+     *    Signature.getNormalizedV(0)
+     *    //_result:
+     *
+     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
+     *    Signature.getNormalizedV(27)
+     *    //_result:
+     *
+     *    // Legacy EIP-155 transaction (i.e. >= 35)
+     *    Signature.getNormalizedV(46)
+     *    //_result:
+     *
+     *    // Invalid values throw
+     *    Signature.getNormalizedV(5)
+     *    //_error:
+     */
+    static getNormalizedV(v) {
+        const bv = (0, index_js_2.getBigInt)(v);
+        if (bv === BN_0 || bv === BN_27) {
+            return 27;
+        }
+        if (bv === BN_1 || bv === BN_28) {
+            return 28;
+        }
+        (0, index_js_2.assertArgument)(bv >= BN_35, "invalid v", "v", v);
+        // Otherwise, EIP-155 v means odd is 27 and even is 28
+        return (bv & BN_1) ? 27 : 28;
+    }
+    /**
+     *  Creates a new [[Signature]].
+     *
+     *  If no %%sig%% is provided, a new [[Signature]] is created
+     *  with default values.
+     *
+     *  If %%sig%% is a string, it is parsed.
+     */
+    static from(sig) {
+        function assertError(check, message) {
+            (0, index_js_2.assertArgument)(check, message, "signature", sig);
+        }
+        ;
+        if (sig == null) {
+            return new Signature(_guard, index_js_1.ZeroHash, index_js_1.ZeroHash, 27);
+        }
+        if (typeof (sig) === "string") {
+            const bytes = (0, index_js_2.getBytes)(sig, "signature");
+            if (bytes.length === 64) {
+                const r = (0, index_js_2.hexlify)(bytes.slice(0, 32));
+                const s = bytes.slice(32, 64);
+                const v = (s[0] & 0x80) ? 28 : 27;
+                s[0] &= 0x7f;
+                return new Signature(_guard, r, (0, index_js_2.hexlify)(s), v);
+            }
+            if (bytes.length === 65) {
+                const r = (0, index_js_2.hexlify)(bytes.slice(0, 32));
+                const s = (0, index_js_2.hexlify)(bytes.slice(32, 64));
+                const v = Signature.getNormalizedV(bytes[64]);
+                return new Signature(_guard, r, s, v);
+            }
+            assertError(false, "invalid raw signature length");
+        }
+        if (sig instanceof Signature) {
+            return sig.clone();
+        }
+        // Get r
+        const _r = sig.r;
+        assertError(_r != null, "missing r");
+        const r = toUint256(_r);
+        // Get s; by any means necessary (we check consistency below)
+        const s = (function (s, yParityAndS) {
+            if (s != null) {
+                return toUint256(s);
+            }
+            if (yParityAndS != null) {
+                assertError((0, index_js_2.isHexString)(yParityAndS, 32), "invalid yParityAndS");
+                const bytes = (0, index_js_2.getBytes)(yParityAndS);
+                bytes[0] &= 0x7f;
+                return (0, index_js_2.hexlify)(bytes);
+            }
+            assertError(false, "missing s");
+        })(sig.s, sig.yParityAndS);
+        // Get v; by any means necessary (we check consistency below)
+        const { networkV, v } = (function (_v, yParityAndS, yParity) {
+            if (_v != null) {
+                const v = (0, index_js_2.getBigInt)(_v);
+                return {
+                    networkV: ((v >= BN_35) ? v : undefined),
+                    v: Signature.getNormalizedV(v)
+                };
+            }
+            if (yParityAndS != null) {
+                assertError((0, index_js_2.isHexString)(yParityAndS, 32), "invalid yParityAndS");
+                return { v: (((0, index_js_2.getBytes)(yParityAndS)[0] & 0x80) ? 28 : 27) };
+            }
+            if (yParity != null) {
+                switch ((0, index_js_2.getNumber)(yParity, "sig.yParity")) {
+                    case 0: return { v: 27 };
+                    case 1: return { v: 28 };
+                }
+                assertError(false, "invalid yParity");
+            }
+            assertError(false, "missing v");
+        })(sig.v, sig.yParityAndS, sig.yParity);
+        const result = new Signature(_guard, r, s, v);
+        if (networkV) {
+            result.#networkV = networkV;
+        }
+        // If multiple of v, yParity, yParityAndS we given, check they match
+        assertError(sig.yParity == null || (0, index_js_2.getNumber)(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
+        assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
+        return result;
+    }
+}
+exports.Signature = Signature;
+//# sourceMappingURL=signature.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/signing-key.d.ts

@@ -0,0 +1,122 @@
+/**
+ *  Add details about signing here.
+ *
+ *  @_subsection: api/crypto:Signing  [about-signing]
+ */
+import { Signature } from "./signature.js";
+import type { BytesLike } from "../utils/index.js";
+import type { SignatureLike } from "./index.js";
+/**
+ *  A **SigningKey** provides high-level access to the elliptic curve
+ *  cryptography (ECC) operations and key management.
+ */
+export declare class SigningKey {
+    #private;
+    /**
+     *  Creates a new **SigningKey** for %%privateKey%%.
+     */
+    constructor(privateKey: BytesLike);
+    /**
+     *  The private key.
+     */
+    get privateKey(): string;
+    /**
+     *  The uncompressed public key.
+     *
+     * This will always begin with the prefix ``0x04`` and be 132
+     * characters long (the ``0x`` prefix and 130 hexadecimal nibbles).
+     */
+    get publicKey(): string;
+    /**
+     *  The compressed public key.
+     *
+     *  This will always begin with either the prefix ``0x02`` or ``0x03``
+     *  and be 68 characters long (the ``0x`` prefix and 33 hexadecimal
+     *  nibbles)
+     */
+    get compressedPublicKey(): string;
+    /**
+     *  Return the signature of the signed %%digest%%.
+     */
+    sign(digest: BytesLike): Signature;
+    /**
+     *  Returns the [[link-wiki-ecdh]] shared secret between this
+     *  private key and the %%other%% key.
+     *
+     *  The %%other%% key may be any type of key, a raw public key,
+     *  a compressed/uncompressed pubic key or aprivate key.
+     *
+     *  Best practice is usually to use a cryptographic hash on the
+     *  returned value before using it as a symetric secret.
+     *
+     *  @example:
+     *    sign1 = new SigningKey(id("some-secret-1"))
+     *    sign2 = new SigningKey(id("some-secret-2"))
+     *
+     *    // Notice that privA.computeSharedSecret(pubB)...
+     *    sign1.computeSharedSecret(sign2.publicKey)
+     *    //_result:
+     *
+     *    // ...is equal to privB.computeSharedSecret(pubA).
+     *    sign2.computeSharedSecret(sign1.publicKey)
+     *    //_result:
+     */
+    computeSharedSecret(other: BytesLike): string;
+    /**
+     *  Compute the public key for %%key%%, optionally %%compressed%%.
+     *
+     *  The %%key%% may be any type of key, a raw public key, a
+     *  compressed/uncompressed public key or private key.
+     *
+     *  @example:
+     *    sign = new SigningKey(id("some-secret"));
+     *
+     *    // Compute the uncompressed public key for a private key
+     *    SigningKey.computePublicKey(sign.privateKey)
+     *    //_result:
+     *
+     *    // Compute the compressed public key for a private key
+     *    SigningKey.computePublicKey(sign.privateKey, true)
+     *    //_result:
+     *
+     *    // Compute the uncompressed public key
+     *    SigningKey.computePublicKey(sign.publicKey, false);
+     *    //_result:
+     *
+     *    // Compute the Compressed a public key
+     *    SigningKey.computePublicKey(sign.publicKey, true);
+     *    //_result:
+     */
+    static computePublicKey(key: BytesLike, compressed?: boolean): string;
+    /**
+     *  Returns the public key for the private key which produced the
+     *  %%signature%% for the given %%digest%%.
+     *
+     *  @example:
+     *    key = new SigningKey(id("some-secret"))
+     *    digest = id("hello world")
+     *    sig = key.sign(digest)
+     *
+     *    // Notice the signer public key...
+     *    key.publicKey
+     *    //_result:
+     *
+     *    // ...is equal to the recovered public key
+     *    SigningKey.recoverPublicKey(digest, sig)
+     *    //_result:
+     *
+     */
+    static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string;
+    /**
+     *  Returns the point resulting from adding the ellipic curve points
+     *  %%p0%% and %%p1%%.
+     *
+     *  This is not a common function most developers should require, but
+     *  can be useful for certain privacy-specific techniques.
+     *
+     *  For example, it is used by [[HDNodeWallet]] to compute child
+     *  addresses from parent public keys and chain codes.
+     */
+    static addPoints(p0: BytesLike, p1: BytesLike, compressed?: boolean): string;
+}
+//# sourceMappingURL=signing-key.d.ts.map

dev/env/node_modules/ethers/lib.commonjs/crypto/signing-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-key.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/signing-key.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAGhD;;;GAGG;AACH,qBAAa,UAAU;;IAGnB;;OAEG;gBACS,UAAU,EAAE,SAAS;IAKjC;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAA6B;IAErD;;;;;OAKG;IACH,IAAI,SAAS,IAAI,MAAM,CAA0D;IAEjF;;;;;;OAMG;IACH,IAAI,mBAAmB,IAAI,MAAM,CAAgE;IAEjG;;OAEG;IACH,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS;IAclC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,mBAAmB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IAK7C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM;IAqBrE;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,GAAG,MAAM;IAc5E;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM;CAK/E"}

dev/env/node_modules/ethers/lib.commonjs/crypto/signing-key.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ *  Add details about signing here.
+ *
+ *  @_subsection: api/crypto:Signing  [about-signing]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigningKey = void 0;
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const index_js_1 = require("../utils/index.js");
+const signature_js_1 = require("./signature.js");
+/**
+ *  A **SigningKey** provides high-level access to the elliptic curve
+ *  cryptography (ECC) operations and key management.
+ */
+class SigningKey {
+    #privateKey;
+    /**
+     *  Creates a new **SigningKey** for %%privateKey%%.
+     */
+    constructor(privateKey) {
+        (0, index_js_1.assertArgument)((0, index_js_1.dataLength)(privateKey) === 32, "invalid private key", "privateKey", "[REDACTED]");
+        this.#privateKey = (0, index_js_1.hexlify)(privateKey);
+    }
+    /**
+     *  The private key.
+     */
+    get privateKey() { return this.#privateKey; }
+    /**
+     *  The uncompressed public key.
+     *
+     * This will always begin with the prefix ``0x04`` and be 132
+     * characters long (the ``0x`` prefix and 130 hexadecimal nibbles).
+     */
+    get publicKey() { return SigningKey.computePublicKey(this.#privateKey); }
+    /**
+     *  The compressed public key.
+     *
+     *  This will always begin with either the prefix ``0x02`` or ``0x03``
+     *  and be 68 characters long (the ``0x`` prefix and 33 hexadecimal
+     *  nibbles)
+     */
+    get compressedPublicKey() { return SigningKey.computePublicKey(this.#privateKey, true); }
+    /**
+     *  Return the signature of the signed %%digest%%.
+     */
+    sign(digest) {
+        (0, index_js_1.assertArgument)((0, index_js_1.dataLength)(digest) === 32, "invalid digest length", "digest", digest);
+        const sig = secp256k1_1.secp256k1.sign((0, index_js_1.getBytesCopy)(digest), (0, index_js_1.getBytesCopy)(this.#privateKey), {
+            lowS: true
+        });
+        return signature_js_1.Signature.from({
+            r: (0, index_js_1.toBeHex)(sig.r, 32),
+            s: (0, index_js_1.toBeHex)(sig.s, 32),
+            v: (sig.recovery ? 0x1c : 0x1b)
+        });
+    }
+    /**
+     *  Returns the [[link-wiki-ecdh]] shared secret between this
+     *  private key and the %%other%% key.
+     *
+     *  The %%other%% key may be any type of key, a raw public key,
+     *  a compressed/uncompressed pubic key or aprivate key.
+     *
+     *  Best practice is usually to use a cryptographic hash on the
+     *  returned value before using it as a symetric secret.
+     *
+     *  @example:
+     *    sign1 = new SigningKey(id("some-secret-1"))
+     *    sign2 = new SigningKey(id("some-secret-2"))
+     *
+     *    // Notice that privA.computeSharedSecret(pubB)...
+     *    sign1.computeSharedSecret(sign2.publicKey)
+     *    //_result:
+     *
+     *    // ...is equal to privB.computeSharedSecret(pubA).
+     *    sign2.computeSharedSecret(sign1.publicKey)
+     *    //_result:
+     */
+    computeSharedSecret(other) {
+        const pubKey = SigningKey.computePublicKey(other);
+        return (0, index_js_1.hexlify)(secp256k1_1.secp256k1.getSharedSecret((0, index_js_1.getBytesCopy)(this.#privateKey), (0, index_js_1.getBytes)(pubKey), false));
+    }
+    /**
+     *  Compute the public key for %%key%%, optionally %%compressed%%.
+     *
+     *  The %%key%% may be any type of key, a raw public key, a
+     *  compressed/uncompressed public key or private key.
+     *
+     *  @example:
+     *    sign = new SigningKey(id("some-secret"));
+     *
+     *    // Compute the uncompressed public key for a private key
+     *    SigningKey.computePublicKey(sign.privateKey)
+     *    //_result:
+     *
+     *    // Compute the compressed public key for a private key
+     *    SigningKey.computePublicKey(sign.privateKey, true)
+     *    //_result:
+     *
+     *    // Compute the uncompressed public key
+     *    SigningKey.computePublicKey(sign.publicKey, false);
+     *    //_result:
+     *
+     *    // Compute the Compressed a public key
+     *    SigningKey.computePublicKey(sign.publicKey, true);
+     *    //_result:
+     */
+    static computePublicKey(key, compressed) {
+        let bytes = (0, index_js_1.getBytes)(key, "key");
+        // private key
+        if (bytes.length === 32) {
+            const pubKey = secp256k1_1.secp256k1.getPublicKey(bytes, !!compressed);
+            return (0, index_js_1.hexlify)(pubKey);
+        }
+        // raw public key; use uncompressed key with 0x04 prefix
+        if (bytes.length === 64) {
+            const pub = new Uint8Array(65);
+            pub[0] = 0x04;
+            pub.set(bytes, 1);
+            bytes = pub;
+        }
+        const point = secp256k1_1.secp256k1.ProjectivePoint.fromHex(bytes);
+        return (0, index_js_1.hexlify)(point.toRawBytes(compressed));
+    }
+    /**
+     *  Returns the public key for the private key which produced the
+     *  %%signature%% for the given %%digest%%.
+     *
+     *  @example:
+     *    key = new SigningKey(id("some-secret"))
+     *    digest = id("hello world")
+     *    sig = key.sign(digest)
+     *
+     *    // Notice the signer public key...
+     *    key.publicKey
+     *    //_result:
+     *
+     *    // ...is equal to the recovered public key
+     *    SigningKey.recoverPublicKey(digest, sig)
+     *    //_result:
+     *
+     */
+    static recoverPublicKey(digest, signature) {
+        (0, index_js_1.assertArgument)((0, index_js_1.dataLength)(digest) === 32, "invalid digest length", "digest", digest);
+        const sig = signature_js_1.Signature.from(signature);
+        let secpSig = secp256k1_1.secp256k1.Signature.fromCompact((0, index_js_1.getBytesCopy)((0, index_js_1.concat)([sig.r, sig.s])));
+        secpSig = secpSig.addRecoveryBit(sig.yParity);
+        const pubKey = secpSig.recoverPublicKey((0, index_js_1.getBytesCopy)(digest));
+        (0, index_js_1.assertArgument)(pubKey != null, "invalid signature for digest", "signature", signature);
+        return "0x" + pubKey.toHex(false);
+    }
+    /**
+     *  Returns the point resulting from adding the ellipic curve points
+     *  %%p0%% and %%p1%%.
+     *
+     *  This is not a common function most developers should require, but
+     *  can be useful for certain privacy-specific techniques.
+     *
+     *  For example, it is used by [[HDNodeWallet]] to compute child
+     *  addresses from parent public keys and chain codes.
+     */
+    static addPoints(p0, p1, compressed) {
+        const pub0 = secp256k1_1.secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p0).substring(2));
+        const pub1 = secp256k1_1.secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p1).substring(2));
+        return "0x" + pub0.add(pub1).toHex(!!compressed);
+    }
+}
+exports.SigningKey = SigningKey;
+//# sourceMappingURL=signing-key.js.map

dev/env/node_modules/ethers/lib.commonjs/crypto/signing-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing-key.js","sourceRoot":"","sources":["../../src.ts/crypto/signing-key.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,uDAAoD;AAEpD,gDAG2B;AAE3B,iDAA2C;AAO3C;;;GAGG;AACH,MAAa,UAAU;IACnB,WAAW,CAAS;IAEpB;;OAEG;IACH,YAAY,UAAqB;QAC7B,IAAA,yBAAc,EAAC,IAAA,qBAAU,EAAC,UAAU,CAAC,KAAK,EAAE,EAAE,qBAAqB,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;QACjG,IAAI,CAAC,WAAW,GAAG,IAAA,kBAAO,EAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,IAAI,UAAU,KAAa,OAAO,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;IAErD;;;;;OAKG;IACH,IAAI,SAAS,KAAa,OAAO,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAEjF;;;;;;OAMG;IACH,IAAI,mBAAmB,KAAa,OAAO,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAEjG;;OAEG;IACH,IAAI,CAAC,MAAiB;QAClB,IAAA,yBAAc,EAAC,IAAA,qBAAU,EAAC,MAAM,CAAC,KAAK,EAAE,EAAE,uBAAuB,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAErF,MAAM,GAAG,GAAG,qBAAS,CAAC,IAAI,CAAC,IAAA,uBAAY,EAAC,MAAM,CAAC,EAAE,IAAA,uBAAY,EAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC7E,IAAI,EAAE,IAAI;SACb,CAAC,CAAC;QAEH,OAAO,wBAAS,CAAC,IAAI,CAAC;YAClB,CAAC,EAAE,IAAA,kBAAO,EAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;YACrB,CAAC,EAAE,IAAA,kBAAO,EAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;YACrB,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA,CAAC,CAAC,IAAI,CAAC;SACjC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,mBAAmB,CAAC,KAAgB;QAChC,MAAM,MAAM,GAAG,UAAU,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAClD,OAAO,IAAA,kBAAO,EAAC,qBAAS,CAAC,eAAe,CAAC,IAAA,uBAAY,EAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAA,mBAAQ,EAAC,MAAM,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IACvG,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,gBAAgB,CAAC,GAAc,EAAE,UAAoB;QACxD,IAAI,KAAK,GAAG,IAAA,mBAAQ,EAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAEjC,cAAc;QACd,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE;YACrB,MAAM,MAAM,GAAG,qBAAS,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC;YAC3D,OAAO,IAAA,kBAAO,EAAC,MAAM,CAAC,CAAC;SAC1B;QAED,wDAAwD;QACxD,IAAI,KAAK,CAAC,MAAM,KAAK,EAAE,EAAE;YACrB,MAAM,GAAG,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;YAC/B,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YACd,GAAG,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAClB,KAAK,GAAG,GAAG,CAAC;SACf;QAED,MAAM,KAAK,GAAG,qBAAS,CAAC,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvD,OAAO,IAAA,kBAAO,EAAC,KAAK,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,gBAAgB,CAAC,MAAiB,EAAE,SAAwB;QAC/D,IAAA,yBAAc,EAAC,IAAA,qBAAU,EAAC,MAAM,CAAC,KAAK,EAAE,EAAE,uBAAuB,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAErF,MAAM,GAAG,GAAG,wBAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEtC,IAAI,OAAO,GAAG,qBAAS,CAAC,SAAS,CAAC,WAAW,CAAC,IAAA,uBAAY,EAAC,IAAA,iBAAM,EAAC,CAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC;QACtF,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAE9C,MAAM,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,IAAA,uBAAY,EAAC,MAAM,CAAC,CAAC,CAAC;QAC9D,IAAA,yBAAc,EAAC,MAAM,IAAI,IAAI,EAAE,8BAA8B,EAAE,WAAW,EAAE,SAAS,CAAC,CAAC;QAEvF,OAAO,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,CAAC,EAAa,EAAE,EAAa,EAAE,UAAoB;QAC/D,MAAM,IAAI,GAAG,qBAAS,CAAC,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7F,MAAM,IAAI,GAAG,qBAAS,CAAC,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7F,OAAO,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,CAAC,CAAA;IACpD,CAAC;CACJ;AA1KD,gCA0KC"}