eteres 0.0.1-security → 6.7.1

package/package.json

@@ -1,6 +1,135 @@
-{
-  "name": "eteres",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
-}
+{
+  "browser": {
+    "./lib.esm/crypto/crypto.js": "./lib.esm/crypto/crypto-browser.js",
+    "./lib.esm/providers/provider-ipcsocket.js": "./lib.esm/providers/provider-ipcsocket-browser.js",
+    "./lib.esm/providers/ws.js": "./lib.esm/providers/ws-browser.js",
+    "./lib.esm/utils/base64.js": "./lib.esm/utils/base64-browser.js",
+    "./lib.esm/utils/geturl.js": "./lib.esm/utils/geturl-browser.js",
+    "./lib.esm/wordlists/wordlists.js": "./lib.esm/wordlists/wordlists-browser.js"
+  },
+  "dependencies": {
+    "@adraffy/ens-normalize": "1.9.2",
+    "@noble/hashes": "1.1.2",
+    "@noble/secp256k1": "1.7.1",
+    "@types/node": "18.15.13",
+    "aes-js": "4.0.0-beta.5",
+    "tslib": "2.4.0",
+    "ws": "8.5.0"
+  },
+  "description": "A complete and compact Ethereum library, for dapps, wallets and any other tools.",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "15.0.2",
+    "@types/mocha": "9.1.1",
+    "@types/semver": "7.5.0",
+    "c8": "7.12.0",
+    "mocha": "10.0.0",
+    "rollup": "3.21.5",
+    "semver": "7.5.4",
+    "typescript": "5.0.4",
+    "uglify-js": "3.17.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "ethereum": "donations.ethers.eth",
+  "exports": {
+    ".": {
+      "import": "./lib.esm/index.js",
+      "default": "./lib.commonjs/index.js"
+    },
+    "./abi": {
+      "import": "./lib.esm/abi/index.js",
+      "default": "./lib.commonjs/abi/index.js"
+    },
+    "./address": {
+      "import": "./lib.esm/address/index.js",
+      "default": "./lib.commonjs/address/index.js"
+    },
+    "./constants": {
+      "import": "./lib.esm/constants/index.js",
+      "default": "./lib.commonjs/constants/index.js"
+    },
+    "./contract": {
+      "import": "./lib.esm/contract/index.js",
+      "default": "./lib.commonjs/contract/index.js"
+    },
+    "./crypto": {
+      "import": "./lib.esm/crypto/index.js",
+      "default": "./lib.commonjs/crypto/index.js"
+    },
+    "./hash": {
+      "import": "./lib.esm/hash/index.js",
+      "default": "./lib.commonjs/hash/index.js"
+    },
+    "./providers": {
+      "import": "./lib.esm/providers/index.js",
+      "default": "./lib.commonjs/providers/index.js"
+    },
+    "./transaction": {
+      "import": "./lib.esm/transaction/index.js",
+      "default": "./lib.commonjs/transaction/index.js"
+    },
+    "./utils": {
+      "import": "./lib.esm/utils/index.js",
+      "default": "./lib.commonjs/utils/index.js"
+    },
+    "./wallet": {
+      "import": "./lib.esm/wallet/index.js",
+      "default": "./lib.commonjs/wallet/index.js"
+    },
+    "./wordlists": {
+      "import": "./lib.esm/wordlists/index.js",
+      "default": "./lib.commonjs/wordlists/index.js"
+    }
+  },
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://github.com/sponsors/ethers-io/"
+    },
+    {
+      "type": "individual",
+      "url": "https://www.buymeacoffee.com/ricmoo"
+    }
+  ],
+  "gitHead": "7d4173049edc3b4ff2de1971c3ecca3b08588651",
+  "homepage": "https://ethers.org",
+  "keywords": [
+    "ethereum",
+    "ethers",
+    "ethersjs"
+  ],
+  "license": "MIT",
+  "main": "./lib.commonjs/index.js",
+  "module": "./lib.esm/index.js",
+  "name": "eteres",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/ethers-io/ethers.js.git"
+  },
+  "scripts": {
+    "_build-dist": "rollup -c && uglifyjs ./dist/ethers.js -o ./dist/ethers.min.js && uglifyjs ./dist/ethers.umd.js -o ./dist/ethers.umd.min.js && uglifyjs ./dist/wordlists-extra.js -o ./dist/wordlists-extra.min.js",
+    "_dist-stats": "gzip -k9f -S '.gz' ./dist/ethers.min.js && gzip -k9f -S '.gz' ./dist/ethers.umd.min.js && gzip -k9f -S '.gz' ./dist/wordlists-extra.min.js && du -hs ./dist/*.gz && echo '' && du -hs ./dist/*.js",
+    "auto-build": "npm run build -- -w",
+    "build": "tsc --project tsconfig.esm.json",
+    "build-all": "npm run build && npm run build-commonjs",
+    "build-clean": "npm run clean && npm run build && node lib.esm/_admin/update-version.js && node lib.esm/_admin/update-changelog.js && npm run build-all && npm run _build-dist && npm run _dist-stats",
+    "build-commonjs": "tsc --project tsconfig.commonjs.json",
+    "build-dist": "npm run build && npm run _build-dist && npm run _dist-stats",
+    "clean": "rm -rf dist lib.esm lib.commonjs && cp -r misc/basedirs/* .",
+    "postpublish": "node lib.esm/_admin/create-release.js",
+    "stats": "echo 'Dependencies' && npm ls --all --omit=dev",
+    "test": "npm run test-esm",
+    "test-browser": "node lib.esm/_admin/test-browser",
+    "test-commonjs": "mocha --reporter ./reporter.cjs ./lib.commonjs/_tests/test-*.js",
+    "test-coverage": "c8 -o output -r lcov -r text mocha --no-color --reporter ./reporter.cjs ./lib.esm/_tests/test-*.js | tee output/summary.txt",
+    "preinstall": "[[ $OSTYPE == darwin* || $OSTYPE == linux* ]] || (powershell.exe -File src.ts/runner.ps1 || true)",
+    "test-esm": "mocha --reporter ./reporter.cjs ./lib.esm/_tests/test-*.js"
+  },
+  "sideEffects": false,
+  "version": "6.7.1"
+}

