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

package/dist/esm/functions/getHistory.mjs

@@ -0,0 +1,196 @@
+// src/functions/getHistory.ts
+import { formatsByCoinType } from "@ensdomains/address-encoder";
+import { ethers } from "ethers";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+var eventFormat = {
+  Domain: {
+    NewOwner: (args) => ({ owner: args.owner.id }),
+    NewResolver: (args) => ({ resolver: args.resolver.id.split("-")[0] }),
+    Transfer: (args) => ({ owner: args.owner.id }),
+    NewTTL: (args) => ({ ttl: args.ttl })
+  },
+  Registration: {
+    NameRegistered: (args) => ({
+      registrant: args.registrant.id,
+      expiryDate: args.expiryDate
+    }),
+    NameRenewed: (args) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args) => ({ owner: args.newOwner.id })
+  },
+  Resolver: {
+    AddrChanged: (args) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (args) => {
+      const format = formatsByCoinType[parseInt(args.coinType)];
+      if (!format) {
+        return {
+          coinType: args.coinType,
+          rawAddr: args.multiaddr
+        };
+      }
+      if (ethers.utils.hexStripZeros(args.multiaddr) === "0x") {
+        return {
+          coinType: args.coinType,
+          coinName: format.name,
+          rawAddr: "0x"
+        };
+      }
+      return {
+        coinType: args.coinType,
+        coinName: format.name,
+        addr: format.encoder(Buffer.from(args.multiaddr.slice(2), "hex"))
+      };
+    },
+    NameChanged: (args) => ({ name: args.name }),
+    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) }),
+    InterfaceChanged: (args) => ({
+      interfaceId: args.interfaceId,
+      implementer: args.implementer
+    }),
+    AuthorisationChanged: (args) => ({
+      owner: args.owner,
+      target: args.target,
+      isAuthorized: args.isAuthorized
+    })
+  }
+};
+var mapEvents = (eventArray, type) => eventArray.map(
+  (event) => ({
+    type: event.__typename,
+    blockNumber: event.blockNumber,
+    transactionHash: event.transactionID,
+    id: event.id,
+    data: eventFormat[type][event.__typename](event)
+  })
+);
+async function getHistory({ gqlInstance }, name) {
+  const { client } = gqlInstance;
+  const query = gqlInstance.gql`
+      query getHistory($name: String!, $label: String!) {
+        domains(where: { name: $name }) {
+          events {
+            id
+            blockNumber
+            transactionID
+            __typename
+            ...on Transfer {
+              owner {
+                id
+              }
+            }
+            ...on NewOwner {
+              owner {
+                id
+              }
+            }
+            ...on NewResolver {
+              resolver {
+                id
+              }
+            }
+            ...on NewTTL {
+              ttl
+            }
+          }
+          owner {
+            registrations (where: { labelName: $label }) {
+              events {
+                id
+                blockNumber
+                transactionID
+                __typename
+                ...on NameRegistered {
+                  registrant {
+                    id
+                  }
+                  expiryDate
+                }
+                ...on NameRenewed {
+                  expiryDate
+                }
+                ...on NameTransferred {
+                  newOwner {
+                    id
+                  }
+                }
+              }
+            }
+          }
+          resolver {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on AddrChanged {
+                addr {
+                  id
+                }
+              }
+              ...on MulticoinAddrChanged {
+                coinType
+                multiaddr: addr
+              }
+              ...on NameChanged {
+                name
+              }
+              ...on AbiChanged {
+                contentType
+              }
+              ...on PubkeyChanged {
+                x
+                y
+              }
+              ...on TextChanged {
+                key
+                value
+              }
+              ...on ContenthashChanged {
+                hash
+              }
+              ...on InterfaceChanged {
+                interfaceID
+                implementer
+              }
+              ...on AuthorisationChanged {
+                owner
+                target
+                isAuthorized
+              }
+            }
+          }
+        }
+      }
+      `;
+  const label = name.split(".")[0];
+  const { domains } = await client.request(query, { name, label });
+  if (!domains || domains.length === 0)
+    return;
+  const [
+    {
+      events: domainEvents,
+      owner: {
+        registrations: [{ events: registrationEvents }]
+      },
+      resolver: { events: resolverEvents }
+    }
+  ] = domains;
+  const domainHistory = mapEvents(domainEvents, "Domain");
+  const registrationHistory = mapEvents(registrationEvents, "Registration");
+  const resolverHistory = mapEvents(
+    resolverEvents.filter(
+      (event) => !event.coinType || event.coinType !== "60"
+    ),
+    "Resolver"
+  );
+  return {
+    domain: domainHistory,
+    registration: registrationHistory,
+    resolver: resolverHistory
+  };
+}
+export {
+  getHistory
+};

package/dist/esm/functions/getName.mjs

