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

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("ethers").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)
-}

package/src/utils/generateFuseInput.ts

@@ -1,13 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
-import fuses, { FuseOptions } from './fuses'
-
-export default (fuseOptions: FuseOptions) => {
-  const fuseKeys = Object.keys(fuseOptions).filter(
-    (opt) => fuseOptions[opt as keyof FuseOptions] === true,
-  )
-
-  const bigNumberFuses = fuseKeys.reduce((prev, curr) => {
-    return prev.or(fuses[curr as keyof typeof fuses])
-  }, BigNumber.from(0))
-  return bigNumberFuses.toHexString()
-}