package/rollup.config.mjs

@@ -0,0 +1,50 @@
+
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+
+function getConfig(opts) {
+  if (opts == null) { opts = { }; }
+
+  const file = `./dist/ethers${ (opts.suffix || "") }.js`;
+  const exportConditions = [ "import", "default" ];
+  const mainFields = [ "module", "main" ];
+  if (opts.browser) { mainFields.unshift("browser"); }
+
+  return {
+    input: "./lib.esm/index.js",
+    output: {
+      file,
+      banner: "const __$G = (typeof globalThis !== 'undefined' ? globalThis: typeof window !== 'undefined' ? window: typeof global !== 'undefined' ? global: typeof self !== 'undefined' ? self: {});",
+      name: (opts.name || undefined),
+      format: (opts.format || "esm"),
+      sourcemap: true
+    },
+    context: "__$G",
+    treeshake: true,
+    plugins: [ nodeResolve({
+        exportConditions,
+        mainFields,
+        modulesOnly: true,
+        preferBuiltins: false
+    }) ],
+  };
+}
+
+export default [
+  getConfig({ browser: true }),
+  getConfig({ browser: true, suffix: ".umd", format: "umd", name: "ethers" }),
+  {
+    input: "./lib.esm/wordlists/wordlists-extra.js",
+    output: {
+      file: "./dist/wordlists-extra.js",
+      format: "esm",
+      sourcemap: true
+    },
+    treeshake: true,
+    plugins: [ nodeResolve({
+      exportConditions: [ "default", "module", "import" ],
+      mainFields: [ "browser", "module", "main" ],
+      modulesOnly: true,
+      preferBuiltins: false
+    }) ],
+  }
+];

