@ensdomains/ensjs 3.0.0-alpha.40 → 3.0.0-alpha.42

package/src/utils/registerHelpers.ts

@@ -1,15 +1,11 @@
 import { defaultAbiCoder } from '@ethersproject/abi/lib/abi-coder'
-import { BigNumberish } from '@ethersproject/bignumber/lib/bignumber'
 import { keccak256 } from '@ethersproject/keccak256'
 import type { PublicResolver } from '../generated'
-import { FuseOptions } from './fuses'
-import generateFuseInput from './generateFuseInput'
+import { CombinedFuseInput, encodeFuses, hasFuses } from './fuses'
 import { labelhash } from './labels'
 import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
-export const MAX_INT_64 = 2n ** 64n - 1n
-
 export type BaseRegistrationParams = {
   owner: string
   duration: number
@@ -17,8 +13,7 @@ export type BaseRegistrationParams = {
   resolverAddress?: string
   records?: RecordOptions
   reverseRecord?: boolean
-  fuses?: FuseOptions
-  wrapperExpiry?: BigNumberish
+  fuses?: CombinedFuseInput['child']
 }
 
 export type RegistrationParams = Omit<
@@ -29,12 +24,8 @@ export type RegistrationParams = Omit<
   resolver: PublicResolver
 }
 
