@snapshot-labs/snapshot.js 0.12.55 → 0.12.56

package/dist/src/utils.d.ts

@@ -30,8 +30,8 @@ interface validateSchemaOptions {
 export declare function validateSchema(schema: any, data: any, options?: validateSchemaOptions): true | import("ajv").ErrorObject<string, Record<string, any>, unknown>[] | null | undefined;
 export declare function getEnsTextRecord(ens: string, record: string, network?: string, options?: any): Promise<string | null>;
 export declare function getSpaceUri(id: string, network?: string, options?: any): Promise<string | null>;
-export declare function getEnsOwner(ens: string, network?: string, options?: any): Promise<string | null>;
-export declare function getSpaceController(id: string, network?: string, options?: any): Promise<string | null>;
+export declare function getEnsOwner(ens: string, network?: string, options?: any): Promise<string>;
+export declare function getSpaceController(id: string, network?: string, options?: any): Promise<string>;
 export declare function clone(item: any): any;
 export declare function sleep(time: any): Promise<unknown>;
 export declare function getNumberWithOrdinal(n: any): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snapshot-labs/snapshot.js",
-  "version": "0.12.55",
+  "version": "0.12.56",
   "repository": "snapshot-labs/snapshot.js",
   "license": "MIT",
   "main": "dist/snapshot.cjs.js",

package/src/utils.spec.js

@@ -10,6 +10,8 @@ import {
   getEnsTextRecord
 } from './utils';
 
+const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000';
+
 vi.mock('cross-fetch', async () => {
   const actual = await vi.importActual('cross-fetch');
 
@@ -617,7 +619,13 @@ describe('utils', () => {
   describe('getEnsOwner', () => {
     test('should return null when the ENS is not valid', () => {
       // special hidden characters after the k
-      expect(getEnsOwner('elonmusk‍‍.eth')).resolves.toBe(null);
+      expect(getEnsOwner('elonmusk‍‍.eth')).resolves.toBe(EMPTY_ADDRESS);
+    });
+
+    test('throw an error when the network is not supported', () => {
+      expect(getEnsOwner('shot.eth', '100')).rejects.toThrow(
+        'Network not supported'
+      );
     });
   });
 

package/src/utils.ts

@@ -30,6 +30,15 @@ interface Strategy {
   params: any;
 }
 
+type DomainType = 'ens' | 'tld' | 'other-tld' | 'subdomain';
+
+const MUTED_ERRORS = [
+  // mute error from coinbase, when the subdomain is not found
+  // most other resolvers just return an empty address
+  'response not found during CCIP fetch',
+  // mute error from missing offchain resolver (mostly for sepolia)
+  'UNSUPPORTED_OPERATION'
+];
 const ENS_REGISTRY = '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e';
 const ENS_ABI = [
   'function text(bytes32 node, string calldata key) external view returns (string memory)',
@@ -219,6 +228,45 @@ ajv.addFormat('domain', {
   }
 });
 
+function getDomainType(domain: string): DomainType {
+  const isEns = domain.endsWith('.eth');
+
+  const tokens = domain.split('.');
+
+  if (tokens.length === 1) return 'tld';
+  else if (tokens.length === 2 && !isEns) return 'other-tld';
+  else if (tokens.length > 2) return 'subdomain';
+  else if (isEns) return 'ens';
+  else throw new Error('Invalid domain');
+}
+
+// see https://docs.ens.domains/registry/dns#gasless-import
+async function getDNSOwner(domain: string): Promise<string> {
+  const response = await fetch(
+    `https://cloudflare-dns.com/dns-query?name=${domain}&type=TXT`,
+    {
+      headers: {
+        accept: 'application/dns-json'
+      }
+    }
+  );
+
+  const data = await response.json();
+  // Error list: https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6
+  if (data.Status === 3) return EMPTY_ADDRESS;
+  if (data.Status !== 0) throw new Error('Failed to fetch DNS Owner');
+
+  const ownerRecord = data.Answer?.find((record: any) =>
+    record.data.includes('ENS1')
+  );
+
+  if (!ownerRecord) return EMPTY_ADDRESS;
+
+  return getAddress(
+    ownerRecord.data.replace(new RegExp('"', 'g'), '').split(' ').pop()
+  );
+}
+
 export async function call(provider, abi: any[], call: any[], options?) {
   const contract = new Contract(call[0], abi, provider);
   try {
@@ -611,7 +659,12 @@ export async function getEnsOwner(
   ens: string,
   network = '1',
   options: any = {}
-): Promise<string | null> {
+): Promise<string> {
+  if (!networks[network]?.ensResolvers?.length) {
+    throw new Error('Network not supported');
+  }
+
+  const domainType = getDomainType(ens);
   const provider = getProvider(network, options);
   const ensRegistry = new Contract(
     ENS_REGISTRY,
@@ -624,7 +677,7 @@ export async function getEnsOwner(
   try {
     ensHash = namehash(ensNormalize(ens));
   } catch (e: any) {
-    return null;
+    return EMPTY_ADDRESS;
   }
 
   const ensNameWrapper =
@@ -639,14 +692,35 @@ export async function getEnsOwner(
     );
     owner = await ensNameWrapperContract.ownerOf(ensHash);
   }
-  return owner;
+
+  if (owner === EMPTY_ADDRESS && domainType === 'other-tld') {
+    const resolvedAddress = await provider.resolveName(ens);
+
+    // Filter out domains with valid TXT records, but not imported
+    if (resolvedAddress) {
+      owner = await getDNSOwner(ens);
+    }
+  }
+
+  if (owner === EMPTY_ADDRESS && domainType === 'subdomain') {
+    try {
+      owner = await provider.resolveName(ens);
+    } catch (e: any) {
+      if (MUTED_ERRORS.every((error) => !e.message.includes(error))) {
+        throw e;
+      }
+      owner = EMPTY_ADDRESS;
+    }
+  }
+
+  return owner || EMPTY_ADDRESS;
 }
 
 export async function getSpaceController(
   id: string,
   network = '1',
   options: any = {}
-): Promise<string | null> {
+): Promise<string> {
   const spaceUri = await getSpaceUri(id, network, options);
   if (spaceUri) {
     let isUriAddress = isAddress(spaceUri);