@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.43

package/src/generated/factories/UniversalResolver__factory.ts

@@ -2,7 +2,7 @@
 /* tslint:disable */
 /* eslint-disable */
 
-import { Interface } from '@ethersproject/abi/lib/interface'
+import { Interface } from '@ethersproject/abi'
 import { Signer } from '@ethersproject/abstract-signer'
 import { Contract } from '@ethersproject/contracts'
 import type { Provider } from '@ethersproject/providers'
@@ -59,6 +59,25 @@ const _abi = [
     name: 'OffchainLookup',
     type: 'error',
   },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'previousOwner',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'newOwner',
+        type: 'address',
+      },
+    ],
+    name: 'OwnershipTransferred',
+    type: 'event',
+  },
   {
     inputs: [
       {
@@ -146,6 +165,19 @@ const _abi = [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [],
+    name: 'owner',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
   {
     inputs: [],
     name: 'registry',
@@ -159,6 +191,13 @@ const _abi = [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [],
+    name: 'renounceOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
   {
     inputs: [
       {
@@ -311,7 +350,7 @@ const _abi = [
         type: 'address',
       },
     ],
-    stateMutability: 'nonpayable',
+    stateMutability: 'view',
     type: 'function',
   },
   {
@@ -340,7 +379,7 @@ const _abi = [
         type: 'address',
       },
     ],
-    stateMutability: 'nonpayable',
+    stateMutability: 'view',
     type: 'function',
   },
   {
@@ -452,6 +491,19 @@ const _abi = [
         type: 'address',
       },
     ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'string[]',
+        name: '_urls',
+        type: 'string[]',
+      },
+    ],
+    name: 'setGatewayURLs',
+    outputs: [],
     stateMutability: 'nonpayable',
     type: 'function',
   },
@@ -474,6 +526,19 @@ const _abi = [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: 'newOwner',
+        type: 'address',
+      },
+    ],
+    name: 'transferOwnership',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
 ]
 
 export class UniversalResolver__factory {

package/src/index.ts

@@ -15,14 +15,7 @@ import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
 
-export type {
-  Fuse,
-  FuseArrayPossibilities,
-  FuseObj,
-  NamedFusesToBurn,
-  UnnamedFuseType,
-  UnnamedFuseValues,
-} from './utils/fuses'
+export type { ChildFuses, ParentFuses } from './utils/fuses'
 
 type ENSOptions = {
   graphURI?: string | null
@@ -555,6 +548,10 @@ export class ENS {
     ['contracts'],
   )
 
+  public getDecryptedName = this.generateRawFunction<
+    FunctionTypes['getDecryptedName']
+  >('getDecryptedName', ['contracts', 'gqlInstance'])
+
   public universalWrapper = this.generateRawFunction<
     FunctionTypes['universalWrapper']
   >('initialGetters', ['contracts'], 'universalWrapper')
@@ -597,7 +594,7 @@ export class ENS {
 
   public wrapName = this.generateWriteFunction<FunctionTypes['wrapName']>(
     'wrapName',
-    ['contracts', 'getExpiry'],
+    ['contracts'],
   )
 
   public unwrapName = this.generateWriteFunction<FunctionTypes['unwrapName']>(
@@ -605,11 +602,15 @@ export class ENS {
     ['contracts'],
   )
 
-  public burnFuses = this.generateWriteFunction<FunctionTypes['burnFuses']>(
-    'burnFuses',
+  public setFuses = this.generateWriteFunction<FunctionTypes['setFuses']>(
+    'setFuses',
     ['contracts'],
   )
 
+  public setChildFuses = this.generateWriteFunction<
+    FunctionTypes['setChildFuses']
+  >('setFuses', ['contracts'], 'setChildFuses')
+
   public importDNSSECName = this.generateWriteFunction<
     FunctionTypes['importDNSSECName']
   >('importDNSSECName', ['contracts', 'provider', 'signer'])
@@ -640,7 +641,7 @@ export class ENS {
     ['contracts'],
   )
 
-  public renewNameWithData = this.generateWriteFunction<
-    FunctionTypes['renewNameWithData']
-  >('renewNames', ['contracts'], 'renewNameWithData')
+  public extendWrappedName = this.generateWriteFunction<
+    FunctionTypes['extendWrappedName']
+  >('renewNames', ['contracts'], 'extendWrappedName')
 }

package/src/static.ts

@@ -1,4 +1,4 @@
-import type { StaticJsonRpcProvider } from '@ethersproject/providers/lib/url-json-rpc-provider'
+import type { StaticJsonRpcProvider } from '@ethersproject/providers'
 import { gql, GraphQLClient } from 'graphql-request'
 import { parse, print, visit } from 'graphql/language'
 import traverse from 'traverse'

package/src/utils/ccip.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { BigNumber } from '@ethersproject/bignumber'
 import {
   arrayify,
   BytesLike,
@@ -6,7 +6,7 @@ import {
   hexDataSlice,
 } from '@ethersproject/bytes'
 import type { BaseProvider, TransactionRequest } from '@ethersproject/providers'
-import { toUtf8String } from '@ethersproject/strings/lib/utf8'
+import { toUtf8String } from '@ethersproject/strings'
 import type { Transaction } from '@ethersproject/transactions'
 
 function bytesPad(value: Uint8Array): Uint8Array {

package/src/utils/consts.ts

@@ -1 +1,2 @@
 export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'
+export const MAX_INT_64 = 2n ** 64n - 1n

package/src/utils/fuses.ts

@@ -1,160 +1,357 @@
-import { BigNumber, BigNumberish } from '@ethersproject/bignumber/lib/bignumber'
-
+// child named fuses
 const CANNOT_UNWRAP = 1
 const CANNOT_BURN_FUSES = 2
 const CANNOT_TRANSFER = 4
 const CANNOT_SET_RESOLVER = 8
 const CANNOT_SET_TTL = 16
 const CANNOT_CREATE_SUBDOMAIN = 32
-const PARENT_CANNOT_CONTROL = 64
+
+// parent named fuses
+const PARENT_CANNOT_CONTROL = 0x10000
+const IS_DOT_ETH = 0x20000
+const CAN_EXTEND_EXPIRY = 0x40000
+
+// fuse ranges
+export const CHILD_CONTROLLED_FUSES = 0x0000ffff
+export const PARENT_CONTROLLED_FUSES = 0xffff0000
+export const USER_SETTABLE_FUSES = 0xfffdffff
+
+// empty fuse
 const CAN_DO_EVERYTHING = 0
 
-export const fuseEnum = {
+export const childFuseEnum = {
   CANNOT_UNWRAP,
   CANNOT_BURN_FUSES,
   CANNOT_TRANSFER,
   CANNOT_SET_RESOLVER,
   CANNOT_SET_TTL,
   CANNOT_CREATE_SUBDOMAIN,
-  PARENT_CANNOT_CONTROL,
 } as const
 
-export type FuseOptions = { -readonly [K in keyof typeof fuseEnum]?: boolean }
+export const parentFuseEnum = {
+  PARENT_CANNOT_CONTROL,
+  CAN_EXTEND_EXPIRY,
+}
 
-export const unnamedFuses = [
-  128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144,
-  524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864,
-  134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296,
-] as const
+export const fullParentFuseEnum = {
+  ...parentFuseEnum,
+  IS_DOT_ETH,
+} as const
+
+export const userSettableFuseEnum = {
+  ...childFuseEnum,
+  ...parentFuseEnum,
+} as const
 
-const fullFuseEnum = {
-  ...fuseEnum,
+export const fullFuseEnum = {
+  ...userSettableFuseEnum,
   CAN_DO_EVERYTHING,
 }
 
-export type FuseObj = typeof fuseEnum
-export type CurrentFuses = { [f in keyof FuseObj]: boolean } & {
-  CAN_DO_EVERYTHING: boolean
+export const unnamedChildFuses = [
+  64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
+] as const
+
+export const unnamedParentFuses = [
+  0x80000, 0x100000, 0x200000, 0x400000, 0x800000, 0x1000000, 0x2000000,
+  0x4000000, 0x8000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000,
+] as const
+
+export const unnamedUserSettableFuses = [
+  ...unnamedChildFuses,
+  ...unnamedParentFuses,
+] as const
+
+export const childFuseKeys = Object.keys(
+  childFuseEnum,
+) as (keyof typeof childFuseEnum)[]
+export const parentFuseKeys = Object.keys(
+  parentFuseEnum,
+) as (keyof typeof parentFuseEnum)[]
+export const fullParentFuseKeys = Object.keys(
+  fullParentFuseEnum,
+) as (keyof typeof fullParentFuseEnum)[]
+export const userSettableFuseKeys = Object.keys(
+  userSettableFuseEnum,
+) as (keyof typeof userSettableFuseEnum)[]
+
+type FuseType<
+  Enum extends Record<string, number>,
+  UnnamedTuple extends readonly number[],
+  CustomFuses extends string = never,
+> = {
+  fuse: keyof Enum
+  options: { -readonly [K in keyof Enum]?: boolean }
+  current: { [K in keyof Enum]: boolean } & {
+    readonly [K in CustomFuses]: boolean
+  }
+  unnamed: UnnamedTuple
+  unnamedValues: UnnamedTuple[number]
+  unnamedObject: { [K in UnnamedTuple[number]]: boolean }
 }
-export type UnnamedFuseType = typeof unnamedFuses
-export type Fuse = keyof FuseObj
-export type UnnamedFuseValues = UnnamedFuseType[number]
-
-// We need this type so that the following type isn't infinite. This type limits the max length of the fuse array to 7.
-export type FuseArrayPossibilities =
-  | [Fuse]
-  | [Fuse, Fuse]
-  | [Fuse, Fuse, Fuse]
-  | [Fuse, Fuse, Fuse, Fuse]
-  | [Fuse, Fuse, Fuse, Fuse, Fuse]
-  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
-  | [Fuse, Fuse, Fuse, Fuse, Fuse, Fuse, Fuse]
-
-/**
- * This type creates a type error if there are any duplicate fuses.
- * It effectively works like a reduce function, starting with 0 included types, adding a type each time, and then checking for duplicates.
- *
- * @template A The array to check for duplicates.
- * @template B The union of all checked existing types.
- */
-// CLAUSE A: This extension unwraps the type as a fuse tuple.
-type FusesWithoutDuplicates<A, B = never> = A extends FuseArrayPossibilities
-  ? // CLAUSE A > TRUE: CLAUSE B: Pick out the first item in the current array, separating the current item from the rest.
-    A extends [infer Head, ...infer Tail]
-    ? // CLAUSE B > TRUE: CLAUSE C: Check if the current item is a duplicate based on the input union.
-      Head extends B
-      ? // CLAUSE C > TRUE: Duplicate found, return an empty array to throw a type error.
-        []
-      : // CLAUSE C > FALSE: Return a new array to continue the recursion, adds the current item type to the union.
-        [Head, ...FusesWithoutDuplicates<Tail, Head | B>]
-    : // CLAUSE B > FALSE: Return the input array as there is no more array elements to check.
-      A
-  : // CLAUSE A > FALSE: Return an empty array as it isn't a fuse tuple.
-    []
-
-export type NamedFusesToBurn = FusesWithoutDuplicates<FuseArrayPossibilities>
-
-export type FusePropsNamedArray = {
-  namedFusesToBurn: NamedFusesToBurn
+
+export type ChildFuses = FuseType<
+  typeof childFuseEnum,
+  typeof unnamedChildFuses,
+  'CAN_DO_EVERYTHING'
+>
+export type ParentFuses = FuseType<
+  typeof parentFuseEnum,
+  typeof unnamedParentFuses
+>
+export type FullParentFuses = FuseType<
+  typeof fullParentFuseEnum,
+  typeof unnamedParentFuses
+>
+export type UserSettableFuses = FuseType<
+  typeof userSettableFuseEnum,
+  typeof unnamedUserSettableFuses
+>
+
+type InputFuses<NamedFuse extends string, UnnamedFuse extends number> =
+  | {
+      named: readonly NamedFuse[]
+    }
+  | {
+      unnamed: readonly UnnamedFuse[]
+    }
+  | {
+      named: readonly NamedFuse[]
+      unnamed: readonly UnnamedFuse[]
+    }
+  | {
+      number: number
+    }
+
+export type CombinedFuseInput = {
+  child: InputFuses<ChildFuses['fuse'], ChildFuses['unnamedValues']>
+  parent: InputFuses<ParentFuses['fuse'], ParentFuses['unnamedValues']>
 }
 
-export type FusePropsUnnamedArray = {
-  unnamedFusesToBurn: UnnamedFuseValues[]
+type FuseRestriction = 'parent' | 'child'
+
+const checkNumber = (fuses: number) => {
+  if (fuses > 2 ** 32 || fuses < 1) {
+    throw new Error(
+      `Fuse number must be limited to uint32, ${fuses} was too ${
+        fuses < 1 ? 'low' : 'high'
+      }.`,
+    )
+  } else if (fuses % 1 !== 0) {
+    throw new Error(`Fuse number must be an integer, ${fuses} was not.`)
+  } else if ((fuses & USER_SETTABLE_FUSES) !== fuses) {
+    throw new Error(
+      `Fuse number must be limited to user settable fuses, ${fuses} was not.`,
+    )
+  }
 }
 
-export type FusePropsNumber = {
-  fuseNumberToBurn: number
+const testFuses = (fuses: any) => {
+  if ('named' in fuses && fuses.named.length > 0) {
+    return true
+  }
+  if ('unnamed' in fuses && fuses.unnamed.length > 0) {
+    return true
+  }
+  if ('number' in fuses && fuses.number !== 0) {
+    return true
+  }
+  return false
 }
 
-export type FuseProps =
-  | (Partial<FusePropsNamedArray> & FusePropsUnnamedArray)
-  | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>)
-  | FusePropsNumber
+export const hasFuses = (fuses: any) => {
+  if (typeof fuses === 'number') {
+    return fuses !== 0
+  }
 
-export const validateFuses = (fuses: FuseProps) => {
-  const isNumber = 'fuseNumberToBurn' in fuses
-  const hasNamedArray = 'namedFusesToBurn' in fuses
-  const hasUnnamedArray = 'unnamedFusesToBurn' in fuses
+  if (typeof fuses === 'object') {
+    if ('child' in fuses && testFuses(fuses.child)) {
+      return true
+    }
+    if ('parent' in fuses && testFuses(fuses.parent)) {
+      return true
+    }
+    if (testFuses(fuses)) {
+      return true
+    }
+  }
+  return false
+}
 
+export function encodeFuses(fuses: Partial<CombinedFuseInput> | number): number
+export function encodeFuses(
+  fuses: CombinedFuseInput['child'],
+  restrictTo: 'child',
+): number
+export function encodeFuses(
+  fuses: CombinedFuseInput['parent'],
+  restrictTo: 'parent',
+): number
+export function encodeFuses<T extends FuseRestriction>(
+  fuses: CombinedFuseInput[T],
+  restrictTo?: T,
+) {
   let encodedFuses: number = 0
 
-  if (isNumber) {
-    if (fuses.fuseNumberToBurn > 2 ** 32 || fuses.fuseNumberToBurn < 1) {
-      throw new Error(
-        `Fuse number must be limited to uint32, ${
-          fuses.fuseNumberToBurn
-        } was too ${fuses.fuseNumberToBurn < 1 ? 'low' : 'high'}.`,
-      )
-    } else if (fuses.fuseNumberToBurn % 1 !== 0) {
-      throw new Error(
-        `Fuse number must be an integer, ${fuses.fuseNumberToBurn} was not.`,
-      )
+  if (typeof fuses === 'number') {
+    if (restrictTo) {
+      throw new Error('Cannot specify an exact fuse value when restricted.')
     }
-    encodedFuses = fuses.fuseNumberToBurn
+    checkNumber(fuses)
+
+    encodedFuses = fuses
   } else {
-    if (!hasNamedArray && !hasUnnamedArray) {
-      throw new Error('Please provide fuses to burn')
+    let fusesRef = fuses as unknown as CombinedFuseInput
+    let allowedNamed: readonly UserSettableFuses['fuse'][] = []
+    let allowedUnnamed: readonly UserSettableFuses['unnamedValues'][] = []
+
+    let namedArray: readonly UserSettableFuses['fuse'][] = []
+    let unnamedArray: readonly UserSettableFuses['unnamedValues'][] = []
+
+    if (restrictTo) {
+      if ('parent' in fuses || 'child' in fuses) {
+        throw new Error("Can't specify fuse category when restricted.")
+      }
+      allowedNamed = restrictTo === 'child' ? childFuseKeys : parentFuseKeys
+      allowedUnnamed =
+        restrictTo === 'child' ? unnamedChildFuses : unnamedParentFuses
+
+      fusesRef = { [restrictTo]: fuses } as unknown as CombinedFuseInput
+    } else {
+      allowedNamed = userSettableFuseKeys
+      allowedUnnamed = unnamedUserSettableFuses
+    }
+    if ('parent' in fusesRef) {
+      if ('named' in fusesRef.parent) namedArray = fusesRef.parent.named
+      if ('unnamed' in fusesRef.parent) unnamedArray = fusesRef.parent.unnamed
+      if ('number' in fusesRef.parent) {
+        if ('named' in fusesRef.parent || 'unnamed' in fusesRef.parent) {
+          throw new Error(
+            'Cannot specify both a fuse number and named/unnamed fuses.',
+          )
+        }
+        checkNumber(fusesRef.parent.number)
+
+        if (
+          (fusesRef.parent.number & PARENT_CONTROLLED_FUSES) !==
+          fusesRef.parent.number
+        ) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the parent's control.",
+          )
+        }
+
+        encodedFuses |= fusesRef.parent.number
+      }
     }
-    if (hasNamedArray) {
-      for (const fuse of fuses.namedFusesToBurn!) {
-        if (!(fuse in fuseEnum)) {
+    if ('child' in fusesRef) {
+      if ('named' in fusesRef.child)
+        namedArray = [...namedArray, ...fusesRef.child.named]
+      if ('unnamed' in fusesRef.child)
+        unnamedArray = [...unnamedArray, ...fusesRef.child.unnamed]
+      if ('number' in fusesRef.child) {
+        if ('named' in fusesRef.child || 'unnamed' in fusesRef.child) {
+          throw new Error(
+            'Cannot specify both a fuse number and named/unnamed fuses.',
+          )
+        }
+        checkNumber(fusesRef.child.number)
+
+        if (
+          (fusesRef.child.number & CHILD_CONTROLLED_FUSES) !==
+          fusesRef.child.number
+        ) {
+          throw new Error(
+            "Cannot specify a fuse value to set that is outside of the owner's control.",
+          )
+        }
+
+        encodedFuses |= fusesRef.child.number
+      }
+    }
+
+    if (!namedArray.length && !unnamedArray.length && !encodedFuses) {
+      throw new Error('Must specify at least one fuse.')
+    }
+
+    for (const fuse of namedArray) {
+      if (!allowedNamed.includes(fuse)) {
+        if (!userSettableFuseKeys.includes(fuse)) {
           throw new Error(`${fuse} is not a valid named fuse.`)
         }
-        encodedFuses |= fuseEnum[fuse]
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`)
       }
+      encodedFuses |= userSettableFuseEnum[fuse]
     }
-    if (hasUnnamedArray) {
-      for (const fuse of fuses.unnamedFusesToBurn!) {
-        if (!unnamedFuses.includes(fuse)) {
+    for (const fuse of unnamedArray) {
+      if (!allowedUnnamed.includes(fuse)) {
+        if (!unnamedUserSettableFuses.includes(fuse)) {
           throw new Error(
-            `${fuse} is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.`,
+            `${fuse} is not a valid unnamed fuse. If you are trying to set a named fuse, use the named property.`,
           )
         }
-        encodedFuses |= fuse
+        throw new Error(`Fuse ${fuse} is not allowed for this operation.`)
       }
+      encodedFuses |= fuse
     }
   }
 
   return encodedFuses
 }
 
-export const decodeFuses = (fuses: BigNumberish) => {
-  const bnFuses = BigNumber.from(fuses)
-
+const decodeNamedFuses = (fuses: number, arr: readonly string[]) => {
   const fuseObj = Object.fromEntries(
-    Object.keys(fuseEnum).map((fuse) => [
+    arr.map((fuse) => [
       fuse,
-      bnFuses.and(fuseEnum[fuse as keyof typeof fuseEnum]).gt(0),
+      (fuses &
+        userSettableFuseEnum[fuse as keyof typeof userSettableFuseEnum]) >
+        0,
     ]),
   )
 
-  if (bnFuses.eq(0)) {
-    fuseObj.CAN_DO_EVERYTHING = true
-  } else {
-    fuseObj.CAN_DO_EVERYTHING = false
-  }
+  return fuseObj
+}
 
-  return fuseObj as CurrentFuses
+const decodeUnnamedFuses = (fuses: number, arr: readonly number[]) => {
+  const fuseObj = Object.fromEntries(
+    arr.map((fuse) => [fuse, (fuses & fuse) > 0]),
+  )
+
+  return fuseObj
 }
 
+export const decodeFuses = (fuses: number) => {
+  const parentNamedFuses = decodeNamedFuses(
+    fuses,
+    fullParentFuseKeys,
+  ) as FullParentFuses['current']
+  const parentUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedParentFuses,
+  ) as ParentFuses['unnamedObject']
+
+  const childNamedFuses = decodeNamedFuses(
+    fuses,
+    childFuseKeys,
+  ) as ChildFuses['current']
+  const childUnnamedFuses = decodeUnnamedFuses(
+    fuses,
+    unnamedChildFuses,
+  ) as ChildFuses['unnamedObject']
+
+  return {
+    parent: {
+      ...parentNamedFuses,
+      unnamed: parentUnnamedFuses,
+    },
+    child: {
+      ...childNamedFuses,
+      CAN_DO_EVERYTHING: (fuses & CHILD_CONTROLLED_FUSES) === 0,
+      unnamed: childUnnamedFuses,
+    },
+  }
+}
+
+export type AllCurrentFuses = ReturnType<typeof decodeFuses>
+
 export default fullFuseEnum

package/src/utils/hexEncodedName.ts

@@ -2,3 +2,6 @@ import packet from 'dns-packet'
 
 export const hexEncodeName = (name: string) =>
   `0x${packet.name.encode(name).toString('hex')}`
+
+export const hexDecodeName = (hex: string): string =>
+  packet.name.decode(Buffer.from(hex.slice(2), 'hex')).toString()