@ensdomains/ensjs 3.0.0-alpha.6 → 3.0.0-alpha.9

package/src/GqlManager.ts

@@ -1,11 +1,76 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise'
+
+const generateSelection = (selection: any) => ({
+  kind: 'Field',
+  name: {
+    kind: 'Name',
+    value: selection,
+  },
+  arguments: [],
+  directives: [],
+  alias: undefined,
+  selectionSet: undefined,
+})
+
+export const enter = (node: any) => {
+  if (node.kind === 'SelectionSet') {
+    const id = node.selections.find((x) => x.name && x.name.value === 'id')
+    const name = node.selections.find((x) => x.name && x.name.value === 'name')
+
+    if (!id && name) {
+      node.selections = [...node.selections, generateSelection('id')]
+      return node
+    }
+  }
+}
+
+export const requestMiddleware = (visit, parse) => (request: any) => {
+  const requestBody = JSON.parse(request.body)
+  const rawQuery = requestBody.query
+  const parsedQuery = parse(rawQuery)
+  const updatedQuery = visit(parsedQuery, { enter })
+  const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body }
+
+  return {
+    ...request,
+    body: JSON.stringify(updatedBody),
+  }
+}
+
+export const responseMiddleware = (traverse) => (response: any) => {
+  traverse(response).forEach(function (responseItem: any) {
+    if (responseItem instanceof Object && responseItem.name) {
+      //Name already in hashed form
+      if (responseItem.name && responseItem.name.includes('[')) {
+        return
+      }
+
+      const hashedName = namehash(responseItem.name)
+      if (responseItem.id !== hashedName) {
+        this.update({ ...responseItem, name: hashedName, invalidName: true })
+      }
+    }
+  })
+  return response
+}
+
 export default class GqlManager {
   public gql: any = () => null
   public client?: any | null = null
 
   public setUrl = async (url: string | null) => {
     if (url) {
-      const imported = await import('graphql-request')
-      this.client = new imported.GraphQLClient(url)
+      const [imported, traverse, { visit, parse }] = await Promise.all([
+        import('graphql-request'),
+        import('traverse'),
+        import('graphql/language'),
+      ])
+
+      this.client = new imported.GraphQLClient(url, {
+        requestMiddleware: requestMiddleware(visit, parse),
+        responseMiddleware: responseMiddleware(traverse.default),
+      })
       this.gql = imported.gql
     } else {
       this.client = null

package/src/functions/getProfile.test.ts

@@ -2,9 +2,14 @@ import { ENS } from '..'
 import setup from '../tests/setup'
 
 let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
 
 beforeAll(async () => {
-  ;({ ENSInstance } = await setup())
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
 })
 
 const checkRecords = (
@@ -88,6 +93,16 @@ describe('getProfile', () => {
       })
       checkRecords(result)
     })
+    it('should return a profile object for a specified resolver', async () => {
+      const result = await ENSInstance.getProfile('saganaki.xyz', {
+        resolverAddress: '0x12299799a50340fb860d276805e78550cbad3de3',
+      })
+      expect(result).toBeDefined()
+      expect(result?.address).toBe('0x157545BfD441453921049998128Ff090c1c11230')
+      expect(result?.resolverAddress).toBe(
+        '0x12299799a50340fb860d276805e78550cbad3de3',
+      )
+    })
     it('should return undefined for an unregistered name', async () => {
       const result = await ENSInstance.getProfile('test123123123cool.eth')
       expect(result).toBeUndefined()

package/src/functions/getProfile.ts

@@ -3,6 +3,7 @@ import { ethers } from 'ethers'
 import { ENSArgs } from '..'
 import { decodeContenthash, DecodedContentHash } from '../utils/contentHash'
 import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
 import { parseInputType } from '../utils/validation'
 
 type InternalProfileOptions = {
@@ -136,7 +137,8 @@ const getDataForName = async (
   >,
   name: string,
   options: InternalProfileOptions,
-  fallbackResolver: string,
+  fallbackResolver?: string,
+  specificResolver?: string,
 ) => {
   const universalResolver = await contracts?.getUniversalResolver()
 
@@ -149,7 +151,17 @@ const getDataForName = async (
   let resolvedData: any
   let useFallbackResolver = false
   try {
-    resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
+    if (specificResolver) {
+      const publicResolver = await contracts?.getPublicResolver(
+        undefined,
+        specificResolver,
+      )
+      resolvedData = await publicResolver?.callStatic.multicall(
+        calls.map((x) => x.data),
+      )
+    } else {
+      resolvedData = await universalResolver?.resolve(hexEncodeName(name), data)
+    }
   } catch {
     useFallbackResolver = true
   }
@@ -158,15 +170,19 @@ const getDataForName = async (
   let recordData: any
 
   if (useFallbackResolver) {
-    resolverAddress = fallbackResolver
+    resolverAddress = specificResolver || fallbackResolver!
     recordData = await fetchWithoutResolverMulticall(
       { multicallWrapper },
       calls,
       resolverAddress,
     )
   } else {
-    resolverAddress = resolvedData['1']
-    ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
+    resolverAddress = specificResolver || resolvedData['1']
+    if (specificResolver) {
+      recordData = resolvedData
+    } else {
+      ;[recordData] = await resolverMulticallWrapper.decode(resolvedData['0'])
+    }
   }
 
   const matchAddress = recordData[calls.findIndex((x) => x.key === '60')]
@@ -298,10 +314,11 @@ const graphFetch = async (
   { gqlInstance }: ENSArgs<'gqlInstance'>,
   name: string,
   wantedRecords?: ProfileOptions,
+  resolverAddress?: string,
 ) => {
   const query = gqlInstance.gql`
-    query getRecords($name: String!) {
-      domains(where: { name: $name }) {
+    query getRecords($id: String!) {
+      domain(id: $id) {
         isMigrated
         createdAt
         resolver {
@@ -317,13 +334,44 @@ const graphFetch = async (
     }
   `
 
+  const customResolverQuery = gqlInstance.gql`
+    query getRecordsWithCustomResolver($id: String!, $resolverId: String!) {
+      domain(id: $id) {
+        isMigrated
+        createdAt
+      }
+      resolver(id: $resolverId) {
+        texts
+        coinTypes
+        contentHash
+        addr {
+          id
+        }
+      }
+    }
+  `
+
   const client = gqlInstance.client
 
-  const { domains } = await client.request(query, { name })
+  const id = namehash(name)
 
-  if (!domains || domains.length === 0) return
+  let domain: any
+  let resolverResponse: any
 
-  const [{ resolver: resolverResponse, isMigrated, createdAt }] = domains
+  if (!resolverAddress) {
+    ;({ domain } = await client.request(query, { id }))
+    resolverResponse = domain?.resolver
+  } else {
+    const resolverId = `${resolverAddress}-${id}`
+    ;({ resolver: resolverResponse, domain } = await client.request(
+      customResolverQuery,
+      { id, resolverId },
+    ))
+  }
+
+  if (!domain) return
+
+  const { isMigrated, createdAt } = domain
 
   let returnedRecords: ProfileResponse = {}
 
@@ -333,7 +381,7 @@ const graphFetch = async (
     return {
       isMigrated,
       createdAt,
-      graphResolverAddress: resolverResponse.address,
+      graphResolverAddress: resolverResponse.address || resolverAddress,
     }
 
   Object.keys(wantedRecords).forEach((key: string) => {
@@ -351,7 +399,7 @@ const graphFetch = async (
     ...returnedRecords,
     isMigrated,
     createdAt,
-    graphResolverAddress: resolverResponse.address,
+    graphResolverAddress: resolverResponse.address || resolverAddress,
   }
 }
 
@@ -361,6 +409,10 @@ type ProfileOptions = {
   coinTypes?: boolean | string[]
 }
 
+type InputProfileOptions = ProfileOptions & {
+  resolverAddress?: string
+}
+
 const getProfileFromName = async (
   {
     contracts,
@@ -380,13 +432,23 @@ const getProfileFromName = async (
     | 'multicallWrapper'
   >,
   name: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
+  const { resolverAddress, ..._options } = options || {}
+  const optsLength = Object.keys(_options).length
   const usingOptions =
-    !options || options?.texts === true || options?.coinTypes === true
-      ? options || { contentHash: true, texts: true, coinTypes: true }
+    !optsLength || _options?.texts === true || _options?.coinTypes === true
+      ? optsLength
+        ? _options
+        : { contentHash: true, texts: true, coinTypes: true }
       : undefined
-  const graphResult = await graphFetch({ gqlInstance }, name, usingOptions)
+
+  const graphResult = await graphFetch(
+    { gqlInstance },
+    name,
+    usingOptions,
+    resolverAddress,
+  )
   if (!graphResult) return
   const {
     isMigrated,
@@ -398,7 +460,7 @@ const getProfileFromName = async (
     createdAt: string
     graphResolverAddress?: string
   } & InternalProfileOptions = graphResult
-  if (!graphResolverAddress)
+  if (!graphResolverAddress && !options?.resolverAddress)
     return { isMigrated, createdAt, message: "Name doesn't have a resolver" }
   const result = await getDataForName(
     {
@@ -412,6 +474,7 @@ const getProfileFromName = async (
     name,
     usingOptions ? wantedRecords : (options as InternalProfileOptions),
     graphResolverAddress,
+    options?.resolverAddress!,
   )
   if (!result)
     return { isMigrated, createdAt, message: "Records fetch didn't complete" }
@@ -439,7 +502,7 @@ const getProfileFromAddress = async (
     | 'multicallWrapper'
   >,
   address: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ) => {
   let name
   try {
@@ -492,7 +555,7 @@ export default async function (
     | 'multicallWrapper'
   >,
   nameOrAddress: string,
-  options?: ProfileOptions,
+  options?: InputProfileOptions,
 ): Promise<ResolvedProfile | undefined> {
   if (options && options.coinTypes && typeof options.coinTypes !== 'boolean') {
     options.coinTypes = options.coinTypes.map((coin: string) => {

package/src/functions/getRecords.ts

@@ -5,6 +5,7 @@ type ProfileOptions = {
   contentHash?: boolean
   texts?: boolean | string[]
   coinTypes?: boolean | string[]
+  resolverAddress?: string
 }
 
 export default async function (

package/src/functions/setRecord.test.ts

@@ -0,0 +1,100 @@
+import { ENS } from '..'
+import setup from '../tests/setup'
+import { decodeContenthash } from '../utils/contentHash'
+import { hexEncodeName } from '../utils/hexEncodedName'
+import { namehash } from '../utils/normalise'
+
+let ENSInstance: ENS
+let revert: Awaited<ReturnType<typeof setup>>['revert']
+
+beforeAll(async () => {
+  ;({ ENSInstance, revert } = await setup())
+})
+
+afterAll(async () => {
+  await revert()
+})
+
+describe('setRecord', () => {
+  it('should allow a text record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'text',
+      record: { key: 'foo', value: 'bar' },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedText = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('text', [
+        namehash('parthtejpal.eth'),
+        'foo',
+      ]),
+    )
+    const [resultText] = publicResolver.interface.decodeFunctionResult(
+      'text',
+      encodedText[0],
+    )
+    expect(resultText).toBe('bar')
+  })
+  it('should allow an address record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'addr',
+      record: {
+        key: 'ETC',
+        value: '0x42D63ae25990889E35F215bC95884039Ba354115',
+      },
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedAddr = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('addr(bytes32,uint256)', [
+        namehash('parthtejpal.eth'),
+        '61',
+      ]),
+    )
+    const [resultAddr] = publicResolver.interface.decodeFunctionResult(
+      'addr(bytes32,uint256)',
+      encodedAddr[0],
+    )
+    expect(resultAddr).toBe(
+      '0x42D63ae25990889E35F215bC95884039Ba354115'.toLowerCase(),
+    )
+  })
+  it('should allow a contenthash record set', async () => {
+    const tx = await ENSInstance.setRecord('parthtejpal.eth', {
+      type: 'contentHash',
+      record:
+        'ipns://k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    })
+    expect(tx).toBeTruthy()
+    await tx.wait()
+
+    const universalResolver =
+      await ENSInstance.contracts!.getUniversalResolver()!
+    const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
+    const encodedContent = await universalResolver.resolve(
+      hexEncodeName('parthtejpal.eth'),
+      publicResolver.interface.encodeFunctionData('contenthash', [
+        namehash('parthtejpal.eth'),
+      ]),
+    )
+    const [resultContent] = publicResolver.interface.decodeFunctionResult(
+      'contenthash',
+      encodedContent[0],
+    )
+    const content = decodeContenthash(resultContent)
+    expect(content.decoded).toBe(
+      'k51qzi5uqu5dgox2z23r6e99oqency055a6xt92xzmyvpz8mwz5ycjavm0u150',
+    )
+    expect(content.protocolType).toBe('ipns')
+  })
+})

package/src/functions/setRecord.ts

@@ -0,0 +1,63 @@
+import { ENSArgs } from '..'
+import { namehash } from '../utils/normalise'
+import {
+  generateSingleRecordCall,
+  RecordInput,
+  RecordTypes,
+} from '../utils/recordHelpers'
+
+type BaseInput = {
+  resolverAddress?: string
+}
+
+type ContentHashInput = {
+  record: RecordInput<'contentHash'>
+  type: 'contentHash'
+}
+
+type AddrOrTextInput = {
+  record: RecordInput<'addr' | 'text'>
+  type: 'addr' | 'text'
+}
+
+export default async function <T extends RecordTypes>(
+  {
+    contracts,
+    provider,
+    getResolver,
+    signer,
+  }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>,
+  name: string,
+  {
+    record,
+    type,
+    resolverAddress,
+  }: BaseInput & (ContentHashInput | AddrOrTextInput),
+) {
+  if (!name.includes('.')) {
+    throw new Error('Input is not an ENS name')
+  }
+
+  let resolverToUse: string
+  if (resolverAddress) {
+    resolverToUse = resolverAddress
+  } else {
+    resolverToUse = await getResolver(name)
+  }
+
+  if (!resolverToUse) {
+    throw new Error('No resolver found for input address')
+  }
+
+  const resolver = (
+    await contracts?.getPublicResolver(provider, resolverToUse)
+  )?.connect(signer)!
+  const hash = namehash(name)
+
+  const call = generateSingleRecordCall(hash, resolver, type)(record)
+
+  return {
+    to: resolver.address,
+    data: call,
+  }
+}

package/src/functions/setRecords.test.ts

@@ -32,7 +32,7 @@ describe('setRecords', () => {
     const publicResolver = await ENSInstance.contracts!.getPublicResolver()!
     const encodedText = await universalResolver.resolve(
       hexEncodeName('parthtejpal.eth'),
-      publicResolver.interface.encodeFunctionData('text(bytes32,string)', [
+      publicResolver.interface.encodeFunctionData('text', [
         namehash('parthtejpal.eth'),
         'foo',
       ]),
@@ -45,7 +45,7 @@ describe('setRecords', () => {
       ]),
     )
     const [resultText] = publicResolver.interface.decodeFunctionResult(
-      'text(bytes32,string)',
+      'text',
       encodedText[0],
     )
     const [resultAddr] = publicResolver.interface.decodeFunctionResult(

package/src/index.ts

@@ -37,6 +37,7 @@ import type {
 } from './functions/getSpecificRecord'
 import type getSubnames from './functions/getSubnames'
 import type setName from './functions/setName'
+import type setRecord from './functions/setRecord'
 import type setRecords from './functions/setRecords'
 import type setResolver from './functions/setResolver'
 import type transferName from './functions/transferName'
@@ -217,7 +218,7 @@ export class ENS {
       await thisRef.checkInitialProvider()
       // import the module dynamically
       const mod = await import(
-        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true */
+        /* webpackMode: "lazy", webpackChunkName: "[request]", webpackPreload: true, webpackExclude: /.*\.ts$/ */
         `./functions/${path}`
       )
 
@@ -543,6 +544,12 @@ export class ENS {
     ['contracts', 'provider', 'getResolver'],
   )
 
+  public setRecord = this.generateWriteFunction<typeof setRecord>('setRecord', [
+    'contracts',
+    'provider',
+    'getResolver',
+  ])
+
   public setResolver = this.generateWriteFunction<typeof setResolver>(
     'setResolver',
     ['contracts'],

package/src/utils/labels.ts

@@ -1,6 +1,8 @@
 import { solidityKeccak256 } from 'ethers/lib/utils'
 import { truncateFormat } from './format'
 
+const hasLocalStorage = typeof localStorage !== 'undefined'
+
 export const labelhash = (input: string) =>
   solidityKeccak256(['string'], [input])
 
@@ -37,13 +39,13 @@ export function isEncodedLabelhash(hash: string) {
 }
 
 function getLabels() {
-  return localStorage
+  return hasLocalStorage
     ? JSON.parse(localStorage.getItem('ensjs:labels') as string) || {}
     : {}
 }
 
 function _saveLabel(hash: string, label: any) {
-  if (!localStorage) return hash
+  if (!hasLocalStorage) return hash
   const labels = getLabels()
   localStorage.setItem(
     'ensjs:labels',
@@ -106,7 +108,7 @@ export function decryptName(name: string) {
 export const truncateUndecryptedName = (name: string) => truncateFormat(name)
 
 export function checkLocalStorageSize() {
-  if (!localStorage) return 'Empty (0 KB)'
+  if (!hasLocalStorage) return 'Empty (0 KB)'
   let allStrings = ''
   for (const key in window.localStorage) {
     if (Object.prototype.hasOwnProperty.call(window.localStorage, key)) {

package/src/utils/normalise.ts

@@ -1,5 +1,6 @@
 import { concat, hexlify, keccak256, toUtf8Bytes } from 'ethers/lib/utils'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
+import { decodeLabelhash, isEncodedLabelhash } from './labels'
 
 const zeros = new Uint8Array(32)
 zeros.fill(0)
@@ -7,16 +8,21 @@ zeros.fill(0)
 export const normalise = (name: string) =>
   name ? uts46.toUnicode(name, { useStd3ASCII: true }) : name
 
-export const namehash = (inputName: string): string => {
+export const namehash = (name: string): string => {
   let result: string | Uint8Array = zeros
 
-  const name = normalise(inputName)
-
   if (name) {
     const labels = name.split('.')
 
     for (var i = labels.length - 1; i >= 0; i--) {
-      const labelSha = keccak256(toUtf8Bytes(labels[i]))
+      let labelSha: string
+      if (isEncodedLabelhash(labels[i])) {
+        labelSha = decodeLabelhash(labels[i])
+      } else {
+        const normalised = normalise(labels[i])
+        labelSha = keccak256(toUtf8Bytes(normalised))
+      }
+
       result = keccak256(concat([result, labelSha]))
     }
   } else {