Merge branch 'wip-v6.16.0-ens' into wip-v6.17

ricmoo · ricmoo · commit 0e53d1b50635 · 2026-04-09T19:51:37.000-04:00
diff --git a/src.ts/providers/abstract-provider.ts b/src.ts/providers/abstract-provider.ts
@@ -14,15 +14,12 @@
 //   migrate the listener to the static event. We also need to maintain a map
 //   of Signer/ENS name to address so we can sync respond to listenerCount.
 
-import { getAddress, resolveAddress } from "../address/index.js";
-import { ZeroAddress } from "../constants/index.js";
-import { Contract } from "../contract/index.js";
-import { namehash } from "../hash/index.js";
+import { resolveAddress } from "../address/index.js";
 import { Transaction } from "../transaction/index.js";
 import {
     concat, dataLength, dataSlice, hexlify, isHexString,
     getBigInt, getBytes, getNumber,
-    isCallException, isError, makeError, assert, assertArgument,
+    isCallException, makeError, assert, assertArgument,
     FetchRequest,
     toBeArray, toQuantity,
     defineProperties, EventPayload, resolveProperties,
@@ -1189,60 +1186,24 @@ export class AbstractProvider implements Provider {
         });
     }
 
-    async getResolver(name: string): Promise<null | EnsResolver> {
-        return await EnsResolver.fromName(this, name);
+    async getResolver(name: string, preferUniversal?: boolean): Promise<null | EnsResolver> {
+        return await EnsResolver.fromName(this, name, preferUniversal);
     }
 
     async getAvatar(name: string): Promise<null | string> {
-        const resolver = await this.getResolver(name);
+        const resolver = await this.getResolver(name, true);
         if (resolver) { return await resolver.getAvatar(); }
         return null;
     }
 
     async resolveName(name: string): Promise<null | string>{
-        const resolver = await this.getResolver(name);
+        const resolver = await this.getResolver(name, true);
         if (resolver) { return await resolver.getAddress(); }
         return null;
     }
 
     async lookupAddress(address: string): Promise<null | string> {
-        address = getAddress(address);
-        const node = namehash(address.substring(2).toLowerCase() + ".addr.reverse");
-
-        try {
-
-            const ensAddr = await EnsResolver.getEnsAddress(this);
-            const ensContract = new Contract(ensAddr, [
-                "function resolver(bytes32) view returns (address)"
-            ], this);
-
-            const resolver = await ensContract.resolver(node);
-            if (resolver == null || resolver === ZeroAddress) { return null; }
-
-            const resolverContract = new Contract(resolver, [
-                "function name(bytes32) view returns (string)"
-            ], this);
-            const name = await resolverContract.name(node);
-
-            // Failed forward resolution
-            const check = await this.resolveName(name);
-            if (check !== address) { return null; }
-
-            return name;
-
-        } catch (error) {
-            // No data was returned from the resolver
-            if (isError(error, "BAD_DATA") && error.value === "0x") {
-                return null;
-            }
-
-            // Something reerted
-            if (isError(error, "CALL_EXCEPTION")) { return null; }
-
-            throw error;
-        }
-
-        return null;
+        return await EnsResolver.lookupAddress(this, address);
     }
 
     async waitForTransaction(hash: string, _confirms?: null | number, timeout?: null | number): Promise<null | TransactionReceipt> {
diff --git a/src.ts/providers/ens-resolver.ts b/src.ts/providers/ens-resolver.ts
@@ -175,11 +175,21 @@ export class EnsResolver {
     // For EIP-2544 names, the ancestor that provided the resolver
     #supports2544: null | Promise<boolean>;
 
-    #resolver: Contract;
+    readonly #resolver: Contract;
 
-    constructor(provider: AbstractProvider, address: string, name: string) {
+    readonly #universal: null | Contract;
+
+    constructor(provider: AbstractProvider, address: string, name: string, universalResolver?: boolean) {
         defineProperties<EnsResolver>(this, { provider, address, name });
-        this.#supports2544 = null;
+
+        if (universalResolver) {
+            this.#supports2544 = Promise.resolve(true);
+            this.#universal = createUniversal(provider, address);
+        } else {
+            this.#supports2544 = null;
+            this.#universal = null;
+        }
+
 
         this.#resolver = new Contract(address, [
             "function supportsInterface(bytes4) view returns (bool)",
@@ -238,18 +248,22 @@ export class EnsResolver {
             funcName = "resolve(bytes,bytes)";
         }
 
-        params.push({
-            enableCcipRead: true
-        });
+        params.push({ enableCcipRead: true });
 
         try {
-            const result = await this.#resolver[funcName](...params);
+            let result;
+            if (this.#universal) {
+                result = (await this.#universal.resolve(...params)).result;
+            } else {
+                result = await this.#resolver[funcName](...params);
+            }
 
             if (fragment) {
                 return iface.decodeFunctionResult(fragment, result)[0];
             }
 
             return result;
+
         } catch (error: any) {
             if (!isError(error, "CALL_EXCEPTION")) { throw error; }
         }
@@ -572,11 +586,86 @@ export class EnsResolver {
         return null;
     }
 
+    static async lookupAddress(provider: AbstractProvider, address: string, coinType?: number): Promise<null | string> {
+        address = getAddress(address);
+        if (coinType == null) { coinType = 60; }
+
+        // We have a Universal resolver, use it
+        const universal = await getUniversal(provider);
+        if (universal) {
+            const result = await universal.reverse(address, coinType, {
+                enableCcipRead: true
+            });
+
+            return result.primary || null;
+        }
+
+        // Use legacy reverse lookup
+
+        assert(coinType === 60, "lookupAddress coinType requires ENS Universal Resolver", "UNSUPPORTED_OPERATION", {
+            operation: "lookupAddress"
+        });
+
+        try {
+            // Legacy resolver uses namehash of the lowercase name
+            const node = namehash(`${ address.toLowerCase().substring(2) }.addr.reverse`);
+
+            const ensAddr = await EnsResolver.getEnsAddress(provider);
+            const ensContract = new Contract(ensAddr, [
+                "function resolver(bytes32) view returns (address)"
+            ], provider);
+
+            const resolver = await ensContract.resolver(node);
+            if (resolver == null || resolver === ZeroAddress) { return null; }
+
+            const resolverContract = new Contract(resolver, [
+                "function name(bytes32) view returns (string)"
+            ], provider);
+
+            const name = await resolverContract.name(node);
+
+            // Failed forward resolution
+            const check = await provider.resolveName(name);
+            if (check !== address) { return null; }
+            return name;
+
+        } catch (error) {
+            // No data was returned from the resolver
+            if (isError(error, "BAD_DATA") && error.value === "0x") {
+                return null;
+            }
+
+            // Something reverted
+            if (isError(error, "CALL_EXCEPTION")) { return null; }
+
+            throw error;
+        }
+
+        return null;
+    }
+
     /**
      *  Resolve to the ENS resolver for %%name%% using %%provider%% or
      *  ``null`` if unconfigured.
+     *
+     *  If %%preferUniversal%% and the network supports ENS Universal
+     *  Resolver, a resolver is always returned (even if the name doesn't
+     *  have one) and calls are resolved by it. The Universal Resolver is
+     *  more eth_call efficient, as it performs more on-chain, but is not
+     *  the actual resolver, if for example the setters are required.
      */
-    static async fromName(provider: AbstractProvider, name: string): Promise<null | EnsResolver> {
+    static async fromName(provider: AbstractProvider, name: string, preferUniversal?: boolean): Promise<null | EnsResolver> {
+
+        // We have a Universal Resolver, use it
+        const universal = await getUniversal(provider);
+        if (universal) {
+            if (preferUniversal) {
+                return new EnsResolver(provider, <string>universal.target, name, true);
+            }
+
+            const result = await universal.findResolver(dnsEncode(name));
+            return new EnsResolver(provider, result.resolver, name);
+        }
 
         let currentName = name;
         while (true) {
@@ -604,3 +693,23 @@ export class EnsResolver {
         }
     }
 }
+
+function createUniversal(provider: AbstractProvider, address: string): Contract {
+    return new Contract(address, [
+        "function findResolver(bytes) view returns (address resolver, bytes32 node, uint offset)",
+        "function resolve(bytes name, bytes data) view returns (bytes result, address resolver)",
+        "function reverse(bytes name, uint coinType) view returns (string primary, address resolver, address reverseResolver)",
+        "error HttpError(uint16 statusCode, string statusMessage)"
+    ], provider);
+}
+
+async function getUniversal(provider: AbstractProvider): Promise<null | Contract> {
+    const network = await provider.getNetwork();
+
+    const ensPlugin = network.getPlugin<EnsPlugin>("org.ethers.plugins.network.Ens");
+    if (ensPlugin && ensPlugin.universalResolver) {
+        return createUniversal(provider, ensPlugin.universalResolver);
+    }
+
+    return null;
+}
diff --git a/src.ts/providers/network.ts b/src.ts/providers/network.ts
@@ -18,6 +18,8 @@ import type { TransactionLike } from "../transaction/index.js";
 import type { NetworkPlugin } from "./plugins-network.js";
 
 
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+
 /**
  *  A Networkish can be used to allude to a Network, by specifing:
  *  - a [[Network]] object
@@ -31,6 +33,7 @@ export type Networkish = Network | number | bigint | string | {
     //layerOneConnection?: Provider,
     ensAddress?: string,
     ensNetwork?: number
+    ensUniversalResolver?: string;
 };
 
 
@@ -77,6 +80,16 @@ export class Network {
         this.#plugins = new Map();
     }
 
+    [inspect](): string { return this.toString(); }
+
+    toString(): string {
+        const plugins: Array<string> = [ ];
+        for (const plugin of this.#plugins.values()) {
+            plugins.push(plugin.toString());
+        }
+        return `Network { name: ${ this.name }, chainId: ${ this.chainId }, plugins: [ ${ plugins.join(", ") } ] }`
+    }
+
     /**
      *  Returns a JSON-compatible representation of a Network.
      */
@@ -253,8 +266,9 @@ export class Network {
 
             const custom = new Network(<string>(network.name), <number>(network.chainId));
 
-            if ((<any>network).ensAddress || (<any>network).ensNetwork != null) {
-                custom.attachPlugin(new EnsPlugin((<any>network).ensAddress, (<any>network).ensNetwork));
+            const n: any = network;
+            if (n.ensAddress || n.ensNetwork != null || n.ensUniversalResolver) {
+                custom.attachPlugin(new EnsPlugin(n.ensAddress, n.ensNetwork, n.ensUniversalResolver));
             }
 
             //if ((<any>network).layerOneConnection) {
@@ -284,6 +298,7 @@ export class Network {
 
 type Options = {
     ensNetwork?: number;
+    ensUniversalResolver?: string;
     altNames?: Array<string>;
     plugins?: Array<NetworkPlugin>;
 };
@@ -359,7 +374,7 @@ function injectCommonNetworks(): void {
 
             // We use 0 to disable ENS
             if (options.ensNetwork != null) {
-                network.attachPlugin(new EnsPlugin(null, options.ensNetwork));
+                network.attachPlugin(new EnsPlugin(null, options.ensNetwork, options.ensUniversalResolver));
             }
 
             network.attachPlugin(new GasCostPlugin());
@@ -382,12 +397,19 @@ function injectCommonNetworks(): void {
         }
     }
 
-    registerEth("mainnet", 1, { ensNetwork: 1, altNames: [ "homestead" ] });
+    // Proxy address
+    const ensUniversalResolver = "0xeEeEEEeE14D718C2B47D9923Deab1335E144EeEe";
+
+    registerEth("mainnet", 1, {
+        ensUniversalResolver, ensNetwork: 1, altNames: [ "homestead" ]
+    });
     registerEth("ropsten", 3, { ensNetwork: 3 });
     registerEth("rinkeby", 4, { ensNetwork: 4 });
     registerEth("goerli", 5, { ensNetwork: 5 });
     registerEth("kovan", 42, { ensNetwork: 42 });
-    registerEth("sepolia", 11155111, { ensNetwork: 11155111 });
+    registerEth("sepolia", 11155111, {
+        ensUniversalResolver, ensNetwork: 11155111
+    });
     registerEth("holesky", 17000, { ensNetwork: 17000 });
 
     registerEth("classic", 61, { });
diff --git a/src.ts/providers/plugins-network.ts b/src.ts/providers/plugins-network.ts
