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

package/src/utils/labels.ts

@@ -64,21 +64,19 @@ export function saveLabel(label: string) {
 
 export function saveName(name: string) {
   const nameArray = name.split('.')
-  nameArray.forEach((label: any) => {
-    saveLabel(label)
-  })
+  for (const label of nameArray) {
+    if (!isEncodedLabelhash(label)) {
+      saveLabel(label)
+    }
+  }
 }
 
-// eslint-disable-next-line consistent-return
-export function checkLabel(hash: string): string | undefined {
+export function checkLabel(hash: string): string {
   const labels = getLabels()
   if (isEncodedLabelhash(hash)) {
-    return labels[decodeLabelhash(hash)]
-  }
-
-  if (hash.startsWith('0x')) {
-    return labels[`${hash.slice(2)}`]
+    return labels[decodeLabelhash(hash)] || hash
   }
+  return hash
 }
 
 export function encodeLabel(label: any) {
@@ -101,7 +99,7 @@ export function checkIsDecrypted(string: string | string[]) {
 export function decryptName(name: string) {
   return name
     .split('.')
-    .map((label: any) => checkLabel(label) || label)
+    .map((label: any) => checkLabel(label))
     .join('.')
 }
 
@@ -119,3 +117,7 @@ export function checkLocalStorageSize() {
     ? `${3 + (allStrings.length * 16) / (8 * 1024)} KB`
     : 'Empty (0 KB)'
 }
+
+const encodedLabelRegex = /\[[a-fA-F0-9]{64}\]/g
+export const getEncryptedLabelAmount = (name: string) =>
+  name.match(encodedLabelRegex)?.length || 0

package/src/utils/normalise.ts

@@ -1,6 +1,6 @@
 import { concat, hexlify } from '@ethersproject/bytes'
 import { keccak256 } from '@ethersproject/keccak256'
-import { toUtf8Bytes } from '@ethersproject/strings/lib/utf8'
+import { toUtf8Bytes } from '@ethersproject/strings'
 import uts46 from 'idna-uts46-hx/uts46bundle.js'
 import { decodeLabelhash, isEncodedLabelhash } from './labels'
 

package/src/utils/recordHelpers.ts

@@ -1,6 +1,7 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import { isBytesLike } from '@ethersproject/bytes'
+import { toUtf8Bytes } from '@ethersproject/strings'
 import type { BigNumberish } from 'ethers'
-import { isBytesLike, toUtf8Bytes } from 'ethers/lib/utils'
 import type { PublicResolver } from '../generated'
 import { encodeContenthash } from './contentHash'
 

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 { defaultAbiCoder } from '@ethersproject/abi'
 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 { BigNumber } from '@ethersproject/bignumber'
+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;