@ensdomains/ensjs 3.0.0-alpha.26 → 3.0.0-alpha.28

package/dist/cjs/generated/factories/UniversalResolver__factory.js

@@ -29,6 +29,11 @@ const _abi = [
         internalType: "address",
         name: "_registry",
         type: "address"
+      },
+      {
+        internalType: "string[]",
+        name: "_urls",
+        type: "string[]"
       }
     ],
     stateMutability: "nonpayable",
@@ -65,6 +70,69 @@ const _abi = [
     name: "OffchainLookup",
     type: "error"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      },
+      {
+        internalType: "bytes4",
+        name: "callbackFunction",
+        type: "bytes4"
+      },
+      {
+        internalType: "bytes",
+        name: "metaData",
+        type: "bytes"
+      }
+    ],
+    name: "_resolveSingle",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "batchGatewayURLs",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -102,6 +170,103 @@ const _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "data",
+        type: "bytes[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "name",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes[]",
+        name: "data",
+        type: "bytes[]"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "resolve",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -145,11 +310,84 @@ const _abi = [
       }
     ],
     name: "resolveCallback",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "response",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "extraData",
+        type: "bytes"
+      }
+    ],
+    name: "resolveSingleCallback",
     outputs: [
       {
         internalType: "bytes",
         name: "",
         type: "bytes"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "reverseName",
+        type: "bytes"
+      },
+      {
+        internalType: "string[]",
+        name: "gateways",
+        type: "string[]"
+      }
+    ],
+    name: "reverse",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
       }
     ],
     stateMutability: "view",
@@ -189,6 +427,45 @@ const _abi = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "response",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "extraData",
+        type: "bytes"
+      }
+    ],
+    name: "reverseCallback",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {

package/dist/cjs/utils/ccip.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ccip_exports = {};
+__export(ccip_exports, {
+  default: () => ccip_default
+});
+module.exports = __toCommonJS(ccip_exports);
+var import_ethers = require("ethers");
+var import_utils = require("ethers/lib/utils");
+function bytesPad(value) {
+  if (value.length % 32 === 0) {
+    return value;
+  }
+  const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
+  result.set(value);
+  return result;
+}
+function numPad(value) {
+  const result = (0, import_utils.arrayify)(value);
+  if (result.length > 32) {
+    throw new Error("internal; should not happen");
+  }
+  const padded = new Uint8Array(32);
+  padded.set(result, 32 - result.length);
+  return padded;
+}
+function encodeBytes(datas) {
+  const result = [];
+  let byteCount = 0;
+  for (let i = 0; i < datas.length; i += 1) {
+    result.push(new Uint8Array(0));
+    byteCount += 32;
+  }
+  for (let i = 0; i < datas.length; i += 1) {
+    const data = (0, import_utils.arrayify)(datas[i]);
+    result[i] = numPad(byteCount);
+    result.push(numPad(data.length));
+    result.push(bytesPad(data));
+    byteCount += 32 + Math.ceil(data.length / 32) * 32;
+  }
+  return (0, import_utils.hexConcat)(result);
+}
+function _parseBytes(result, start) {
+  if (result === "0x") {
+    return null;
+  }
+  const offset = import_ethers.BigNumber.from(
+    (0, import_utils.hexDataSlice)(result, start, start + 32)
+  ).toNumber();
+  const length = import_ethers.BigNumber.from(
+    (0, import_utils.hexDataSlice)(result, offset, offset + 32)
+  ).toNumber();
+  return (0, import_utils.hexDataSlice)(result, offset + 32, offset + 32 + length);
+}
+function _parseString(result, start) {
+  try {
+    const bytes = _parseBytes(result, start);
+    if (bytes == null)
+      return null;
+    return (0, import_utils.toUtf8String)(bytes);
+  } catch (error) {
+  }
+  return null;
+}
+const ccipLookup = async (provider, transaction, result) => {
+  const txSender = transaction.to;
+  try {
+    const data = (0, import_utils.hexDataSlice)(result, 4);
+    const sender = (0, import_utils.hexDataSlice)(data, 0, 32);
+    if (!import_ethers.BigNumber.from(sender).eq(txSender)) {
+      throw new Error("CCIP Read sender did not match");
+    }
+    const urls = [];
+    const urlsOffset = import_ethers.BigNumber.from((0, import_utils.hexDataSlice)(data, 32, 64)).toNumber();
+    const urlsLength = import_ethers.BigNumber.from(
+      (0, import_utils.hexDataSlice)(data, urlsOffset, urlsOffset + 32)
+    ).toNumber();
+    const urlsData = (0, import_utils.hexDataSlice)(data, urlsOffset + 32);
+    for (let u = 0; u < urlsLength; u += 1) {
+      const url = _parseString(urlsData, u * 32);
+      if (url == null) {
+        throw new Error("CCIP Read contained corrupt URL string");
+      }
+      urls.push(url);
+    }
+    const calldata = _parseBytes(data, 64);
+    if (!import_ethers.BigNumber.from((0, import_utils.hexDataSlice)(data, 100, 128)).isZero()) {
+      throw new Error("CCIP Read callback selected included junk");
+    }
+    const callbackSelector = (0, import_utils.hexDataSlice)(data, 96, 100);
+    const extraData = _parseBytes(data, 128);
+    const ccipResult = await provider.ccipReadFetch(
+      transaction,
+      calldata,
+      urls
+    );
+    if (ccipResult == null) {
+      throw new Error("CCIP Read disabled or provided no URLs");
+    }
+    const tx = {
+      to: sender,
+      data: (0, import_utils.hexConcat)([
+        callbackSelector,
+        encodeBytes([ccipResult, extraData])
+      ])
+    };
+    return await provider._call(tx, "latest", 1);
+  } catch (error) {
+    console.error(error);
+  }
+};
+var ccip_default = ccipLookup;

package/dist/cjs/utils/fuses.js

@@ -18,12 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var fuses_exports = {};
 __export(fuses_exports, {
+  decodeFuses: () => decodeFuses,
   default: () => fuses_default,
   fuseEnum: () => fuseEnum,
   unnamedFuses: () => unnamedFuses,
   validateFuses: () => validateFuses
 });
 module.exports = __toCommonJS(fuses_exports);
+var import_ethers = require("ethers");
 const CANNOT_UNWRAP = 1;
 const CANNOT_BURN_FUSES = 2;
 const CANNOT_TRANSFER = 4;
@@ -114,4 +116,19 @@ const validateFuses = (fuses) => {
   }
   return encodedFuses;
 };
