@ensdomains/ethers-patch-v5 0.0.1

package/dist/index.cjs

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+var import_ethers = require("ethers");
+var import_utils = require("ethers/lib/utils");
+
+// ../../src/shared.ts
+var UR_PROXY = "0xeEeEEEeE14D718C2B47D9923Deab1335E144EeEe";
+var ABI_FRAGMENTS = [
+  // AbstractUniversalResolver
+  "function requireResolver(bytes) view returns ((bytes name, uint256 offset, bytes32 node, address resolver, bool extended))",
+  // IExtendedResolver
+  "function resolve(bytes, bytes) view returns (bytes)",
+  // INameResolver
+  "function name(bytes32) view returns (string)",
+  // IAddrResolver
+  "function addr(bytes32) view returns (address)",
+  // IAddressResolver
+  "function addr(bytes32, uint256) view returns (bytes)"
+];
+var COIN_TYPE_ETH = 60n;
+var COIN_TYPE_DEFAULT = 1n << 31n;
+function isEVMCoinType(coinType) {
+  return coinType === COIN_TYPE_ETH || coinType >= 0n && (coinType ^ COIN_TYPE_DEFAULT) < COIN_TYPE_DEFAULT;
+}
+function getReverseName(lowerAddress, coinType) {
+  return `${lowerAddress.slice(2)}.${coinType === COIN_TYPE_ETH ? "addr" : coinType === COIN_TYPE_DEFAULT ? "default" : coinType.toString(16)}.reverse`;
+}
+
+// index.ts
+var import_ens_normalize = require("@adraffy/ens-normalize");
+__reExport(index_exports, require("ethers"), module.exports);
+var logger = new import_utils.Logger("ur-patch");
+{
+  const { makeError } = import_utils.Logger.prototype;
+  import_utils.Logger.prototype.makeError = function() {
+    logger = this;
+    throw 1;
+  };
+  try {
+    import_ethers.utils.getAddress("abc");
+  } catch {
+  }
+  import_utils.Logger.prototype.makeError = makeError;
+}
+var ABI = new import_utils.Interface(ABI_FRAGMENTS);
+Object.defineProperties(import_ethers.utils, {
+  dnsEncode: { value: dnsEncode },
+  namehash: { value: namehash },
+  ensNormalize: { value: import_ens_normalize.ens_normalize }
+});
+var { getResolver, resolveName, lookupAddress } = import_ethers.providers.BaseProvider.prototype;
+import_ethers.providers.BaseProvider.prototype.getResolverOld = getResolver;
+import_ethers.providers.BaseProvider.prototype.getResolver = async function(name) {
+  const UR = new import_ethers.Contract(UR_PROXY, ABI, this);
+  try {
+    name = (0, import_ens_normalize.ens_normalize)(name);
+    const result = await UR.requireResolver(dnsEncode(name));
+    const resolver = new import_ethers.providers.Resolver(this, result.resolver, name);
+    resolver._supportsEip2544 = Promise.resolve(result.extended);
+    return resolver;
+  } catch (err) {
+    return null;
+  }
+};
+import_ethers.providers.BaseProvider.prototype.resolveName = async function(name, coinType = COIN_TYPE_ETH) {
+  if (coinType === "old") return resolveName.call(this, name);
+  name = await name;
+  coinType = import_ethers.BigNumber.from(coinType).toBigInt();
+  if ((0, import_utils.isHexString)(name) && name.length === 42) {
+    return (0, import_utils.getAddress)(name);
+  }
+  const fwd = await this.getResolver(name);
+  if (!fwd) return null;
+  return fetchAddress(fwd, coinType).catch(() => null);
+};
+import_ethers.providers.BaseProvider.prototype.lookupAddress = async function(address, coinType = COIN_TYPE_ETH) {
+  if (coinType === "old") return lookupAddress.call(this, address);
+  address = await address;
+  if (!(0, import_utils.isHexString)(address) || address === "0x") {
+    logger.throwArgumentError("invalid address", "address", address);
+  }
+  address = address.toLowerCase();
+  coinType = import_ethers.BigNumber.from(coinType).toBigInt();
+  const reverseName = getReverseName(address, coinType);
+  try {
+    const rev = await this.getResolver(reverseName);
+    if (rev) {
+      const name = await callResolver(rev, "name");
+      if (name && (0, import_ens_normalize.ens_normalize)(name) === name) {
+        const fwd = await this.getResolver(name);
+        if (fwd) {
+          const checked = await fetchAddress(fwd, coinType);
+          if (address === checked.toLowerCase()) {
+            return name;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+};
+function namesplit(name) {
+  return name ? name.split(".") : [];
+}
+function dnsEncode(name) {
+  const m = namesplit(name).map((x) => (0, import_utils.toUtf8Bytes)(x));
+  const v = new Uint8Array(m.reduce((a, x) => a + 1 + x.length, 1));
+  let pos = 0;
+  for (const x of m) {
+    if (x.length > 255) {
+      throw new Error("invalid DNS encoded entry; length exceeds 255 bytes");
+    }
+    v[pos++] = x.length;
+    v.set(x, pos);
+    pos += x.length;
+  }
+  return (0, import_utils.hexlify)(v);
+}
+function namehash(name) {
+  return namesplit(name).reduceRight(
+    (h, x) => (0, import_utils.keccak256)(h + (0, import_utils.id)(x).slice(2)),
+    "0x".padEnd(66, "0")
+  );
+}
+async function fetchAddress(resolver, coinType) {
+  if (coinType === COIN_TYPE_ETH) {
+    return callResolver(resolver, "addr(bytes32)");
+  }
+  const a = await callResolver(
+    resolver,
+    "addr(bytes32,uint256)",
+    coinType
+  );
+  return isEVMCoinType(coinType) ? a === "0x" ? a.padEnd(42) : (0, import_utils.getAddress)(a) : a;
+}
+async function callResolver(resolver, fragment, ...args) {
+  const f = ABI.getFunction(fragment);
+  const r = new import_ethers.Contract(resolver.address, ABI, resolver.provider);
+  const node = namehash(resolver.name);
+  if (await resolver.supportsWildcard()) {
+    const res = ABI.decodeFunctionResult(
+      f,
+      await r.resolve(
+        dnsEncode(resolver.name),
+        ABI.encodeFunctionData(f, [node, ...args]),
+        { ccipReadEnabled: true }
+      )
+    );
+    return f.outputs?.length === 1 ? res[0] : res;
+  } else {
+    return r[f.format()](node, ...args, { ccipReadEnabled: true });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("ethers")
+});

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+import { providers, BigNumberish } from 'ethers';
+export * from 'ethers';
+
+declare module "ethers/lib/utils" {
+    function ensNormalize(name: string): string;
+}
+declare module "@ethersproject/providers" {
+    interface BaseProvider {
+        getResolverOld(name: string): Promise<providers.Resolver | null>;
+        resolveName(name: string | Promise<string>, coinType?: BigNumberish): Promise<string | null>;
+        lookupAddress(address: string | Promise<string>, coinType?: BigNumberish): Promise<string | null>;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { providers, BigNumberish } from 'ethers';
+export * from 'ethers';
+
+declare module "ethers/lib/utils" {
+    function ensNormalize(name: string): string;
+}
+declare module "@ethersproject/providers" {
+    interface BaseProvider {
+        getResolverOld(name: string): Promise<providers.Resolver | null>;
+        resolveName(name: string | Promise<string>, coinType?: BigNumberish): Promise<string | null>;
+        lookupAddress(address: string | Promise<string>, coinType?: BigNumberish): Promise<string | null>;
+    }
+}

package/dist/index.js

@@ -0,0 +1,167 @@
+// index.ts
+import {
+  BigNumber,
+  Contract,
+  utils,
+  providers
+} from "ethers";
+import {
+  getAddress,
+  hexlify,
+  id as labelhash,
+  Interface,
+  isHexString,
+  keccak256,
+  Logger,
+  toUtf8Bytes
+} from "ethers/lib/utils";
+
+// ../../src/shared.ts
+var UR_PROXY = "0xeEeEEEeE14D718C2B47D9923Deab1335E144EeEe";
+var ABI_FRAGMENTS = [
+  // AbstractUniversalResolver
+  "function requireResolver(bytes) view returns ((bytes name, uint256 offset, bytes32 node, address resolver, bool extended))",
+  // IExtendedResolver
+  "function resolve(bytes, bytes) view returns (bytes)",
+  // INameResolver
+  "function name(bytes32) view returns (string)",
+  // IAddrResolver
+  "function addr(bytes32) view returns (address)",
+  // IAddressResolver
+  "function addr(bytes32, uint256) view returns (bytes)"
+];
+var COIN_TYPE_ETH = 60n;
+var COIN_TYPE_DEFAULT = 1n << 31n;
+function isEVMCoinType(coinType) {
+  return coinType === COIN_TYPE_ETH || coinType >= 0n && (coinType ^ COIN_TYPE_DEFAULT) < COIN_TYPE_DEFAULT;
+}
+function getReverseName(lowerAddress, coinType) {
+  return `${lowerAddress.slice(2)}.${coinType === COIN_TYPE_ETH ? "addr" : coinType === COIN_TYPE_DEFAULT ? "default" : coinType.toString(16)}.reverse`;
+}
+
+// index.ts
+import { ens_normalize } from "@adraffy/ens-normalize";
+export * from "ethers";
+var logger = new Logger("ur-patch");
+{
+  const { makeError } = Logger.prototype;
+  Logger.prototype.makeError = function() {
+    logger = this;
+    throw 1;
+  };
+  try {
+    utils.getAddress("abc");
+  } catch {
+  }
+  Logger.prototype.makeError = makeError;
+}
+var ABI = new Interface(ABI_FRAGMENTS);
+Object.defineProperties(utils, {
+  dnsEncode: { value: dnsEncode },
+  namehash: { value: namehash },
+  ensNormalize: { value: ens_normalize }
+});
+var { getResolver, resolveName, lookupAddress } = providers.BaseProvider.prototype;
+providers.BaseProvider.prototype.getResolverOld = getResolver;
+providers.BaseProvider.prototype.getResolver = async function(name) {
+  const UR = new Contract(UR_PROXY, ABI, this);
+  try {
+    name = ens_normalize(name);
+    const result = await UR.requireResolver(dnsEncode(name));
+    const resolver = new providers.Resolver(this, result.resolver, name);
+    resolver._supportsEip2544 = Promise.resolve(result.extended);
+    return resolver;
+  } catch (err) {
+    return null;
+  }
+};
+providers.BaseProvider.prototype.resolveName = async function(name, coinType = COIN_TYPE_ETH) {
+  if (coinType === "old") return resolveName.call(this, name);
+  name = await name;
+  coinType = BigNumber.from(coinType).toBigInt();
+  if (isHexString(name) && name.length === 42) {
+    return getAddress(name);
+  }
+  const fwd = await this.getResolver(name);
+  if (!fwd) return null;
+  return fetchAddress(fwd, coinType).catch(() => null);
+};
+providers.BaseProvider.prototype.lookupAddress = async function(address, coinType = COIN_TYPE_ETH) {
+  if (coinType === "old") return lookupAddress.call(this, address);
+  address = await address;
+  if (!isHexString(address) || address === "0x") {
+    logger.throwArgumentError("invalid address", "address", address);
+  }
+  address = address.toLowerCase();
+  coinType = BigNumber.from(coinType).toBigInt();
+  const reverseName = getReverseName(address, coinType);
+  try {
+    const rev = await this.getResolver(reverseName);
+    if (rev) {
+      const name = await callResolver(rev, "name");
+      if (name && ens_normalize(name) === name) {
+        const fwd = await this.getResolver(name);
+        if (fwd) {
+          const checked = await fetchAddress(fwd, coinType);
+          if (address === checked.toLowerCase()) {
+            return name;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+};
+function namesplit(name) {
+  return name ? name.split(".") : [];
+}
+function dnsEncode(name) {
+  const m = namesplit(name).map((x) => toUtf8Bytes(x));
+  const v = new Uint8Array(m.reduce((a, x) => a + 1 + x.length, 1));
+  let pos = 0;
+  for (const x of m) {
+    if (x.length > 255) {
+      throw new Error("invalid DNS encoded entry; length exceeds 255 bytes");
+    }
+    v[pos++] = x.length;
+    v.set(x, pos);
+    pos += x.length;
+  }
+  return hexlify(v);
+}
+function namehash(name) {
+  return namesplit(name).reduceRight(
+    (h, x) => keccak256(h + labelhash(x).slice(2)),
+    "0x".padEnd(66, "0")
+  );
+}
+async function fetchAddress(resolver, coinType) {
+  if (coinType === COIN_TYPE_ETH) {
+    return callResolver(resolver, "addr(bytes32)");
+  }
+  const a = await callResolver(
+    resolver,
+    "addr(bytes32,uint256)",
+    coinType
+  );
+  return isEVMCoinType(coinType) ? a === "0x" ? a.padEnd(42) : getAddress(a) : a;
+}
+async function callResolver(resolver, fragment, ...args) {
+  const f = ABI.getFunction(fragment);
+  const r = new Contract(resolver.address, ABI, resolver.provider);
+  const node = namehash(resolver.name);
+  if (await resolver.supportsWildcard()) {
+    const res = ABI.decodeFunctionResult(
+      f,
+      await r.resolve(
+        dnsEncode(resolver.name),
+        ABI.encodeFunctionData(f, [node, ...args]),
+        { ccipReadEnabled: true }
+      )
+    );
+    return f.outputs?.length === 1 ? res[0] : res;
+  } else {
+    return r[f.format()](node, ...args, { ccipReadEnabled: true });
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@ensdomains/ethers-patch-v5",
+	"version": "0.0.1",
+	"type": "module",
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"files": [
+		"./dist"
+	],
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"peerDependencies": {
+		"typescript": "^5"
+	},
+	"dependencies": {
+		"@adraffy/ens-normalize": "^1.11.1",
+		"ethers": "5",
+		"@ethersproject/providers": "5"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}