-export type CommitmentParams = Omit<
-  RegistrationParams,
-  'secret' | 'wrapperExpiry'
-> & {
+export type CommitmentParams = Omit<RegistrationParams, 'secret'> & {
   secret?: string
-  wrapperExpiry?: BigNumberish
 }
 
 export type RegistrationTuple = [
@@ -45,20 +36,7 @@ export type RegistrationTuple = [
   resolver: string,
   data: string[],
   reverseRecord: boolean,
-  fuses: string,
-  wrapperExpiry: BigNumberish,
-]
-
-export type CommitmentTuple = [
-  labelhash: string,
-  owner: string,
-  duration: number,
-  resolver: string,
-  data: string[],
-  secret: string,
-  reverseRecord: boolean,
-  fuses: string,
-  wrapperExpiry: BigNumberish,
+  ownerControlledFuses: number,
 ]
 
 export const randomSecret = () => {
@@ -74,15 +52,14 @@ export const makeCommitmentData = ({
   records,
   reverseRecord,
   fuses,
-  wrapperExpiry,
   secret,
 }: CommitmentParams & {
   secret: string
-}): CommitmentTuple => {
-  const label = labelhash(name.split('.')[0])
+}): RegistrationTuple => {
+  const labelHash = labelhash(name.split('.')[0])
   const hash = namehash(name)
   const resolverAddress = resolver.address
-  const fuseData = fuses ? generateFuseInput(fuses) : '0'
+  const fuseData = hasFuses(fuses) ? encodeFuses(fuses!, 'child') : 0
 
   if (reverseRecord) {
     if (!records) {
@@ -96,15 +73,14 @@ export const makeCommitmentData = ({
   const data = records ? generateRecordCallArray(hash, records, resolver) : []
 
   return [
-    label,
+    labelHash,
     owner,
     duration,
+    secret,
     resolverAddress,
     data,
-    secret,
     !!reverseRecord,
     fuseData,
-    wrapperExpiry || MAX_INT_64,
   ]
 }
 
@@ -114,24 +90,21 @@ export const makeRegistrationData = (
   const commitmentData = makeCommitmentData(params)
   const label = params.name.split('.')[0]
   commitmentData[0] = label
-  const secret = commitmentData.splice(5, 1)[0]
-  commitmentData.splice(3, 0, secret)
-  return commitmentData as unknown as RegistrationTuple
+  return commitmentData
 }
 
-export const _makeCommitment = (params: CommitmentTuple) => {
+export const _makeCommitment = (params: RegistrationTuple) => {
   return keccak256(
     defaultAbiCoder.encode(
       [
         'bytes32',
         'address',
         'uint256',
+        'bytes32',
         'address',
         'bytes[]',
-        'bytes32',
         'bool',
-        'uint32',
-        'uint64',
+        'uint16',
       ],
       params,
     ),
@@ -152,6 +125,5 @@ export const makeCommitment = ({
   return {
     secret,
     commitment,
-    wrapperExpiry: generatedParams[8],
   }
 }

package/src/utils/subgraph-types.ts

@@ -0,0 +1,312 @@
+export type Maybe<T> = T | null
+export type Exact<T extends { [key: string]: unknown }> = {
+  [K in keyof T]: T[K]
+}
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]?: Maybe<T[SubKey]>
+}
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+  [SubKey in K]: Maybe<T[SubKey]>
+}
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  Bytes: string
+  BigInt: string
+}
+
+export type Domain = {
+  __typename?: 'Domain'
+  id: Scalars['ID']
+  name?: Maybe<Scalars['String']>
+  labelName?: Maybe<Scalars['String']>
+  labelhash?: Maybe<Scalars['Bytes']>
+  parent?: Maybe<Domain>
+  subdomains: Array<Domain>
+  subdomainCount: Scalars['Int']
+  resolvedAddress?: Maybe<Account>
+  owner: Account
+  resolver?: Maybe<Resolver>
+  ttl?: Maybe<Scalars['BigInt']>
+  isMigrated: Scalars['Boolean']
+  createdAt: Scalars['BigInt']
+  events: Array<DomainEvent>
+  registration?: Maybe<Registration>
+  wrappedDomain?: Maybe<WrappedDomain>
+}
+
+export type DomainEvent = {
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type Transfer = DomainEvent & {
+  __typename?: 'Transfer'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  owner: Account
+}
+
+export type NewOwner = DomainEvent & {
+  __typename?: 'NewOwner'
+  id: Scalars['ID']
+  parentDomain: Domain
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  owner: Account
+}
+
+export type NewResolver = DomainEvent & {
+  __typename?: 'NewResolver'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  resolver: Resolver
+}
+
+export type NewTtl = DomainEvent & {
+  __typename?: 'NewTTL'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  ttl: Scalars['BigInt']
+}
+
+export type WrappedTransfer = DomainEvent & {
+  __typename?: 'WrappedTransfer'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  owner: Account
+}
+
+export type NameWrapped = DomainEvent & {
+  __typename?: 'NameWrapped'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  name: Scalars['String']
+  fuses: Scalars['Int']
+  owner: Account
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameUnwrapped = DomainEvent & {
+  __typename?: 'NameUnwrapped'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  owner: Account
+}
+
+export type FusesSet = DomainEvent & {
+  __typename?: 'FusesSet'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  fuses: Scalars['Int']
+}
+
+export type ExpiryExtended = DomainEvent & {
+  __typename?: 'ExpiryExtended'
+  id: Scalars['ID']
+  domain: Domain
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  expiryDate: Scalars['BigInt']
+}
+
+export type Registration = {
+  __typename?: 'Registration'
+  id: Scalars['ID']
+  domain: Domain
+  registrationDate: Scalars['BigInt']
+  expiryDate: Scalars['BigInt']
+  cost?: Maybe<Scalars['BigInt']>
+  registrant: Account
+  labelName?: Maybe<Scalars['String']>
+  events: Array<RegistrationEvent>
+}
+
+export type RegistrationEvent = {
+  id: Scalars['ID']
+  registration: Registration
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type NameRegistered = RegistrationEvent & {
+  __typename?: 'NameRegistered'
+  id: Scalars['ID']
+  registration: Registration
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  registrant: Account
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameRenewed = RegistrationEvent & {
+  __typename?: 'NameRenewed'
+  id: Scalars['ID']
+  registration: Registration
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  expiryDate: Scalars['BigInt']
+}
+
+export type NameTransferred = RegistrationEvent & {
+  __typename?: 'NameTransferred'
+  id: Scalars['ID']
+  registration: Registration
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  newOwner: Account
+}
+
+export type WrappedDomain = {
+  __typename?: 'WrappedDomain'
+  id: Scalars['ID']
+  domain: Domain
+  expiryDate: Scalars['BigInt']
+  fuses: Scalars['Int']
+  owner: Account
+  name?: Maybe<Scalars['String']>
+}
+
+export type Account = {
+  __typename?: 'Account'
+  id: Scalars['ID']
+  domains: Array<Domain>
+  wrappedDomains?: Maybe<Array<WrappedDomain>>
+  registrations?: Maybe<Array<Registration>>
+}
+
+export type Resolver = {
+  __typename?: 'Resolver'
+  id: Scalars['ID']
+  domain?: Maybe<Domain>
+  address: Scalars['Bytes']
+  addr?: Maybe<Account>
+  contentHash?: Maybe<Scalars['Bytes']>
+  texts?: Maybe<Array<Scalars['String']>>
+  coinTypes?: Maybe<Array<Scalars['BigInt']>>
+  events: Array<ResolverEvent>
+}
+
+export type ResolverEvent = {
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+}
+
+export type AddrChanged = ResolverEvent & {
+  __typename?: 'AddrChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  addr: Account
+}
+
+export type MulticoinAddrChanged = ResolverEvent & {
+  __typename?: 'MulticoinAddrChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  coinType: Scalars['BigInt']
+  addr: Scalars['Bytes']
+}
+
+export type NameChanged = ResolverEvent & {
+  __typename?: 'NameChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  name: Scalars['String']
+}
+
+export type AbiChanged = ResolverEvent & {
+  __typename?: 'AbiChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  contentType: Scalars['BigInt']
+}
+
+export type PubkeyChanged = ResolverEvent & {
+  __typename?: 'PubkeyChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  x: Scalars['Bytes']
+  y: Scalars['Bytes']
+}
+
+export type TextChanged = ResolverEvent & {
+  __typename?: 'TextChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  key: Scalars['String']
+  value?: Maybe<Scalars['String']>
+}
+
+export type ContenthashChanged = ResolverEvent & {
+  __typename?: 'ContenthashChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  hash: Scalars['Bytes']
+}
+
+export type InterfaceChanged = ResolverEvent & {
+  __typename?: 'InterfaceChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  interfaceID: Scalars['Bytes']
+  implementer: Scalars['Bytes']
+}
+
+export type AuthorisationChanged = ResolverEvent & {
+  __typename?: 'AuthorisationChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  owner: Scalars['Bytes']
+  target: Scalars['Bytes']
+  isAuthorized: Scalars['Boolean']
+}
+
+export type VersionChanged = ResolverEvent & {
+  __typename?: 'VersionChanged'
+  id: Scalars['ID']
+  resolver: Resolver
+  blockNumber: Scalars['Int']
+  transactionID: Scalars['Bytes']
+  version: Scalars['BigInt']
+}

package/src/utils/wrapper.ts

@@ -1,5 +1,5 @@
 import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
-import { toUtf8Bytes } from '@ethersproject/strings/lib/utf8'
+import { toUtf8Bytes } from '@ethersproject/strings'
 import { ENSArgs } from '../index'
 
 export type Expiry = string | number | Date | BigNumber

package/dist/cjs/utils/generateFuseInput.js

@@ -1,40 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var generateFuseInput_exports = {};
-__export(generateFuseInput_exports, {
-  default: () => generateFuseInput_default
-});
-module.exports = __toCommonJS(generateFuseInput_exports);
-var import_bignumber = require("@ethersproject/bignumber/lib/bignumber");
-var import_fuses = __toESM(require("./fuses"));
-var generateFuseInput_default = (fuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions).filter(
-    (opt) => fuseOptions[opt] === true
-  );
-  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
-    return prev.or(import_fuses.default[curr]);
-  }, import_bignumber.BigNumber.from(0));
-  return bigNumberFuses.toHexString();
-};

package/dist/esm/functions/burnFuses.mjs

@@ -1,12 +0,0 @@
-// src/functions/burnFuses.ts
-import { validateFuses } from "../utils/fuses.mjs";
-import { namehash } from "../utils/normalise.mjs";
-async function burnFuses_default({ contracts, signer }, name, props) {
-  const encodedFuses = validateFuses(props);
-  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
-  const hash = namehash(name);
-  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
-}
-export {
-  burnFuses_default as default
-};

package/dist/esm/utils/generateFuseInput.mjs

@@ -1,15 +0,0 @@
-// src/utils/generateFuseInput.ts
-import { BigNumber } from "@ethersproject/bignumber/lib.esm/bignumber.js";
-import fuses from "./fuses.mjs";
-var generateFuseInput_default = (fuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions).filter(
-    (opt) => fuseOptions[opt] === true
-  );
-  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
-    return prev.or(fuses[curr]);
-  }, BigNumber.from(0));
-  return bigNumberFuses.toHexString();
-};
-export {
-  generateFuseInput_default as default
-};

package/dist/types/functions/burnFuses.d.ts

@@ -1,3 +0,0 @@
-import { ENSArgs } from '..';
-import { FuseProps } from '../utils/fuses';
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("@ethersproject/contracts").PopulatedTransaction>;

package/dist/types/utils/generateFuseInput.d.ts

@@ -1,3 +0,0 @@
-import { FuseOptions } from './fuses';
-declare const _default: (fuseOptions: FuseOptions) => string;
-export default _default;

package/src/functions/burnFuses.test.ts

@@ -1,148 +0,0 @@
-import { ethers } from 'ethers'
-import { ENS } from '..'
-import setup from '../tests/setup'
-import { namehash } from '../utils/normalise'
-
-let ensInstance: ENS
-let revert: Awaited<ReturnType<typeof setup>>['revert']
-let provider: ethers.providers.JsonRpcProvider
-let accounts: string[]
-
-beforeAll(async () => {
-  ;({ ensInstance, revert, provider } = await setup())
-  accounts = await provider.listAccounts()
-})
-
-afterAll(async () => {
-  await revert()
-})
-
-describe('burnFuses', () => {
-  beforeEach(async () => {
-    await revert()
-  })
-  describe('Array', () => {
-    it('should return a burnFuses transaction from a named fuse array and succeed', async () => {
-      const tx = await ensInstance.burnFuses('wrapped.eth', {
-        namedFusesToBurn: [
-          'CANNOT_UNWRAP',
-          'CANNOT_CREATE_SUBDOMAIN',
-          'CANNOT_SET_TTL',
-        ],
-        addressOrIndex: accounts[1],
-      })
-      expect(tx).toBeTruthy()
-      await tx.wait()
-
-      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
-      expect(fuses).toBe(113)
-    })
-    it('should return a burnFuses transaction from an unnamed fuse array and succeed', async () => {
-      const tx0 = await ensInstance.burnFuses('wrapped.eth', {
-        namedFusesToBurn: ['CANNOT_UNWRAP'],
-        addressOrIndex: accounts[1],
-      })
-      expect(tx0).toBeTruthy()
-      await tx0.wait()
-
-      const tx = await ensInstance.burnFuses('wrapped.eth', {
-        unnamedFusesToBurn: [128, 256, 512],
-        addressOrIndex: accounts[1],
-      })
-      expect(tx).toBeTruthy()
-      await tx.wait()
-
-      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
-      expect(fuses).toBe(961)
-    })
-    it('should return a burnFuses transaction from both an unnamed and named fuse array and succeed', async () => {
-      const tx = await ensInstance.burnFuses('wrapped.eth', {
-        namedFusesToBurn: [
-          'CANNOT_UNWRAP',
-          'CANNOT_CREATE_SUBDOMAIN',
-          'CANNOT_SET_TTL',
-        ],
-        unnamedFusesToBurn: [128, 256, 512],
-        addressOrIndex: accounts[1],
-      })
-      expect(tx).toBeTruthy()
-      await tx.wait()
-
-      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
-      expect(fuses).toBe(1009)
-    })
-    it('should throw an error when trying to burn a named fuse in an unnamed fuse array', async () => {
-      try {
-        await ensInstance.burnFuses('wrapped.eth', {
-          unnamedFusesToBurn: [64] as any,
-        })
-        expect(false).toBeTruthy()
-      } catch (e: any) {
-        expect(e.message).toBe(
-          '64 is not a valid unnamed fuse. If you are trying to burn a named fuse, use the namedFusesToBurn property.',
-        )
-      }
-    })
-    it('should throw an error when trying to burn an unnamed fuse in a named fuse array', async () => {
-      try {
-        await ensInstance.burnFuses('wrapped.eth', {
-          namedFusesToBurn: ['COOL_SWAG_FUSE'] as any,
-        })
-        expect(false).toBeTruthy()
-      } catch (e: any) {
-        expect(e.message).toBe('COOL_SWAG_FUSE is not a valid named fuse.')
-      }
-    })
-  })
-  describe('Number', () => {
-    it('should return a burnFuses transaction from a number and succeed', async () => {
-      const tx = await ensInstance.burnFuses('wrapped.eth', {
-        fuseNumberToBurn: 49,
-        addressOrIndex: accounts[1],
-      })
-      expect(tx).toBeTruthy()
-      await tx.wait()
-
-      const nameWrapper = await ensInstance.contracts!.getNameWrapper()!
-      const [, fuses] = await nameWrapper.getData(namehash('wrapped.eth'))
-      expect(fuses).toBe(113)
-    })
-    it('should throw an error if the number is too high', async () => {
-      try {
-        await ensInstance.burnFuses('wrapped.eth', {
-          fuseNumberToBurn: 4294967297,
-        })
-        expect(false).toBeTruthy()
-      } catch (e: any) {
-        expect(e.message).toBe(
-          'Fuse number must be limited to uint32, 4294967297 was too high.',
-        )
-      }
-    })
-    it('should throw an error if the number is too low', async () => {
-      try {
-        await ensInstance.burnFuses('wrapped.eth', {
-          fuseNumberToBurn: -1,
-        })
-        expect(false).toBeTruthy()
-      } catch (e: any) {
-        expect(e.message).toBe(
-          'Fuse number must be limited to uint32, -1 was too low.',
-        )
-      }
-    })
-    it('should throw an error if the number is not an integer', async () => {
-      try {
-        await ensInstance.burnFuses('wrapped.eth', {
-          fuseNumberToBurn: 7.5,
-        })
-        expect(false).toBeTruthy()
-      } catch (e: any) {
-        expect(e.message).toBe('Fuse number must be an integer, 7.5 was not.')
-      }
-    })
-  })
-})

package/src/functions/burnFuses.ts

@@ -1,16 +0,0 @@
-import { ENSArgs } from '..'
-import { FuseProps, validateFuses } from '../utils/fuses'
-import { namehash } from '../utils/normalise'
-
-export default async function (
-  { contracts, signer }: ENSArgs<'contracts' | 'signer'>,
-  name: string,
-  props: FuseProps,
-) {
-  const encodedFuses = validateFuses(props)
-
-  const nameWrapper = (await contracts!.getNameWrapper()!).connect(signer)
-  const hash = namehash(name)
-
-  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses)
-}