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

package/src/utils/recordHelpers.ts

@@ -1,4 +1,6 @@
 import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder'
+import type { BigNumberish } from 'ethers'
+import { isBytesLike, toUtf8Bytes } from 'ethers/lib/utils'
 import type { PublicResolver } from '../generated'
 import { encodeContenthash } from './contentHash'
 
@@ -7,10 +9,19 @@ type RecordItem = {
   value: string
 }
 
+type ABIEncodeAs = 'json' | 'zlib' | 'cbor' | 'uri'
+
+type ABIItem = {
+  contentType?: BigNumberish
+  data: object | string
+}
+
 export type RecordOptions = {
+  clearRecords?: boolean
   contentHash?: string
   texts?: RecordItem[]
   coinTypes?: RecordItem[]
+  abi?: ABIItem
 }
 
 export const generateSetAddr = (
@@ -20,7 +31,7 @@ export const generateSetAddr = (
   resolver: PublicResolver,
 ) => {
   let coinTypeInstance
-  if (!isNaN(parseInt(coinType))) {
+  if (!Number.isNaN(parseInt(coinType))) {
     coinTypeInstance = formatsByCoinType[parseInt(coinType)]
   } else {
     coinTypeInstance = formatsByName[coinType.toUpperCase()]
@@ -33,6 +44,97 @@ export const generateSetAddr = (
   )
 }
 
+export const generateABIInput = async (
+  encodeAs: ABIEncodeAs,
+  data: object | string,
+) => {
+  let contentType: number
+  let encodedData: string | Buffer | Uint8Array
+  switch (encodeAs) {
+    case 'json':
+      contentType = 1
+      encodedData = JSON.stringify(data)
+      break
+    case 'zlib': {
+      contentType = 2
+      const { deflate } = await import('pako/dist/pako_deflate.min.js')
+      encodedData = deflate(JSON.stringify(data))
+      break
+    }
+    case 'cbor': {
+      contentType = 4
+      const { encode } = await import('cbor')
+      encodedData = encode(data)
+      break
+    }
+    default: {
+      contentType = 8
+      encodedData = data as string
+      break
+    }
+  }
+  return { contentType, data: encodedData }
+}
+
+export type RecordTypes = 'contentHash' | 'text' | 'addr' | 'abi'
+
+export type RecordInput<T extends RecordTypes> = T extends 'contentHash'
+  ? string
+  : T extends 'abi'
+  ? ABIItem
+  : RecordItem
+
+export function generateSingleRecordCall<T extends RecordTypes>(
+  namehash: string,
+  resolver: PublicResolver,
+  type: T,
+): (record: RecordInput<T>) => string {
+  if (type === 'contentHash') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as string
+      let _contentHash = ''
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record)
+        if (encoded.error) throw new Error(encoded.error)
+        _contentHash = encoded.encoded as string
+      }
+      return resolver.interface.encodeFunctionData('setContenthash', [
+        namehash,
+        _contentHash,
+      ])
+    }
+  }
+  if (type === 'abi') {
+    return (_r: RecordInput<T>) => {
+      const record = _r as ABIItem
+      const { contentType = 1, data } = record
+      let encodedData = data as string | Uint8Array | Buffer
+      if (!isBytesLike(encodedData)) {
+        if (typeof encodedData === 'object') {
+          encodedData = JSON.stringify(encodedData)
+        }
+        encodedData = toUtf8Bytes(encodedData)
+      }
+      return resolver.interface.encodeFunctionData('setABI', [
+        namehash,
+        contentType,
+        encodedData,
+      ])
+    }
+  }
+  return (_r: RecordInput<T>) => {
+    const record = _r as RecordItem
+    if (type === 'text') {
+      return resolver.interface.encodeFunctionData('setText', [
+        namehash,
+        record.key,
+        record.value,
+      ])
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver)
+  }
+}
+
 export const generateRecordCallArray = (
   namehash: string,
   records: RecordOptions,
@@ -40,32 +142,31 @@ export const generateRecordCallArray = (
 ) => {
   const calls: string[] = []
 
-  if (records.contentHash) {
-    const contentHash =
-      records.contentHash === '' ? '' : encodeContenthash(records.contentHash)
-    const data = (resolver?.interface.encodeFunctionData as any)(
-      'setContenthash',
-      [namehash, contentHash],
+  if (records.clearRecords) {
+    calls.push(
+      resolver.interface.encodeFunctionData('clearRecords', [namehash]),
     )
-    data && calls.push(data)
+  }
+
+  if (records.contentHash) {
+    const data = generateSingleRecordCall(
+      namehash,
+      resolver,
+      'contentHash',
+    )(records.contentHash)
+    if (data) calls.push(data)
   }
 
   if (records.texts && records.texts.length > 0) {
-    records.texts.forEach(({ key, value }: RecordItem) => {
-      const data = resolver?.interface.encodeFunctionData('setText', [
-        namehash,
-        key,
-        value,
-      ])
-      data && calls.push(data)
-    })
+    records.texts
+      .map(generateSingleRecordCall(namehash, resolver, 'text'))
+      .forEach((call) => calls.push(call))
   }
 
   if (records.coinTypes && records.coinTypes.length > 0) {
-    records.coinTypes.forEach(({ key, value }: RecordItem) => {
-      const data = generateSetAddr(namehash, key, value, resolver!)
-      data && calls.push(data)
-    })
+    records.coinTypes
+      .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+      .forEach((call) => calls.push(call))
   }
 
   return calls

package/src/utils/registerHelpers.ts

@@ -1,17 +1,72 @@
-import { utils } from 'ethers'
-import type { FuseOptions } from '../@types/FuseOptions'
+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 { 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
+  secret: string
+  resolverAddress?: string
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: FuseOptions
+  wrapperExpiry?: BigNumberish
+}
+
+export type RegistrationParams = Omit<
+  BaseRegistrationParams,
+  'resolverAddress'
+> & {
+  name: string
+  resolver: PublicResolver
+}
+
+export type CommitmentParams = Omit<
+  RegistrationParams,
+  'secret' | 'wrapperExpiry'
+> & {
+  secret?: string
+  wrapperExpiry?: BigNumberish
+}
+
+export type RegistrationTuple = [
+  name: string,
+  owner: string,
+  duration: number,
+  secret: string,
+  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,
+]
+
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
-  return '0x' + crypto.getRandomValues(bytes).toString('hex')
+  return `0x${crypto.getRandomValues(bytes).toString('hex')}`
 }
 
-export const makeCommitment = ({
+export const makeCommitmentData = ({
   name,
   owner,
   duration,
@@ -19,69 +74,84 @@ export const makeCommitment = ({
   records,
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
+  wrapperExpiry,
+  secret,
+}: CommitmentParams & {
+  secret: string
+}): CommitmentTuple => {
   const label = 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 commitment = _makeCommitment({
-    labelhash: label,
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: 'ETH', value: owner }] }
+    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+      if (!records.coinTypes) records.coinTypes = []
+      records.coinTypes.push({ key: 'ETH', value: owner })
+    }
+  }
+
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
+
+  return [
+    label,
     owner,
     duration,
-    secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || MAX_INT_64,
+  ]
+}
+
+export const makeRegistrationData = (
+  params: RegistrationParams,
+): RegistrationTuple => {
+  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
+}
+
+export const _makeCommitment = (params: CommitmentTuple) => {
+  return keccak256(
+    defaultAbiCoder.encode(
+      [
+        'bytes32',
+        'address',
+        'uint256',
+        'address',
+        'bytes[]',
+        'bytes32',
+        'bool',
+        'uint32',
+        'uint64',
+      ],
+      params,
+    ),
+  )
+}
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
   })
 
+  const commitment = _makeCommitment(generatedParams)
+
   return {
     secret,
     commitment,
+    wrapperExpiry: generatedParams[8],
   }
 }
-
-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],
-  )
-}