+const decodeFuses = (fuses) => {
+  const bnFuses = import_ethers.BigNumber.from(fuses);
+  const fuseObj = Object.fromEntries(
+    Object.keys(fuseEnum).map((fuse) => [
+      fuse,
+      bnFuses.and(fuseEnum[fuse]).gt(0)
+    ])
+  );
+  if (bnFuses.eq(0)) {
+    fuseObj.CAN_DO_EVERYTHING = true;
+  } else {
+    fuseObj.CAN_DO_EVERYTHING = false;
+  }
+  return fuseObj;
+};
 var fuses_default = fullFuseEnum;

package/dist/cjs/utils/singleCall.js

@@ -21,4 +21,4 @@ __export(singleCall_exports, {
   default: () => singleCall_default
 });
 module.exports = __toCommonJS(singleCall_exports);
-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));
+var singleCall_default = async (provider, ensData, func, ...data) => func.raw(ensData, ...data).then((rawData) => provider.call({ ...rawData, ccipReadEnabled: true })).catch(() => null).then((ret) => func.decode(ensData, ret, ...data));

package/dist/esm/contracts/getContractAddress.mjs

@@ -44,7 +44,7 @@ var addresses = {
     "1": "0x580AF46E06DaaD47eb5940526FD64d95b815Cb70",
     "3": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
     "4": "0x74e20bd2a1fe0cdbe45b9a1d89cb7e0a45b36376",
-    "5": "0x9380F1974D2B7064eA0c0EC251968D8c69f0Ae31"
+    "5": "0x687c30Cc44bFA39A1449e86E172BF002E7b3f0b0"
   },
   BulkRenewal: {
     "1": "0xfF252725f6122A92551A5FA9a6b6bf10eb0Be035",

package/dist/esm/functions/batchWrappers.mjs

@@ -1,20 +1,21 @@
 // src/functions/batchWrappers.ts
+import ccipLookup from "../utils/ccip.mjs";
 import { hexEncodeName } from "../utils/hexEncodedName.mjs";
 var universalWrapper = {
   raw: async ({ contracts }, name, data) => {
     const universalResolver = await contracts?.getUniversalResolver();
     return {
       to: universalResolver.address,
-      data: universalResolver.interface.encodeFunctionData("resolve", [
-        hexEncodeName(name),
-        data
-      ])
+      data: universalResolver.interface.encodeFunctionData(
+        "resolve(bytes,bytes)",
+        [hexEncodeName(name), data]
+      )
     };
   },
   decode: async ({ contracts }, data) => {
     const universalResolver = await contracts?.getUniversalResolver();
     const response = universalResolver.interface.decodeFunctionResult(
-      "resolve",
+      "resolve(bytes,bytes)",
       data
     );
     if (!response || !response[0]) {
@@ -60,7 +61,7 @@ var multicallWrapper = {
       ])
     };
   },
-  async decode({ contracts }, data) {
+  async decode({ contracts, provider }, data, transactions) {
     if (!data)
       return;
     const multicall = await contracts?.getMulticall();
@@ -69,9 +70,35 @@ var multicallWrapper = {
         "tryAggregate",
         data
       );
-      return result;
+      const ccipChecked = await Promise.all(
+        result.map(
+          async ([success, returnData], i) => {
+            let newArr = [success, returnData];
+            if (!success && returnData.startsWith("0x556f1830")) {
+              try {
+                const newData = await ccipLookup(
+                  provider,
+                  transactions[i],
+                  returnData
+                );
+                if (newData) {
+                  newArr = [true, newData];
+                }
+              } catch {
+              }
+            }
+            return {
+              ...newArr,
+              success: newArr[0],
+              returnData: newArr[1]
+            };
+          }
+        )
+      );
+      return ccipChecked;
     } catch (e) {
-      return e;
+      console.error(e);
+      return;
     }
   }
 };

