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

package/dist/esm/functions/getHistory.mjs

@@ -7,17 +7,20 @@ import { namehash } from "../utils/normalise.mjs";
 var eventFormat = {
   Domain: {
     NewOwner: (args) => ({ owner: args.owner.id }),
-    NewResolver: (args) => ({ resolver: args.resolver.id.split("-")[0] }),
+    NewResolver: (args) => ({
+      resolver: args.resolver.id.split("-")[0]
+    }),
     Transfer: (args) => ({ owner: args.owner.id }),
     NewTTL: (args) => ({ ttl: args.ttl }),
     WrappedTransfer: (args) => ({ owner: args.owner.id }),
     NameWrapped: (args) => ({
       fuses: args.fuses,
       owner: args.owner.id,
-      expiry: args.expiry
+      expiryDate: args.expiryDate
     }),
     NameUnwrapped: (args) => ({ owner: args.owner.id }),
-    FusesSet: (args) => ({ fuses: args.fuses, expiry: args.expiry })
+    FusesSet: (args) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args) => ({ expiryDate: args.expiryDate })
   },
   Registration: {
     NameRegistered: (args) => ({
@@ -54,9 +57,11 @@ var eventFormat = {
     AbiChanged: (args) => ({ contentType: args.contentType }),
     PubkeyChanged: (args) => ({ x: args.x, y: args.y }),
     TextChanged: (args) => ({ key: args.key, value: args.value }),
-    ContenthashChanged: (args) => ({ hash: decodeContenthash(args.hash) }),
+    ContenthashChanged: (args) => ({
+      hash: decodeContenthash(args.hash)
+    }),
     InterfaceChanged: (args) => ({
-      interfaceId: args.interfaceId,
+      interfaceId: args.interfaceID,
       implementer: args.implementer
     }),
     AuthorisationChanged: (args) => ({
@@ -111,7 +116,7 @@ async function getHistory({ gqlInstance }, name) {
             }
             ...on NameWrapped {
               fuses
-              expiry
+              expiryDate
               owner {
                 id
               }
@@ -123,7 +128,9 @@ async function getHistory({ gqlInstance }, name) {
             }
             ...on FusesSet {
               fuses
-              expiry
+            }
+            ...on ExpiryExtended {
+              expiryDate
             }
           }
           registration {

package/dist/esm/functions/getNames.mjs

@@ -2,12 +2,12 @@
 import { truncateFormat } from "../utils/format.mjs";
 import { decodeFuses } from "../utils/fuses.mjs";
 import { decryptName } from "../utils/labels.mjs";
-var mapDomain = (domain) => {
-  const decrypted = decryptName(domain.name);
+var mapDomain = ({ name, ...domain }) => {
+  const decrypted = name ? decryptName(name) : void 0;
   return {
     ...domain,
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : void 0,
     createdAt: new Date(parseInt(domain.createdAt) * 1e3),
     type: "domain"
   };
@@ -16,8 +16,12 @@ var mapWrappedDomain = (wrappedDomain) => {
   const domain = mapDomain(wrappedDomain.domain);
   if (domain.registration) {
     domain.registration = {
-      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1e3),
-      registrationDate: new Date(domain.registration.registrationDate * 1e3)
+      expiryDate: new Date(
+        parseInt(domain.registration.expiryDate) * 1e3
+      ),
+      registrationDate: new Date(
+        parseInt(domain.registration.registrationDate) * 1e3
+      )
     };
   }
   return {
@@ -209,7 +213,7 @@ var getNames = async ({ gqlInstance }, {
         id: address,
         first: pageSize,
         skip: (page || 0) * pageSize,
-        orderBy,
+        orderBy: orderBy === "labelName" ? "name" : orderBy,
         orderDirection
       };
     }

package/dist/esm/functions/getOwner.mjs

@@ -111,27 +111,39 @@ var decode = async ({
   const registryOwner = decodedData[0][0];
   const nameWrapperOwner = decodedData[1][0];
   let registrarOwner = decodedData[2]?.[0];
+  let baseReturnObject = {};
   if (labels[labels.length - 1] === "eth") {
-    if (!registrarOwner && labels.length === 2) {
-      const graphRegistrantResult = await gqlInstance.client.request(
-        registrantQuery,
-        {
-          namehash: makeNamehash(name)
-        }
-      );
-      registrarOwner = graphRegistrantResult.domain?.registration?.registrant?.id;
+    if (labels.length === 2) {
+      if (!registrarOwner) {
+        const graphRegistrantResult = await gqlInstance.client.request(
+          registrantQuery,
+          {
+            namehash: makeNamehash(name)
+          }
+        );
+        registrarOwner = graphRegistrantResult.domain?.registration?.registrant?.id;
+        baseReturnObject = {
+          expired: true
+        };
+      } else {
+        baseReturnObject = {
+          expired: false
+        };
+      }
     }
-    if (registrarOwner === nameWrapper.address) {
+    if (registrarOwner?.toLowerCase() === nameWrapper.address.toLowerCase()) {
       return {
         owner: nameWrapperOwner,
-        ownershipLevel: "nameWrapper"
+        ownershipLevel: "nameWrapper",
+        ...baseReturnObject
       };
     }
     if (registrarOwner) {
       return {
         registrant: registrarOwner,
         owner: registryOwner,
-        ownershipLevel: "registrar"
+        ownershipLevel: "registrar",
+        ...baseReturnObject
       };
     }
     if (hexStripZeros(registryOwner) !== "0x") {
@@ -139,7 +151,8 @@ var decode = async ({
         return {
           registrant: void 0,
           owner: registryOwner,
-          ownershipLevel: "registrar"
+          ownershipLevel: "registrar",
+          expired: true
         };
       }
       if (registryOwner === nameWrapper.address && nameWrapperOwner && hexStripZeros(nameWrapperOwner) !== "0x") {

package/dist/esm/functions/getSpecificRecord.mjs

@@ -1,6 +1,7 @@
 // src/functions/getSpecificRecord.ts
 import { formatsByCoinType, formatsByName } from "@ensdomains/address-encoder";
-import { hexStripZeros, isBytesLike } from "@ethersproject/bytes";
+import { arrayify, hexStripZeros, isBytesLike } from "@ethersproject/bytes";
+import { toUtf8String } from "@ethersproject/strings";
 import { decodeContenthash } from "../utils/contentHash.mjs";
 import { namehash } from "../utils/normalise.mjs";
 var _getContentHash = {
@@ -166,10 +167,86 @@ var getAddr = {
     return _getAddr.decode({ contracts }, urData.data, _name, coinType);
   }
 };
+var supportedContentTypes = "0xf";
+var _getABI = {
+  raw: async ({ contracts }, name) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    return {
+      to: "0x0000000000000000000000000000000000000000",
+      data: publicResolver.interface.encodeFunctionData("ABI", [
+        namehash(name),
+        supportedContentTypes
+      ])
+    };
+  },
+  decode: async ({ contracts }, data) => {
+    const publicResolver = await contracts?.getPublicResolver();
+    const [bnContentType, encodedABIData] = publicResolver.interface.decodeFunctionResult("ABI", data);
+    if (!bnContentType || !data) {
+      return;
+    }
+    const contentType = bnContentType.toNumber();
+    if (!contentType) {
+      return;
+    }
+    let abiData;
+    let decoded = false;
+    switch (contentType) {
+      case 1:
+        abiData = JSON.parse(toUtf8String(encodedABIData));
+        decoded = true;
+        break;
+      case 2: {
+        const { inflate } = await import("pako/dist/pako_inflate.min.js");
+        abiData = JSON.parse(
+          inflate(arrayify(encodedABIData), { to: "string" })
+        );
+        decoded = true;
+        break;
+      }
+      case 4: {
+        const { decodeFirst } = await import("cbor");
+        abiData = await decodeFirst(arrayify(encodedABIData));
+        decoded = true;
+        break;
+      }
+      case 8:
+        abiData = toUtf8String(encodedABIData);
+        decoded = false;
+        break;
+      default:
+        try {
+          abiData = toUtf8String(encodedABIData);
+        } catch {
+          abiData = encodedABIData;
+        }
+        decoded = false;
+    }
+    return {
+      contentType,
+      decoded,
+      abi: abiData
+    };
+  }
+};
+var getABI = {
+  raw: async ({ contracts, universalWrapper }, name) => {
+    const prData = await _getABI.raw({ contracts }, name);
+    return universalWrapper.raw(name, prData.data);
+  },
+  decode: async ({ contracts, universalWrapper }, data) => {
+    const urData = await universalWrapper.decode(data);
+    if (!urData)
+      return;
+    return _getABI.decode({ contracts }, urData.data);
+  }
+};
 export {
+  _getABI,
   _getAddr,
   _getContentHash,
   _getText,
+  getABI,
   getAddr,
   getContentHash,
   getText

package/dist/esm/functions/getWrapperData.mjs

@@ -12,15 +12,14 @@ var raw = async ({ contracts }, name) => {
 var decode = async ({ contracts }, data) => {
   const nameWrapper = await contracts?.getNameWrapper();
   try {
-    const [owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
+    const [owner, fuses, expiry] = nameWrapper.interface.decodeFunctionResult(
       "getData",
       data
     );
-    const fuses = BigNumber.from(_fuses);
     const fuseObj = decodeFuses(fuses);
-    const expiryDate = new Date(expiry * 1e3);
+    const expiryDate = expiry.gt(0) && expiry.lt(BigNumber.from(2).pow(32)) ? new Date(expiry.mul(1e3).toString()) : void 0;
     return {
-      fuseObj,
+      ...fuseObj,
       expiryDate,
       rawFuses: fuses,
       owner

package/dist/esm/functions/renewNames.mjs

@@ -1,24 +1,17 @@
 // src/functions/renewNames.ts
-import { validateFuses } from "../utils/fuses.mjs";
-import { MAX_INT_64 } from "../utils/registerHelpers.mjs";
-async function renewNameWithData({ contracts }, name, {
-  duration,
-  value,
-  fuses,
-  wrapperExpiry = MAX_INT_64
-}) {
+import { MAX_INT_64 } from "../utils/consts.mjs";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+async function extendWrappedName({ contracts }, name, options) {
+  const expiry = options?.duration || MAX_INT_64;
   const labels = name.split(".");
-  if (labels.length !== 2 || labels[1] !== "eth") {
-    throw new Error("Currently only .eth TLD renewals are supported");
-  }
-  const encodedFuses = fuses ? validateFuses(fuses) : 0;
-  const controller = await contracts.getEthRegistrarController();
-  return controller.populateTransaction.renewWithFuses(
-    labels[0],
-    duration,
-    encodedFuses,
-    wrapperExpiry,
-    { value }
+  const labelHash = labelhash(labels.shift());
+  const parentNode = namehash(labels.join("."));
+  const nameWrapper = await contracts.getNameWrapper();
+  return nameWrapper.populateTransaction.extendExpiry(
+    parentNode,
+    labelHash,
+    expiry
   );
 }
 async function renewNames_default({ contracts }, nameOrNames, { duration, value }) {
@@ -39,5 +32,5 @@ async function renewNames_default({ contracts }, nameOrNames, { duration, value
 }
 export {
   renewNames_default as default,
-  renewNameWithData
+  extendWrappedName
 };

package/dist/esm/functions/setFuses.mjs

@@ -0,0 +1,30 @@
+// src/functions/setFuses.ts
+import { encodeFuses } from "../utils/fuses.mjs";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.mjs";
+async function setChildFuses({ contracts, signer }, name, {
+  fuses,
+  expiry = 0
+}) {
+  const encodedFuses = encodeFuses(fuses);
+  const labels = name.split(".");
+  const labelHash = labelhash(labels.shift());
+  const parentNode = namehash(labels.join("."));
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  return nameWrapper.populateTransaction.setChildFuses(
+    parentNode,
+    labelHash,
+    encodedFuses,
+    expiry
+  );
+}
+async function setFuses_default({ contracts, signer }, name, props) {
+  const encodedFuses = encodeFuses(props, "child");
+  const nameWrapper = (await contracts.getNameWrapper()).connect(signer);
+  const hash = namehash(name);
+  return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
+}
+export {
+  setFuses_default as default,
+  setChildFuses
+};

package/dist/esm/functions/wrapName.mjs

@@ -1,16 +1,16 @@
 // src/functions/wrapName.ts
 import { defaultAbiCoder } from "@ethersproject/abi/lib.esm/abi-coder.js";
 import { keccak256 as solidityKeccak256 } from "@ethersproject/solidity";
-import generateFuseInput from "../utils/generateFuseInput.mjs";
+import { encodeFuses } from "../utils/fuses.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
-import { makeExpiry, wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
-async function wrapETH({ contracts }, labels, wrappedOwner, expiry, decodedFuses, resolverAddress, signer, address) {
+import { wrappedLabelLengthCheck } from "../utils/wrapper.mjs";
+async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
   const nameWrapper = await contracts?.getNameWrapper();
   const baseRegistrar = (await contracts.getBaseRegistrar()).connect(signer);
   const labelhash = solidityKeccak256(["string"], [labels[0]]);
   const data = defaultAbiCoder.encode(
-    ["string", "address", "uint32", "uint64", "address"],
-    [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress]
+    ["string", "address", "uint16", "address"],
+    [labels[0], wrappedOwner, decodedFuses, resolverAddress]
   );
   return baseRegistrar.populateTransaction["safeTransferFrom(address,address,uint256,bytes)"](address, nameWrapper.address, labelhash, data);
 }
@@ -32,11 +32,7 @@ async function wrapOther({ contracts }, name, wrappedOwner, resolverAddress, add
     resolverAddress
   );
 }
-async function wrapName_default({
-  contracts,
-  signer,
-  getExpiry
-}, name, {
+async function wrapName_default({ contracts, signer }, name, {
   wrappedOwner,
   fuseOptions,
   expiry,
@@ -52,31 +48,25 @@ async function wrapName_default({
   if (labels.length === 2 && labels[1] === "eth") {
     switch (typeof fuseOptions) {
       case "object": {
-        decodedFuses = generateFuseInput(fuseOptions);
+        decodedFuses = encodeFuses(fuseOptions);
         break;
       }
       case "number": {
-        decodedFuses = fuseOptions.toString(16);
-        break;
-      }
-      case "string": {
         decodedFuses = fuseOptions;
         break;
       }
       case "undefined": {
-        decodedFuses = "0";
+        decodedFuses = 0;
         break;
       }
       default: {
         throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
       }
     }
-    const expiryToUse = await makeExpiry({ getExpiry }, name, expiry);
     return wrapETH(
       { contracts },
       labels,
       wrappedOwner,
-      expiryToUse,
       decodedFuses,
       resolverAddress,
       signer,

package/dist/esm/generated/factories/ETHRegistrarController__factory.mjs

@@ -109,17 +109,6 @@ var _abi = [
     name: "ResolverRequiredWhenDataSupplied",
     type: "error"
   },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "node",
-        type: "bytes32"
-      }
-    ],
-    name: "Unauthorised",
-    type: "error"
-  },
   {
     inputs: [
       {
@@ -326,14 +315,9 @@ var _abi = [
         type: "bool"
       },
       {
-        internalType: "uint32",
-        name: "fuses",
-        type: "uint32"
-      },
-      {
-        internalType: "uint64",
-        name: "wrapperExpiry",
-        type: "uint64"
+        internalType: "uint16",
+        name: "ownerControlledFuses",
+        type: "uint16"
       }
     ],
     name: "makeCommitment",
@@ -473,14 +457,9 @@ var _abi = [
         type: "bool"
       },
       {
-        internalType: "uint32",
-        name: "fuses",
-        type: "uint32"
-      },
-      {
-        internalType: "uint64",
-        name: "wrapperExpiry",
-        type: "uint64"
+        internalType: "uint16",
+        name: "ownerControlledFuses",
+        type: "uint16"
       }
     ],
     name: "register",
@@ -506,34 +485,6 @@ var _abi = [
     stateMutability: "payable",
     type: "function"
   },
-  {
-    inputs: [
-      {
-        internalType: "string",
-        name: "name",
-        type: "string"
-      },
-      {
-        internalType: "uint256",
-        name: "duration",
-        type: "uint256"
-      },
-      {
-        internalType: "uint32",
-        name: "fuses",
-        type: "uint32"
-      },
-      {
-        internalType: "uint64",
-        name: "wrapperExpiry",
-        type: "uint64"
-      }
-    ],
-    name: "renewWithFuses",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
   {
     inputs: [],
     name: "renounceOwnership",