package/src/utils/singleCall.ts

@@ -1,7 +1,7 @@
-import { ethers } from 'ethers'
+import type { Provider } from '@ethersproject/providers'
 
 export default async (
-  provider: ethers.providers.Provider,
+  provider: Provider,
   ensData: any,
   func: {
     raw: (...args: any[]) => Promise<{ to: string; data: string }>
@@ -11,6 +11,6 @@ export default async (
 ) =>
   func
     .raw(ensData, ...data)
-    .then((rawData) => provider.call(rawData))
+    .then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true }))
     .catch(() => null)
     .then((ret) => func.decode(ensData, ret, ...data))

package/src/utils/validation.ts

@@ -1,17 +1,16 @@
-import { isAddress } from 'ethers/lib/utils'
+import { isAddress } from '@ethersproject/address'
 import { isEncodedLabelhash, saveName } from './labels'
 import { normalise } from './normalise'
 
 export const validateName = (name: string) => {
   const nameArray = name.split('.')
-  const hasEmptyLabels = nameArray.some((label) => label.length == 0)
+  const hasEmptyLabels = nameArray.some((label) => label.length === 0)
   if (hasEmptyLabels) throw new Error('Name cannot have empty labels')
   const normalizedArray = nameArray.map((label) => {
     if (label === '[root]') {
       return label
-    } else {
-      return isEncodedLabelhash(label) ? label : normalise(label)
     }
+    return isEncodedLabelhash(label) ? label : normalise(label)
   })
   const normalizedName = normalizedArray.join('.')
   saveName(normalizedName)
@@ -30,7 +29,7 @@ type InputType = {
 
 export const parseInputType = (input: string): InputType => {
   const validTLD = validateTLD(input)
-  let regex = /[^.]+$/
+  const regex = /[^.]+$/
 
   try {
     validateName(input)
@@ -61,13 +60,13 @@ export const parseInputType = (input: string): InputType => {
       type: 'name',
       info: 'unsupported',
     }
-  } else if (isAddress(input)) {
+  }
+  if (isAddress(input)) {
     return {
       type: 'address',
     }
-  } else {
-    return {
-      type: 'label',
-    }
+  }
+  return {
+    type: 'label',
   }
 }

package/src/utils/wrapper.ts

@@ -0,0 +1,36 @@
+import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
+import { toUtf8Bytes } from '@ethersproject/strings/lib/utf8'
+import { ENSArgs } from '../index'
+
+export type Expiry = string | number | Date | BigNumber
+
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)
+
+export const makeExpiry = async (
+  { getExpiry }: ENSArgs<'getExpiry'>,
+  name: string,
+  expiry?: Expiry,
+) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1000)
+    }
+    if (expiry instanceof BigNumber) {
+      return expiry
+    }
+    return BigNumber.from(expiry)
+  }
+  if (name.endsWith('.eth')) {
+    const expResponse = await getExpiry(name)
+    if (!expResponse?.expiry)
+      throw new Error("Couldn't get expiry for name, please provide one.")
+    return BigNumber.from(expResponse.expiry.getTime() / 1000)
+  }
+  return MAX_EXPIRY
+}
+
+export const wrappedLabelLengthCheck = (label: string) => {
+  const bytes = toUtf8Bytes(label)
+  if (bytes.byteLength > 255)
+    throw new Error("Label can't be longer than 255 bytes")
+}

