@ensdomains/ensjs 3.0.0-alpha.16 → 3.0.0-alpha.19

package/dist/esm/utils/recordHelpers.mjs

@@ -0,0 +1,70 @@
+// src/utils/recordHelpers.ts
+import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
+import { encodeContenthash } from "./contentHash.mjs";
+var generateSetAddr = (namehash, coinType, address, resolver) => {
+  let coinTypeInstance;
+  if (!Number.isNaN(parseInt(coinType))) {
+    coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+  } else {
+    coinTypeInstance = formatsByName[coinType.toUpperCase()];
+  }
+  const inputCoinType = coinTypeInstance.coinType;
+  const encodedAddress = coinTypeInstance.decoder(address);
+  return resolver?.interface.encodeFunctionData(
+    "setAddr(bytes32,uint256,bytes)",
+    [namehash, inputCoinType, encodedAddress]
+  );
+};
+function generateSingleRecordCall(namehash, resolver, type) {
+  if (type === "contentHash") {
+    return (_r) => {
+      const record = _r;
+      let _contentHash = "";
+      if (record !== _contentHash) {
+        const encoded = encodeContenthash(record);
+        if (encoded.error)
+          throw new Error(encoded.error);
+        _contentHash = encoded.encoded;
+      }
+      return resolver.interface.encodeFunctionData("setContenthash", [
+        namehash,
+        _contentHash
+      ]);
+    };
+  }
+  return (_r) => {
+    const record = _r;
+    if (type === "text") {
+      return resolver.interface.encodeFunctionData("setText", [
+        namehash,
+        record.key,
+        record.value
+      ]);
+    }
+    return generateSetAddr(namehash, record.key, record.value, resolver);
+  };
+}
+var generateRecordCallArray = (namehash, records, resolver) => {
+  const calls = [];
+  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.map(generateSingleRecordCall(namehash, resolver, "text")).forEach((call) => calls.push(call));
+  }
+  if (records.coinTypes && records.coinTypes.length > 0) {
+    records.coinTypes.map(generateSingleRecordCall(namehash, resolver, "addr")).forEach((call) => calls.push(call));
+  }
+  return calls;
+};
+export {
+  generateRecordCallArray,
+  generateSetAddr,
+  generateSingleRecordCall
+};

package/dist/esm/utils/registerHelpers.mjs

@@ -0,0 +1,95 @@
+// src/utils/registerHelpers.ts
+import { utils } from "ethers";
+import generateFuseInput from "./generateFuseInput.mjs";
+import { labelhash } from "./labels.mjs";
+import { namehash } from "./normalise.mjs";
+import { generateRecordCallArray } from "./recordHelpers.mjs";
+var randomSecret = () => {
+  const bytes = Buffer.allocUnsafe(32);
+  return `0x${crypto.getRandomValues(bytes).toString("hex")}`;
+};
+var makeCommitmentData = ({
+  name,
+  owner,
+  duration,
+  resolver,
+  records,
+  reverseRecord,
+  fuses,
+  wrapperExpiry,
+  secret
+}) => {
+  const label = labelhash(name.split(".")[0]);
+  const hash = namehash(name);
+  const resolverAddress = resolver.address;
+  const fuseData = fuses ? generateFuseInput(fuses) : "0";
+  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,
+    resolverAddress,
+    data,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || Math.floor(Date.now() / 1e3) + duration
+  ];
+};
+var makeRegistrationData = (params) => {
+  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;
+};
+var _makeCommitment = (params) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        "bytes32",
+        "address",
+        "uint256",
+        "address",
+        "bytes[]",
+        "bytes32",
+        "bool",
+        "uint32",
+        "uint64"
+      ],
+      params
+    )
+  );
+};
+var makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret
+  });
+  const commitment = _makeCommitment(generatedParams);
+  return {
+    secret,
+    commitment,
+    wrapperExpiry: generatedParams[8]
+  };
+};
+export {
+  _makeCommitment,
+  makeCommitment,
+  makeCommitmentData,
+  makeRegistrationData,
+  randomSecret
+};

package/dist/esm/utils/singleCall.mjs

@@ -0,0 +1,5 @@
+// src/utils/singleCall.ts
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call(rawData)).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));
+export {
+  singleCall_default as default
+};

package/dist/esm/utils/validation.mjs

@@ -0,0 +1,67 @@
+// src/utils/validation.ts
+import { isAddress } from "ethers/lib/utils.js";
+import { isEncodedLabelhash, saveName } from "./labels.mjs";
+import { normalise } from "./normalise.mjs";
+var validateName = (name) => {
+  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) => {
+    if (label === "[root]") {
+      return label;
+    }
+    return isEncodedLabelhash(label) ? label : normalise(label);
+  });
+  const normalizedName = normalizedArray.join(".");
+  saveName(normalizedName);
+  return normalizedName;
+};
+var validateTLD = (name) => {
+  const labels = name.split(".");
+  return validateName(labels[labels.length - 1]);
+};
+var parseInputType = (input) => {
+  const validTLD = validateTLD(input);
+  const regex = /[^.]+$/;
+  try {
+    validateName(input);
+  } catch (e) {
+    return {
+      type: "unknown"
+    };
+  }
+  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) {
+        return {
+          type: "name",
+          info: "short"
+        };
+      }
+      return {
+        type: "name",
+        info: "supported"
+      };
+    }
+    return {
+      type: "name",
+      info: "unsupported"
+    };
+  }
+  if (isAddress(input)) {
+    return {
+      type: "address"
+    };
+  }
+  return {
+    type: "label"
+  };
+};
+export {
+  parseInputType,
+  validateName,
+  validateTLD
+};