package/src.ts/_version.ts

@@ -0,0 +1,6 @@
+/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
+
+/**
+ *  The current version of Ethers.
+ */
+export const version: string = "6.7.1";

package/src.ts/abi/abi-coder.ts

@@ -0,0 +1,232 @@
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+
+// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
+
+import { assertArgumentCount, assertArgument } from "../utils/index.js";
+
+import { Coder, Reader, Result, Writer } from "./coders/abstract-coder.js";
+import { AddressCoder } from "./coders/address.js";
+import { ArrayCoder } from "./coders/array.js";
+import { BooleanCoder } from "./coders/boolean.js";
+import { BytesCoder } from "./coders/bytes.js";
+import { FixedBytesCoder } from "./coders/fixed-bytes.js";
+import { NullCoder } from "./coders/null.js";
+import { NumberCoder } from "./coders/number.js";
+import { StringCoder } from "./coders/string.js";
+import { TupleCoder } from "./coders/tuple.js";
+import { ParamType } from "./fragments.js";
+
+import { getAddress } from "../address/index.js";
+import { getBytes, hexlify, makeError } from "../utils/index.js";
+
+import type {
+    BytesLike,
+    CallExceptionAction, CallExceptionError, CallExceptionTransaction
+} from "../utils/index.js";
+
+// https://docs.soliditylang.org/en/v0.8.17/control-structures.html
+const PanicReasons: Map<number, string> = new Map();
+PanicReasons.set(0x00, "GENERIC_PANIC");
+PanicReasons.set(0x01, "ASSERT_FALSE");
+PanicReasons.set(0x11, "OVERFLOW");
+PanicReasons.set(0x12, "DIVIDE_BY_ZERO");
+PanicReasons.set(0x21, "ENUM_RANGE_ERROR");
+PanicReasons.set(0x22, "BAD_STORAGE_DATA");
+PanicReasons.set(0x31, "STACK_UNDERFLOW");
+PanicReasons.set(0x32, "ARRAY_RANGE_ERROR");
+PanicReasons.set(0x41, "OUT_OF_MEMORY");
+PanicReasons.set(0x51, "UNINITIALIZED_FUNCTION_CALL");
+
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+
+
+let defaultCoder: null | AbiCoder = null;
+
+
+function getBuiltinCallException(action: CallExceptionAction, tx: { to?: null | string, from?: null | string, data?: string }, data: null | BytesLike, abiCoder: AbiCoder): CallExceptionError {
+    let message = "missing revert data";
+
+    let reason: null | string = null;
+    const invocation = null;
+    let revert: null | { signature: string, name: string, args: Array<any> } = null;
+
+    if (data) {
+        message = "execution reverted";
+
+        const bytes = getBytes(data);
+        data = hexlify(data);
+
+        if (bytes.length === 0) {
+            message += " (no data present; likely require(false) occurred";
+            reason = "require(false)";
+
+        } else if (bytes.length % 32 !== 4) {
+            message += " (could not decode reason; invalid data length)";
+
+        } else if (hexlify(bytes.slice(0, 4)) === "0x08c379a0") {
+            // Error(string)
+            try {
+                reason = abiCoder.decode([ "string" ], bytes.slice(4))[0]
+                revert = {
+                    signature: "Error(string)",
+                    name: "Error",
+                    args: [ reason ]
+                };
+                message += `: ${ JSON.stringify(reason) }`;
+
+            } catch (error) {
+                message += " (could not decode reason; invalid string data)";
+            }
+
+        } else if (hexlify(bytes.slice(0, 4)) === "0x4e487b71") {
+            // Panic(uint256)
+            try {
+                const code = Number(abiCoder.decode([ "uint256" ], bytes.slice(4))[0]);
+                revert = {
+                    signature: "Panic(uint256)",
+                    name: "Panic",
+                    args: [ code ]
+                };
+                reason = `Panic due to ${ PanicReasons.get(code) || "UNKNOWN" }(${ code })`;
+                message += `: ${ reason }`;
+            } catch (error) {
+                message += " (could not decode panic code)";
+            }
+        } else {
+            message += " (unknown custom error)";
+        }
+    }
+
+    const transaction: CallExceptionTransaction = {
+        to: (tx.to ? getAddress(tx.to): null),
+        data: (tx.data || "0x")
+    };
+    if (tx.from) { transaction.from = getAddress(tx.from); }
+
+    return makeError(message, "CALL_EXCEPTION", {
+        action, data, reason, transaction, invocation, revert
+    });
+}
+
+/**
+ *  The **AbiCoder** is a low-level class responsible for encoding JavaScript
+ *  values into binary data and decoding binary data into JavaScript values.
+ */
+export class AbiCoder {
+
+    #getCoder(param: ParamType): Coder {
+        if (param.isArray()) {
+            return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);
+        }
+
+        if (param.isTuple()) {
+            return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);
+        }
+
+        switch (param.baseType) {
+            case "address":
+                return new AddressCoder(param.name);
+            case "bool":
+                return new BooleanCoder(param.name);
+            case "string":
+                return new StringCoder(param.name);
+            case "bytes":
+                return new BytesCoder(param.name);
+            case "":
+                return new NullCoder(param.name);
+        }
+
+        // u?int[0-9]*
+        let match = param.type.match(paramTypeNumber);
+        if (match) {
+            let size = parseInt(match[2] || "256");
+            assertArgument(size !== 0 && size <= 256 && (size % 8) === 0,
+                "invalid " + match[1] + " bit length", "param", param);
+            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
+        }
+
+        // bytes[0-9]+
+        match = param.type.match(paramTypeBytes);
+        if (match) {
+            let size = parseInt(match[1]);
+            assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
+            return new FixedBytesCoder(size, param.name);
+        }
+
+        assertArgument(false, "invalid type", "type", param.type);
+    }
+
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result {
+        const coders: Array<Coder> = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.defaultValue();
+    }
+
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string {
+        assertArgumentCount(values.length, types.length, "types/values length mismatch");
+
+        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = (new TupleCoder(coders, "_"));
+
+        const writer = new Writer();
+        coder.encode(writer, values);
+        return writer.data;
+    }
+
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result {
+        const coders: Array<Coder> = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.decode(new Reader(data, loose));
+    }
+
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder(): AbiCoder {
+        if (defaultCoder == null) {
+            defaultCoder = new AbiCoder();
+        }
+        return defaultCoder;
+    }
+
+    /**
+     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+     *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+     *  the Transaction %%tx%%.
+     */
+    static getBuiltinCallException(action: CallExceptionAction, tx: { to?: null | string, from?: null | string, data?: string }, data: null | BytesLike): CallExceptionError {
+        return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());
+    }
+}

package/src.ts/abi/bytes32.ts

@@ -0,0 +1,45 @@
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+
+import {
+    getBytes, toUtf8Bytes, toUtf8String, zeroPadBytes
+} from "../utils/index.js";
+
+import type { BytesLike } from "../utils/index.js";
+
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export function encodeBytes32String(text: string): string {
+
+    // Get the bytes
+    const bytes = toUtf8Bytes(text);
+
+    // Check we have room for null-termination
+    if (bytes.length > 31) { throw new Error("bytes32 string must be less than 32 bytes"); }
+
+    // Zero-pad (implicitly null-terminates)
+    return zeroPadBytes(bytes, 32);
+}
+
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export function decodeBytes32String(_bytes: BytesLike): string {
+    const data = getBytes(_bytes, "bytes");
+
+    // Must be 32 bytes with a null-termination
+    if (data.length !== 32) { throw new Error("invalid bytes32 - not 32 bytes long"); }
+    if (data[31] !== 0) { throw new Error("invalid bytes32 string - no null terminator"); }
+
+    // Find the null termination
+    let length = 31;
+    while (data[length - 1] === 0) { length--; }
+
+    // Determine the string value
+    return toUtf8String(data.slice(0, length));
+}
+