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

package/dist/esm/functions/getHistory.mjs

@@ -0,0 +1,231 @@
+// src/functions/getHistory.ts
+import { formatsByCoinType } from "@ensdomains/address-encoder";
+import { hexStripZeros } from "@ethersproject/bytes";
+import { decodeContenthash } from "../utils/contentHash.mjs";
+import { labelhash } from "../utils/labels.mjs";
+import { namehash } from "../utils/normalise.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 }),
+    WrappedTransfer: (args) => ({ owner: args.owner.id }),
+    NameWrapped: (args) => ({
+      fuses: args.fuses,
+      owner: args.owner.id,
+      expiry: args.expiry
+    }),
+    NameUnwrapped: (args) => ({ owner: args.owner.id }),
+    FusesSet: (args) => ({ fuses: args.fuses, expiry: args.expiry })
+  },
+  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 (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
+    }),
+    VersionChanged: (args) => ({ version: args.version })
+  }
+};
+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($namehash: String!, $labelhash: String!) {
+        domain(id: $namehash) {
+          events {
+            id
+            blockNumber
+            transactionID
+            __typename
+            ...on Transfer {
+              owner {
+                id
+              }
+            }
+            ...on NewOwner {
+              owner {
+                id
+              }
+            }
+            ...on NewResolver {
+              resolver {
+                id
+              }
+            }
+            ...on NewTTL {
+              ttl
+            }
+            ...on WrappedTransfer {
+              owner {
+                id
+              }
+            }
+            ...on NameWrapped {
+              fuses
+              expiry
+              owner {
+                id
+              }
+            }
+            ...on NameUnwrapped {
+              owner {
+                id
+              }
+            }
+            ...on FusesSet {
+              fuses
+              expiry
+            }
+          }
+          registration {
+            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
+              }
+              ...on VersionChanged {
+                version
+              }
+            }
+          }
+        }
+      }
+      `;
+  const label = name.split(".")[0];
+  const nameHash = namehash(name);
+  const labelHash = labelhash(label);
+  const response = await client.request(query, {
+    namehash: nameHash,
+    labelhash: labelHash
+  });
+  const domain = response?.domain;
+  if (!domain)
+    return;
+  const {
+    events: domainEvents,
+    registration: { events: registrationEvents },
+    resolver: { events: resolverEvents }
+  } = domain;
+  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(bytes)", [
+      hexEncodeName(reverseNode)
+    ])
+  };
+};
+var decode = async ({ contracts }, data, address) => {
+  if (data === null)
+    return;
+  const universalResolver = await contracts?.getUniversalResolver();
+  try {
+    const result = universalResolver.interface.decodeFunctionResult(
+      "reverse(bytes)",
+      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,312 @@
+// 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);
+  return {
+    ...domain,
+    name: decrypted,
+    truncatedName: truncateFormat(decrypted),
+    createdAt: new Date(parseInt(domain.createdAt) * 1e3),
+    type: "domain"
+  };
+};
+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)
+    };
+  }
+  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 {
+    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 = "labelName"
+}) => {
+  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
+          }
+          wrappedDomains(first: 1000) {
+            expiryDate
+            fuses
+            domain {
+              ${domainQueryData}
+              registration {
+                registrationDate
+                expiryDate
+              }
+            }
+          }
+        }
+      }
+    `;
+    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 (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(
+          $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 response = await client.request(finalQuery, queryVars);
+  const account = response?.account;
+  if (type === "all") {
+    return [
+      ...account?.domains.map(mapDomain) || [],
+      ...account?.registrations.map(mapRegistration) || [],
+      ...account?.wrappedDomains.map(mapWrappedDomain) || []
+    ].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) || [];
+  }
+  if (type === "wrappedOwner") {
+    return account?.wrappedDomains.map(mapWrappedDomain) || [];
+  }
+  return account?.registrations.map(mapRegistration) || [];
+};
+var getNames_default = getNames;
+export {
+  getNames_default as default
+};