package/dist/esm/utils/wrapperExpiry.mjs

@@ -0,0 +1,25 @@
+// src/utils/wrapperExpiry.ts
+import { BigNumber } from "ethers";
+var MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+var makeExpiry = async ({ getExpiry }, name, expiry) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1e3);
+    }
+    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() / 1e3);
+  }
+  return MAX_EXPIRY;
+};
+export {
+  MAX_EXPIRY,
+  makeExpiry
+};

package/dist/esm/utils/writeTx.mjs

@@ -0,0 +1,6 @@
+// src/utils/writeTx.ts
+var withCustomData = (tx, customData) => customData ? { ...tx, customData } : tx;
+var writeTx_default = (signer, populate) => ({ customData, ...tx }) => populate ? withCustomData(tx, customData) : signer.sendTransaction(tx).then((r) => withCustomData(r, customData));
+export {
+  writeTx_default as default
+};

package/dist/{esm → types}/contracts/baseRegistrar.d.ts

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

package/dist/{esm → types}/contracts/ethRegistrarController.d.ts

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

package/dist/{cjs → types}/contracts/index.d.ts

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

package/dist/{cjs → types}/contracts/multicall.d.ts

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

package/dist/{esm → types}/contracts/nameWrapper.d.ts

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

package/dist/{cjs → types}/contracts/publicResolver.d.ts

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

package/dist/{cjs → types}/contracts/registry.d.ts

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

package/dist/{cjs → types}/contracts/reverseRegistrar.d.ts

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

package/dist/{cjs → types}/contracts/universalResolver.d.ts

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

package/dist/{cjs → types}/functions/batchWrappers.d.ts

@@ -21,9 +21,9 @@ export declare const resolverMulticallWrapper: {
     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<{
+    raw({ contracts }: ENSArgs<'contracts'>, transactions: ethers.providers.TransactionRequest[], requireSuccess?: boolean): Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts }: ENSArgs<'contracts'>, data: string) => Promise<any>;
+    decode({ contracts }: ENSArgs<'contracts'>, data: string): Promise<any>;
 };

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

@@ -0,0 +1,13 @@
+import { ENSArgs } from '..';
+import { NamedFusesToBurn, UnnamedFuseValues } from '../utils/fuses';
+export declare type FusePropsNamedArray = {
+    namedFusesToBurn: NamedFusesToBurn;
+};
+export declare type FusePropsUnnamedArray = {
+    unnamedFusesToBurn: UnnamedFuseValues[];
+};
+export declare type FusePropsNumber = {
+    fuseNumberToBurn: number;
+};
+export declare type FuseProps = (Partial<FusePropsNamedArray> & FusePropsUnnamedArray) | (FusePropsNamedArray & Partial<FusePropsUnnamedArray>) | FusePropsNumber;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, props: FuseProps): Promise<import("ethers").PopulatedTransaction>;

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

@@ -0,0 +1,28 @@
+import { ENSArgs } from '..';
+declare type DomainEvent = 'NewOwner' | 'NewResolver' | 'Transfer' | 'NewTTL';
+declare type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred';
+declare type ResolverEvent = 'AddrChanged' | 'MulticoinAddrChanged' | 'NameChanged' | 'AbiChanged' | 'PubkeyChanged' | 'TextChanged' | 'ContenthashChanged' | 'InterfaceChanged' | 'AuthorisationChanged';
+export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name: string): Promise<{
+    domain: {
+        type: DomainEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    registration: {
+        type: RegistrationEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+    resolver: {
+        type: ResolverEvent;
+        blockNumber: number;
+        transactionHash: string;
+        id: string;
+        data: object;
+    }[];
+} | undefined>;
+export {};

package/dist/{esm → types}/functions/setRecord.d.ts

@@ -1,5 +1,5 @@
 import { ENSArgs } from '..';
-import { RecordInput, RecordTypes } from '../utils/recordHelpers';
+import { RecordInput } from '../utils/recordHelpers';
 declare type BaseInput = {
     resolverAddress?: string;
 };
@@ -11,7 +11,7 @@ declare type AddrOrTextInput = {
     record: RecordInput<'addr' | 'text'>;
     type: 'addr' | 'text';
 };
-export default function <T extends RecordTypes>({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
+export default function ({ contracts, provider, getResolver, signer, }: ENSArgs<'contracts' | 'provider' | 'getResolver' | 'signer'>, name: string, { record, type, resolverAddress, }: BaseInput & (ContentHashInput | AddrOrTextInput)): Promise<{
     to: string;
     data: string;
 }>;