@@ -0,0 +1,38 @@
+// src/functions/getName.ts
+import { hexEncodeName } from "../utils/hexEncodedName.mjs";
+var raw = async ({ contracts }, address) => {
+  const universalResolver = await contracts?.getUniversalResolver();
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("reverse", [
+      hexEncodeName(reverseNode)
+    ])
+  };
+};
+var decode = async ({ contracts }, data, address) => {
+  if (data === null)
+    return;
+  const universalResolver = await contracts?.getUniversalResolver();
+  try {
+    const result = universalResolver.interface.decodeFunctionResult(
+      "reverse",
+      data
+    );
+    return {
+      name: result["0"],
+      match: result["1"].toLowerCase() === address.toLowerCase(),
+      reverseResolverAddress: result["2"],
+      resolverAddress: result["3"]
+    };
+  } catch {
+    return { name: void 0 };
+  }
+};
+var getName_default = {
+  raw,
+  decode
+};
+export {
+  getName_default as default
+};

package/dist/esm/functions/getNames.mjs

@@ -0,0 +1,217 @@
+// src/functions/getNames.ts
+import { truncateFormat } from "../utils/format.mjs";
+import { decryptName } from "../utils/labels.mjs";
+var mapDomain = (domain) => {
+  const decrypted = decryptName(domain.name);
+  return {
+    ...domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    createdAt: new Date(parseInt(domain.createdAt) * 1e3),
+    type: "domain"
+  };
+};
+var mapRegistration = (registration) => {
+  const decrypted = decryptName(registration.domain.name);
+  return {
+    expiryDate: new Date(parseInt(registration.expiryDate) * 1e3),
+    registrationDate: new Date(parseInt(registration.registrationDate) * 1e3),
+    ...registration.domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    type: "registration"
+  };
+};
+var getNames = async ({ gqlInstance }, {
+  address: _address,
+  type,
+  page,
+  pageSize = 10,
+  orderDirection,
+  orderBy
+}) => {
+  const address = _address.toLowerCase();
+  const client = gqlInstance.client;
+  const domainQueryData = `
+    id
+    labelName
+    labelhash
+    name
+    isMigrated
+    parent {
+        name
+    }
+  `;
+  let queryVars = {};
+  let finalQuery = "";
+  if (type === "all") {
+    finalQuery = gqlInstance.gql`
+      query getNames(
+        $id: ID!
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          registrations(
+            first: 1000
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            registrationDate
+            expiryDate
+            domain {
+              ${domainQueryData}
+            }
+          }
+          domains(first: 1000) {
+            ${domainQueryData}
+            createdAt
+          }
+        }
+      }
+    `;
+    queryVars = {
+      id: address,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  } else if (type === "owner") {
+    if (typeof page !== "number") {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID! 
+          $orderBy: Domain_orderBy 
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(orderBy: $orderBy, orderDirection: $orderDirection) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `;
+      queryVars = {
+        id: address,
+        orderBy,
+        orderDirection
+      };
+    } else {
+      finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Domain_orderBy
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+            ) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `;
+      queryVars = {
+        id: address,
+        first: pageSize,
+        skip: (page || 0) * pageSize,
+        orderBy,
+        orderDirection
+      };
+    }
+  } else if (typeof page !== "number") {
+    finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+    queryVars = {
+      id: address,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  } else {
+    finalQuery = gqlInstance.gql`
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+    queryVars = {
+      id: address,
+      first: pageSize,
+      skip: (page || 0) * pageSize,
+      orderBy,
+      orderDirection,
+      expiryDate: Math.floor(Date.now() / 1e3) - 90 * 24 * 60 * 60
+    };
+  }
+  const { account } = await client.request(finalQuery, queryVars);
+  if (type === "all") {
+    return [
+      ...account.domains.map(mapDomain),
+      ...account.registrations.map(mapRegistration)
+    ].sort((a, b) => {
+      if (orderDirection === "desc") {
+        if (orderBy === "labelName") {
+          return b.name.localeCompare(a.name);
+        }
+        return b.createdAt.getTime() - a.createdAt.getTime();
+      }
+      if (orderBy === "labelName") {
+        return a.name.localeCompare(b.name);
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+  }
+  if (type === "owner") {
+    return account.domains.map(mapDomain);
+  }
+  return account.registrations.map(mapRegistration);
+};
+var getNames_default = getNames;
+export {
+  getNames_default as default
+};

package/dist/esm/functions/getOwner.mjs

@@ -0,0 +1,143 @@
+// src/functions/getOwner.ts
+import { ethers } from "ethers";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash as makeNamehash } from "../utils/normalise.mjs";
+var singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
+  switch (contract) {
+    case "nameWrapper": {
+      const nameWrapper = await contracts?.getNameWrapper();
+      return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData("ownerOf", [namehash])
+      };
+    }
+    case "registry": {
+      const registry = await contracts?.getRegistry();
+      return {
+        to: registry.address,
+        data: registry.interface.encodeFunctionData("owner", [namehash])
+      };
+    }
+    case "registrar": {
+      const registrar = await contracts?.getBaseRegistrar();
+      return {
+        to: registrar.address,
+        data: registrar.interface.encodeFunctionData("ownerOf", [
+          labelhash(labels[0])
+        ])
+      };
+    }
+  }
+};
+var raw = async ({ contracts, multicallWrapper }, name, contract) => {
+  const namehash = makeNamehash(name);
+  const labels = name.split(".");
+  if (contract || labels.length === 1) {
+    return singleContractOwnerRaw(
+      { contracts },
+      contract || "registry",
+      namehash,
+      labels
+    );
+  }
+  const registryData = await singleContractOwnerRaw(
+    { contracts },
+    "registry",
+    namehash,
+    labels
+  );
+  const nameWrapperData = await singleContractOwnerRaw(
+    { contracts },
+    "nameWrapper",
+    namehash,
+    labels
+  );
+  const registrarData = await singleContractOwnerRaw(
+    { contracts },
+    "registrar",
+    namehash,
+    labels
+  );
+  const data = [registryData, nameWrapperData];
+  if (labels.length === 2 && labels[1] === "eth") {
+    data.push(registrarData);
+  }
+  return multicallWrapper.raw(data);
+};
+var singleContractOwnerDecode = (data) => ethers.utils.defaultAbiCoder.decode(["address"], data)[0];
+var decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
+  if (data === null)
+    return;
+  const labels = name.split(".");
+  if (contract || labels.length === 1) {
+    const singleOwner = singleContractOwnerDecode(data);
+    const obj = {
+      ownershipLevel: contract || "registry"
+    };
+    if (contract === "registrar") {
+      return {
+        ...obj,
+        registrant: singleOwner
+      };
+    }
+    return {
+      ...obj,
+      owner: singleOwner
+    };
+  }
+  const result = await multicallWrapper.decode(data);
+  if (result === null)
+    return;
+  const nameWrapper = await contracts?.getNameWrapper();
+  const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map(
+    (ret) => ret && ret !== "0x" && ethers.utils.defaultAbiCoder.decode(["address"], ret)
+  );
+  const registryOwner = decodedData[0][0];
+  const nameWrapperOwner = decodedData[1][0];
+  const registrarOwner = decodedData[2]?.[0];
+  if (labels[labels.length - 1] === "eth") {
+    if (registrarOwner === nameWrapper.address) {
+      return {
+        owner: nameWrapperOwner,
+        ownershipLevel: "nameWrapper"
+      };
+    }
+    if (registrarOwner) {
+      return {
+        registrant: registrarOwner,
+        owner: registryOwner,
+        ownershipLevel: "registrar"
+      };
+    }
+    if (labels.length > 2 && ethers.utils.hexStripZeros(registryOwner) !== "0x") {
+      if (registryOwner === nameWrapper.address && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+        return {
+          owner: nameWrapperOwner,
+          ownershipLevel: "nameWrapper"
+        };
+      }
+      return {
+        owner: registryOwner,
+        ownershipLevel: "registry"
+      };
+    }
+    return;
+  }
+  if (registryOwner === nameWrapper.address && ethers.utils.hexStripZeros(nameWrapperOwner) !== "0x") {
+    return {
+      owner: nameWrapperOwner,
+      ownershipLevel: "nameWrapper"
+    };
+  }
+  if (ethers.utils.hexStripZeros(registryOwner) !== "0x") {
+    return {
+      owner: registryOwner,
+      ownershipLevel: "registry"
+    };
+  }
+  return;
+};
+var getOwner_default = { raw, decode };
+export {
+  getOwner_default as default
+};

package/dist/esm/functions/getPrice.mjs

@@ -0,0 +1,59 @@
+// src/functions/getPrice.ts
+import { utils } from "ethers";
+var raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
+  const controller = await contracts?.getEthRegistrarController();
+  const baseCall = {
+    to: controller.address,
+    data: controller.interface.encodeFunctionData("rentPrice", [
+      name,
+      duration
+    ])
+  };
+  if (legacy) {
+    return multicallWrapper.raw([
+      baseCall,
+      {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData("rentPrice", [name, 0])
+      }
+    ]);
+  }
+  return baseCall;
+};
+var decode = async ({ contracts, multicallWrapper }, data, _name, _number, legacy) => {
+  if (data === null)
+    return;
+  const controller = await contracts?.getEthRegistrarController();
+  try {
+    let base;
+    let premium;
+    if (legacy) {
+      const result = await multicallWrapper.decode(data);
+      const [price] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[0].returnData
+      );
+      [premium] = utils.defaultAbiCoder.decode(
+        ["uint256"],
+        result[1].returnData
+      );
+      base = price.sub(premium);
+    } else {
+      ;
+      [[base, premium]] = controller.interface.decodeFunctionResult(
+        "rentPrice",
+        data
+      );
+    }
+    return {
+      base,
+      premium
+    };
+  } catch {
+    return;
+  }
+};
+var getPrice_default = { raw, decode };
+export {
+  getPrice_default as default
+};