package/src/utils/writeTx.ts

@@ -0,0 +1,16 @@
+import type { PopulatedTransaction } from '@ethersproject/contracts'
+import type { JsonRpcSigner } from '@ethersproject/providers'
+
+type CustomData = Record<string, any>
+
+const withCustomData = <T extends object>(
+  tx: T,
+  customData: CustomData | undefined,
+): (T & { customData: CustomData }) | T =>
+  customData ? { ...tx, customData } : tx
+
+export default (signer: JsonRpcSigner, populate: boolean) =>
+  ({ customData, ...tx }: PopulatedTransaction) =>
+    populate
+      ? withCustomData(tx, customData)
+      : signer.sendTransaction(tx).then((r) => withCustomData(r, customData))

package/dist/cjs/GqlManager.d.ts

@@ -1,6 +0,0 @@
-export default class GqlManager {
-    gql: any;
-    client?: any | null;
-    setUrl: (url: string | null) => Promise<void>;
-    request: (...arg: any[]) => any;
-}

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/index.d.ts

@@ -1,16 +0,0 @@
-import { ethers } from 'ethers';
-import { ContractAddressFetch } from './getContractAddress';
-export default class ContractManager {
-    private provider;
-    private fetchAddress;
-    constructor(provider: ethers.providers.Provider, fetchAddress: ContractAddressFetch);
-    private generateContractGetter;
-    getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
-    getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
-    getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
-    getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
-    getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
-}

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

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

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

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

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

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

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

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

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

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

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

@@ -1,2 +0,0 @@
-export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
-export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver';

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

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

package/dist/cjs/functions/batchWrappers.d.ts

@@ -1,29 +0,0 @@
-import { ethers } from 'ethers';
-import { ENSArgs } from '..';
-export declare const universalWrapper: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, name: string, data: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<{
-        data: any;
-        resolver: any;
-    } | undefined>;
-};
-export declare const resolverMulticallWrapper: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, data: {
-        to: string;
-        data: string;
-    }[]) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<ethers.utils.Result | undefined>;
-};
-export declare const multicallWrapper: {
-    raw: ({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
-};

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

@@ -1,3 +0,0 @@
-import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<import("ethers").ContractTransaction>;

package/dist/cjs/functions/createSubname.d.ts

@@ -1,19 +0,0 @@
-import { ethers } from 'ethers';
-import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-declare type BaseArgs = {
-    name: string;
-    owner: string;
-    resolverAddress?: string;
-    contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
-};
-declare type NameWrapperArgs = {
-    contract: 'nameWrapper';
-    fuses?: FuseOptions;
-} & BaseArgs;
-declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
-export {};

package/dist/cjs/functions/deleteSubname.d.ts

@@ -1,4 +0,0 @@
-import { ENSArgs } from '..';
-export default function ({ contracts, provider, transferSubname, }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>, name: string, contract: 'registry' | 'nameWrapper', options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction>;

package/dist/cjs/functions/getExpiry.d.ts

@@ -1,12 +0,0 @@
-import { ENSArgs } from '..';
-declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
-        to: string;
-        data: string;
-    }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
-        expiry: Date | null;
-        gracePeriod: number;
-    } | undefined>;
-};
-export default _default;