@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.10

package/src/utils/registerHelpers.ts

@@ -1,87 +1,157 @@
-import { utils } from 'ethers'
-import type { FuseOptions } from '../@types/FuseOptions'
-import type { PublicResolver } from '../generated'
-import generateFuseInput from './generateFuseInput'
-import { labelhash } from './labels'
-import { namehash } from './normalise'
-import { generateRecordCallArray, RecordOptions } from './recordHelpers'
+import {
+  encodeAbiParameters,
+  keccak256,
+  labelhash,
+  pad,
+  toBytes,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
+import { CampaignReferenceTooLargeError } from '../errors/utils.js'
+import { EMPTY_ADDRESS } from './consts.js'
+import { encodeFuses, type EncodeChildFusesInputObject } from './fuses.js'
+import {
+  generateRecordCallArray,
+  type RecordOptions,
+} from './generateRecordCallArray.js'
+import { namehash } from './normalise.js'
 
-export const randomSecret = () => {
-  const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+export type RegistrationParameters = {
+  /** Name to register */
+  name: string
+  /** Address to set owner to */
+  owner: Address
+  /** Duration of registration */
+  duration: number
+  /** Random 32 bytes to use for registration */
+  secret: Hex
+  /** Custom resolver address, defaults to current public resolver deployment */
+  resolverAddress?: Address
+  /** Records to set upon registration */
+  records?: RecordOptions
+  /** Sets primary name upon registration */
+  reverseRecord?: boolean
+  /** Fuses to set upon registration */
+  fuses?: EncodeChildFusesInputObject
 }
 
-export const makeCommitment = ({
+export type CommitmentTuple = [
+  labelHash: Hex,
+  owner: Address,
+  duration: bigint,
+  secret: Hex,
+  resolver: Address,
+  data: Hex[],
+  reverseRecord: boolean,
+  ownerControlledFuses: number,
+]
+
+export type RegistrationTuple = [
+  label: string,
+  owner: Address,
+  duration: bigint,
+  secret: Hex,
+  resolver: Address,
+  data: Hex[],
+  reverseRecord: boolean,
+  ownerControlledFuses: number,
+]
+
+export const randomSecret = ({
+  platformDomain,
+  campaign,
+}: {
+  platformDomain?: string
+  campaign?: number
+} = {}) => {
+  const bytes = crypto.getRandomValues(new Uint8Array(32))
+  if (platformDomain) {
+    const hash = toBytes(namehash(platformDomain))
+    for (let i = 0; i < 4; i += 1) {
+      bytes[i] = hash[i]
+    }
+  }
+  if (campaign) {
+    if (campaign > 0xffffffff)
+      throw new CampaignReferenceTooLargeError({ campaign })
+    const campaignBytes = pad(toBytes(campaign), { size: 4 })
+    for (let i = 0; i < 4; i += 1) {
+      bytes[i + 4] = campaignBytes[i]
+    }
+  }
+  return toHex(bytes)
+}
+
+export const makeCommitmentTuple = ({
   name,
   owner,
   duration,
-  resolver,
-  records,
+  resolverAddress = EMPTY_ADDRESS,
+  records: { coins = [], ...records } = { texts: [], coins: [] },
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
-  const label = labelhash(name.split('.')[0])
+  secret,
+}: RegistrationParameters): CommitmentTuple => {
+  const labelHash = labelhash(name.split('.')[0])
   const hash = namehash(name)
-  const resolverAddress = resolver.address
-  const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
-  const fuseData = fuses ? generateFuseInput(fuses) : '0'
+  const fuseData = fuses
+    ? encodeFuses({ restriction: 'child', input: fuses })
+    : 0
+
+  if (
+    reverseRecord &&
+    !coins.find(
+      (c) =>
+        c.coin === 'ETH' ||
+        (typeof c.coin === 'string' ? parseInt(c.coin) === 60 : c.coin === 60),
+    )
+  ) {
+    coins.push({ coin: 60, value: owner })
+  }
+
+  const data = records
+    ? generateRecordCallArray({ namehash: hash, coins, ...records })
+    : []
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  return [
+    labelHash,
     owner,
-    duration,
+    BigInt(duration),
     secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
-  })
+    !!reverseRecord,
+    fuseData,
+  ]
+}
 
-  return {
-    secret,
-    commitment,
-  }
+export const makeRegistrationTuple = (
+  params: RegistrationParameters,
+): RegistrationTuple => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const [_labelhash, ...commitmentData] = makeCommitmentTuple(params)
+  const label = params.name.split('.')[0]
+  return [label, ...commitmentData]
 }
 
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
+export const makeCommitmentFromTuple = (params: CommitmentTuple): Hex => {
+  return keccak256(
+    encodeAbiParameters(
+      [
+        { name: 'name', type: 'bytes32' },
+        { name: 'owner', type: 'address' },
+        { name: 'duration', type: 'uint256' },
+        { name: 'secret', type: 'bytes32' },
+        { name: 'resolver', type: 'address' },
+        { name: 'data', type: 'bytes[]' },
+        { name: 'reverseRecord', type: 'bool' },
+        { name: 'ownerControlledFuses', type: 'uint16' },
+      ],
+      params,
+    ),
   )
 }
+
+export const makeCommitment = (params: RegistrationParameters): Hex =>
+  makeCommitmentFromTuple(makeCommitmentTuple(params))

package/src/utils/validation.ts

@@ -1,73 +1,79 @@
-import { isAddress } from 'ethers/lib/utils'
-import { isEncodedLabelhash, saveName } from './labels'
-import { normalise } from './normalise'
+import {
+  NameWithEmptyLabelsError,
+  RootNameIncludesOtherLabelsError,
+} from '../errors/utils.js'
+import { MINIMUM_DOT_ETH_CHARS } from './consts.js'
+import { checkLabel, isEncodedLabelhash, saveName } from './labels.js'
+import { normalise, split, type Label } from './normalise.js'
 
 export const validateName = (name: string) => {
   const nameArray = name.split('.')
-  const hasEmptyLabels = nameArray.some((label) => label.length == 0)
-  if (hasEmptyLabels) throw new Error('Name cannot have empty labels')
-  const normalizedArray = nameArray.map((label) => {
+  const normalisedArray = nameArray.map((label) => {
+    if (label.length === 0) throw new NameWithEmptyLabelsError({ name })
     if (label === '[root]') {
+      if (name !== label) throw new RootNameIncludesOtherLabelsError({ name })
       return label
-    } else {
-      return isEncodedLabelhash(label) ? label : normalise(label)
     }
+    return isEncodedLabelhash(label)
+      ? checkLabel(label) || label
+      : normalise(label)
   })
-  const normalizedName = normalizedArray.join('.')
-  saveName(normalizedName)
-  return normalizedName
+  const normalisedName = normalisedArray.join('.')
+  saveName(normalisedName)
+  return normalisedName
 }
 
-export const validateTLD = (name: string) => {
-  const labels = name.split('.')
-  return validateName(labels[labels.length - 1])
+export type ParsedInputResult = {
+  type: 'name' | 'label'
+  normalised: string | undefined
+  isValid: boolean
+  isShort: boolean
+  is2LD: boolean
+  isETH: boolean
+  labelDataArray: Label[]
 }
 
-type InputType = {
-  type: 'name' | 'label' | 'address' | 'unknown'
-  info?: 'short' | 'supported' | 'unsupported'
-}
-
-export const parseInputType = (input: string): InputType => {
-  const validTLD = validateTLD(input)
-  let regex = /[^.]+$/
+export const parseInput = (input: string): ParsedInputResult => {
+  let nameReference = input
+  let isValid = false
 
   try {
-    validateName(input)
-  } catch (e) {
-    return {
-      type: 'unknown',
-    }
-  }
+    nameReference = validateName(input)
+    isValid = true
+  } catch {}
 
-  if (input.indexOf('.') !== -1) {
-    const termArray = input.split('.')
-    const tld = input.match(regex) ? input.match(regex)![0] : ''
-    if (validTLD) {
-      if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
-        // code-point length
-        return {
-          type: 'name',
-          info: 'short',
-        }
-      }
-      return {
-        type: 'name',
-        info: 'supported',
-      }
-    }
+  const normalisedName = isValid ? nameReference : undefined
 
-    return {
-      type: 'name',
-      info: 'unsupported',
-    }
-  } else if (isAddress(input)) {
-    return {
-      type: 'address',
-    }
-  } else {
+  const labels = nameReference.split('.')
+  const tld = labels[labels.length - 1]
+  const isETH = tld === 'eth'
+  const labelDataArray = split(nameReference)
+  const isShort =
+    (labelDataArray[0].output?.length || 0) < MINIMUM_DOT_ETH_CHARS
+
+  if (labels.length === 1) {
     return {
       type: 'label',
+      normalised: normalisedName,
+      isShort,
+      isValid,
+      is2LD: false,
+      isETH,
+      labelDataArray,
     }
   }
+
+  const is2LD = labels.length === 2
+  return {
+    type: 'name',
+    normalised: normalisedName,
+    isShort: isETH && is2LD ? isShort : false,
+    isValid,
+    is2LD,
+    isETH,
+    labelDataArray,
+  }
 }
+
+export const checkIsDotEth = (labels: string[]) =>
+  labels.length === 2 && labels[1] === 'eth'

package/src/utils/wrapper.ts

@@ -0,0 +1,20 @@
+import { stringToBytes } from 'viem'
+import { WrappedLabelTooLargeError } from '../errors/utils.js'
+import type { AnyDate } from '../types.js'
+
+export const MAX_EXPIRY = 2n ** 64n - 1n
+
+export const expiryToBigInt = (expiry?: AnyDate, defaultValue = 0n): bigint => {
+  if (!expiry) return defaultValue
+  if (typeof expiry === 'bigint') return expiry
+  if (typeof expiry === 'string' || typeof expiry === 'number')
+    return BigInt(expiry)
+  if (expiry instanceof Date) return BigInt(Math.floor(expiry.getTime() / 1000))
+  throw new TypeError('Expiry must be a bigint, string, number or Date')
+}
+
+export const wrappedLabelLengthCheck = (label: string) => {
+  const bytes = stringToBytes(label)
+  if (bytes.byteLength > 255)
+    throw new WrappedLabelTooLargeError({ label, byteLength: bytes.byteLength })
+}

package/src/wallet.ts

@@ -0,0 +1,126 @@
+export {
+  default as clearRecords,
+  type ClearRecordsDataParameters,
+  type ClearRecordsDataReturnType,
+  type ClearRecordsParameters,
+  type ClearRecordsReturnType,
+} from './functions/wallet/clearRecords.js'
+export {
+  default as commitName,
+  type CommitNameDataParameters,
+  type CommitNameDataReturnType,
+  type CommitNameParameters,
+  type CommitNameReturnType,
+} from './functions/wallet/commitName.js'
+export {
+  default as createSubname,
+  type CreateSubnameDataParameters,
+  type CreateSubnameDataReturnType,
+  type CreateSubnameParameters,
+  type CreateSubnameReturnType,
+} from './functions/wallet/createSubname.js'
+export {
+  default as deleteSubname,
+  type DeleteSubnameDataParameters,
+  type DeleteSubnameDataReturnType,
+  type DeleteSubnameParameters,
+  type DeleteSubnameReturnType,
+} from './functions/wallet/deleteSubname.js'
+export {
+  default as registerName,
+  type RegisterNameDataParameters,
+  type RegisterNameDataReturnType,
+  type RegisterNameParameters,
+  type RegisterNameReturnType,
+} from './functions/wallet/registerName.js'
+export {
+  default as renewNames,
+  type RenewNamesDataParameters,
+  type RenewNamesDataReturnType,
+  type RenewNamesParameters,
+  type RenewNamesReturnType,
+} from './functions/wallet/renewNames.js'
+export {
+  default as setAbiRecord,
+  type SetAbiRecordDataParameters,
+  type SetAbiRecordDataReturnType,
+  type SetAbiRecordParameters,
+  type SetAbiRecordReturnType,
+} from './functions/wallet/setAbiRecord.js'
+export {
+  default as setAddressRecord,
+  type SetAddressRecordDataParameters,
+  type SetAddressRecordDataReturnType,
+  type SetAddressRecordParameters,
+  type SetAddressRecordReturnType,
+} from './functions/wallet/setAddressRecord.js'
+export {
+  default as setChildFuses,
+  type SetChildFusesDataParameters,
+  type SetChildFusesDataReturnType,
+  type SetChildFusesParameters,
+  type SetChildFusesReturnType,
+} from './functions/wallet/setChildFuses.js'
+export {
+  default as setContentHashRecord,
+  type SetContentHashRecordDataParameters,
+  type SetContentHashRecordDataReturnType,
+  type SetContentHashRecordParameters,
+  type SetContentHashRecordReturnType,
+} from './functions/wallet/setContentHashRecord.js'
+export {
+  default as setFuses,
+  type SetFusesDataParameters,
+  type SetFusesDataReturnType,
+  type SetFusesParameters,
+  type SetFusesReturnType,
+} from './functions/wallet/setFuses.js'
+export {
+  default as setPrimaryName,
+  type SetPrimaryNameDataParameters,
+  type SetPrimaryNameDataReturnType,
+  type SetPrimaryNameParameters,
+  type SetPrimaryNameReturnType,
+} from './functions/wallet/setPrimaryName.js'
+export {
+  default as setRecords,
+  type SetRecordsDataParameters,
+  type SetRecordsDataReturnType,
+  type SetRecordsParameters,
+  type SetRecordsReturnType,
+} from './functions/wallet/setRecords.js'
+export {
+  default as setResolver,
+  type SetResolverDataParameters,
+  type SetResolverDataReturnType,
+  type SetResolverParameters,
+  type SetResolverReturnType,
+} from './functions/wallet/setResolver.js'
+export {
+  default as setTextRecord,
+  type SetTextRecordDataParameters,
+  type SetTextRecordDataReturnType,
+  type SetTextRecordParameters,
+  type SetTextRecordReturnType,
+} from './functions/wallet/setTextRecord.js'
+export {
+  default as transferName,
+  type TransferNameDataParameters,
+  type TransferNameDataReturnType,
+  type TransferNameParameters,
+  type TransferNameReturnType,
+} from './functions/wallet/transferName.js'
+export {
+  default as unwrapName,
+  type UnwrapNameDataParameters,
+  type UnwrapNameDataReturnType,
+  type UnwrapNameParameters,
+  type UnwrapNameReturnType,
+} from './functions/wallet/unwrapName.js'
+export {
+  default as wrapName,
+  type WrapNameDataParameters,
+  type WrapNameDataReturnType,
+  type WrapNameParameters,
+  type WrapNameReturnType,
+} from './functions/wallet/wrapName.js'

package/subgraph/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/subgraph.d.ts",
+  "module": "../dist/esm/subgraph.js",
+  "main": "../dist/cjs/subgraph.js"
+}

package/utils/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/utils/index.d.ts",
+  "module": "../dist/esm/utils/index.js",
+  "main": "../dist/cjs/utils/index.js"
+}

package/wallet/package.json

@@ -0,0 +1,5 @@
+{
+  "types": "../dist/types/wallet.d.ts",
+  "module": "../dist/esm/wallet.js",
+  "main": "../dist/cjs/wallet.js"
+}

package/dist/cjs/GqlManager.d.ts

@@ -1,9 +0,0 @@
-export declare const enter: (node: any) => any;
-export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
-export declare const responseMiddleware: (traverse: any) => (response: any) => any;
-export default class GqlManager {
-    gql: any;
-    client?: any | null;
-    setUrl: (url: string | null) => Promise<void>;
-    request: (...arg: any[]) => any;
-}

package/dist/cjs/GqlManager.js

@@ -1,102 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.responseMiddleware = exports.requestMiddleware = exports.enter = void 0;
-// @ts-nocheck
-const normalise_1 = require("./utils/normalise");
-const generateSelection = (selection) => ({
-    kind: 'Field',
-    name: {
-        kind: 'Name',
-        value: selection,
-    },
-    arguments: [],
-    directives: [],
-    alias: undefined,
-    selectionSet: undefined,
-});
-const enter = (node) => {
-    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;
-        }
-    }
-};
-exports.enter = enter;
-const requestMiddleware = (visit, parse) => (request) => {
-    const requestBody = JSON.parse(request.body);
-    const rawQuery = requestBody.query;
-    const parsedQuery = parse(rawQuery);
-    const updatedQuery = visit(parsedQuery, { enter: exports.enter });
-    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
-    return {
-        ...request,
-        body: JSON.stringify(updatedBody),
-    };
-};
-exports.requestMiddleware = requestMiddleware;
-const responseMiddleware = (traverse) => (response) => {
-    traverse(response).forEach(function (responseItem) {
-        if (responseItem instanceof Object && responseItem.name) {
-            //Name already in hashed form
-            if (responseItem.name && responseItem.name.includes('[')) {
-                return;
-            }
-            const hashedName = (0, normalise_1.namehash)(responseItem.name);
-            if (responseItem.id !== hashedName) {
-                this.update({ ...responseItem, name: hashedName, invalidName: true });
-            }
-        }
-    });
-    return response;
-};
-exports.responseMiddleware = responseMiddleware;
-class GqlManager {
-    gql = () => null;
-    client = null;
-    setUrl = async (url) => {
-        if (url) {
-            const [imported, traverse, { visit, parse }] = await Promise.all([
-                Promise.resolve().then(() => __importStar(require('graphql-request'))),
-                Promise.resolve().then(() => __importStar(require('traverse'))),
-                Promise.resolve().then(() => __importStar(require('graphql/language'))),
-            ]);
-            this.client = new imported.GraphQLClient(url, {
-                requestMiddleware: (0, exports.requestMiddleware)(visit, parse),
-                responseMiddleware: (0, exports.responseMiddleware)(traverse.default),
-            });
-            this.gql = imported.gql;
-        }
-        else {
-            this.client = null;
-            this.gql = () => null;
-        }
-    };
-    request = (...arg) => this.client ? this.client.request(...arg) : null;
-}
-exports.default = GqlManager;

package/dist/cjs/contracts/baseRegistrar.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
-export default _default;

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/DoNotCallOnChainUniversalResolverProxy").DoNotCallOnChainUniversalResolverProxy;
-export default _default;

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const DoNotCallOnChainUniversalResolverProxy__factory_1 = require("../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory");
-exports.default = (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory_1.DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);

package/dist/cjs/contracts/ethRegistrarController.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ETHRegistrarController;
-export default _default;

package/dist/cjs/contracts/getContractAddress.d.ts

@@ -1,3 +0,0 @@
-import { ContractName, SupportedNetworkId } from './types';
-export declare type ContractAddressFetch = (contractName: ContractName) => string;
-export declare const getContractAddress: (networkId: SupportedNetworkId) => ContractAddressFetch;