package/dist/esm/functions/getName.mjs

@@ -5,7 +5,7 @@ var raw = async ({ contracts }, address) => {
   const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
   return {
     to: universalResolver.address,
-    data: universalResolver.interface.encodeFunctionData("reverse", [
+    data: universalResolver.interface.encodeFunctionData("reverse(bytes)", [
       hexEncodeName(reverseNode)
     ])
   };
@@ -16,7 +16,7 @@ var decode = async ({ contracts }, data, address) => {
   const universalResolver = await contracts?.getUniversalResolver();
   try {
     const result = universalResolver.interface.decodeFunctionResult(
-      "reverse",
+      "reverse(bytes)",
       data
     );
     return {

package/dist/esm/functions/getNames.mjs

@@ -1,5 +1,6 @@
 // src/functions/getNames.ts
 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);
@@ -11,6 +12,15 @@ var mapDomain = (domain) => {
     type: "domain"
   };
 };
+var mapWrappedDomain = (wrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain);
+  return {
+    expiryDate: new Date(parseInt(wrappedDomain.expiryDate) * 1e3),
+    fuses: decodeFuses(wrappedDomain.fuses),
+    ...domain,
+    type: "wrappedDomain"
+  };
+};
 var mapRegistration = (registration) => {
   const decrypted = decryptName(registration.domain.name);
   return {
@@ -65,6 +75,17 @@ var getNames = async ({ gqlInstance }, {
             ${domainQueryData}
             createdAt
           }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
         }
       }
     `;
@@ -123,6 +144,69 @@ var getNames = async ({ gqlInstance }, {
         orderDirection
       };
     }
+  } else if (type === "wrappedOwner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $first: Int
+        $skip: Int
+        $orderBy: WrappedDomain_orderBy
+        $orderDirection: OrderDirection
+      ) {
+        account(id: $id) {
+          wrappedDomains(
+            first: $first
+            skip: $skip
+            orderBy: $orderBy
+            orderDirection: $orderDirection
+          ) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      }
+    `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
+    }
   } else if (typeof page !== "number") {
     finalQuery = gqlInstance.gql`
         query getNames(
@@ -192,7 +276,8 @@ var getNames = async ({ gqlInstance }, {
   if (type === "all") {
     return [
       ...account.domains.map(mapDomain),
-      ...account.registrations.map(mapRegistration)
+      ...account.registrations.map(mapRegistration),
+      ...account.wrappedDomains.map(mapWrappedDomain)
     ].sort((a, b) => {
       if (orderDirection === "desc") {
         if (orderBy === "labelName") {
@@ -209,6 +294,9 @@ var getNames = async ({ gqlInstance }, {
   if (type === "owner") {
     return account.domains.map(mapDomain);
   }
+  if (type === "wrappedOwner") {
+    return account.wrappedDomains.map(mapWrappedDomain);
+  }
   return account.registrations.map(mapRegistration);
 };
 var getNames_default = getNames;