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

package/dist/cjs/functions/getDNSOwner.js

@@ -1,81 +1,82 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dnsQuery = exports.getDNS = exports.encodeURLParams = void 0;
-const packet = __importStar(require("dns-packet"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDNSOwner_exports = {};
+__export(getDNSOwner_exports, {
+  default: () => getDNSOwner_default,
+  dnsQuery: () => dnsQuery,
+  encodeURLParams: () => encodeURLParams,
+  getDNS: () => getDNS
+});
+module.exports = __toCommonJS(getDNSOwner_exports);
+var packet = __toESM(require("dns-packet"));
 function encodeURLParams(p) {
-    return Object.entries(p)
-        .map((kv) => kv.map(encodeURIComponent).join('='))
-        .join('&');
+  return Object.entries(p).map((kv) => kv.map(encodeURIComponent).join("=")).join("&");
 }
-exports.encodeURLParams = encodeURLParams;
 const getDNS = async (q) => {
-    const response = await global.fetch(`https://cloudflare-dns.com/dns-query?${encodeURLParams({
-        ct: 'application/dns-udpwireformat',
-        dns: packet.encode(q)?.toString('base64'),
-        ts: Date.now().toString(),
-    })}`);
-    const arrayBuffer = await response.arrayBuffer();
-    // @ts-ignore:next-line
-    const fromArrayBuffer = Buffer.from(arrayBuffer);
-    return packet.decode(fromArrayBuffer);
+  const response = await global.fetch(
+    `https://cloudflare-dns.com/dns-query?${encodeURLParams({
+      ct: "application/dns-udpwireformat",
+      dns: packet.encode(q)?.toString("base64"),
+      ts: Date.now().toString()
+    })}`
+  );
+  const arrayBuffer = await response.arrayBuffer();
+  const fromArrayBuffer = Buffer.from(arrayBuffer);
+  return packet.decode(fromArrayBuffer);
 };
-exports.getDNS = getDNS;
 const dnsQuery = async (qtype, qname) => {
-    const query = {
-        type: 'query',
-        id: 1,
-        flags: packet.RECURSION_DESIRED,
-        questions: [
-            {
-                type: qtype,
-                class: 'IN',
-                name: qname,
-            },
-        ],
-        additionals: [
-            {
-                type: 'OPT',
-                class: 'IN',
-                name: '.',
-                udpPayloadSize: 4096,
-                flags: packet.DNSSEC_OK,
-            },
-        ],
-        answers: [],
-    };
-    const response = await (0, exports.getDNS)(query);
-    if (response.rcode !== 'NOERROR') {
-        throw new Error(`DNS query failed: ${response.rcode}`);
-    }
-    return response;
+  const query = {
+    type: "query",
+    id: 1,
+    flags: packet.RECURSION_DESIRED,
+    questions: [
+      {
+        type: qtype,
+        class: "IN",
+        name: qname
+      }
+    ],
+    additionals: [
+      {
+        type: "OPT",
+        class: "IN",
+        name: ".",
+        udpPayloadSize: 4096,
+        flags: packet.DNSSEC_OK
+      }
+    ],
+    answers: []
+  };
+  const response = await getDNS(query);
+  if (response.rcode !== "NOERROR") {
+    throw new Error(`DNS query failed: ${response.rcode}`);
+  }
+  return response;
 };
-exports.dnsQuery = dnsQuery;
-async function default_1(_, dnsName) {
-    const result = await (0, exports.dnsQuery)('TXT', `_ens.${dnsName}`);
-    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
-    return address;
+async function getDNSOwner_default(_, dnsName) {
+  const result = await dnsQuery("TXT", `_ens.${dnsName}`);
+  const address = result?.answers?.[0]?.data?.[0]?.toString()?.split("=")?.[1];
+  return address;
 }
-exports.default = default_1;

package/dist/cjs/functions/getExpiry.js

@@ -1,90 +1,114 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("ethers/lib/utils");
-const normalise_1 = require("../utils/normalise");
+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 getExpiry_exports = {};
+__export(getExpiry_exports, {
+  default: () => getExpiry_default
+});
+module.exports = __toCommonJS(getExpiry_exports);
+var import_utils = require("ethers/lib/utils");
+var import_normalise = require("../utils/normalise");
 const getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
-    if (labels.length > 2 || labels[1] !== 'eth') {
-        throw new Error('Only .eth names have expiry dates on the registrar');
+  if (labels.length > 2 || labels[1] !== "eth") {
+    throw new Error("Only .eth names have expiry dates on the registrar");
+  }
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  const expiryCall = baseRegistrar.interface.encodeFunctionData("nameExpires", [
+    (0, import_utils.solidityKeccak256)(["string"], [labels[0]])
+  ]);
+  const gracePeriodCall = baseRegistrar.interface.encodeFunctionData("GRACE_PERIOD");
+  return multicallWrapper.raw([
+    {
+      to: baseRegistrar.address,
+      data: expiryCall
+    },
+    {
+      to: baseRegistrar.address,
+      data: gracePeriodCall
     }
-    const baseRegistrar = await contracts?.getBaseRegistrar();
-    const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
-        (0, utils_1.solidityKeccak256)(['string'], [labels[0]]),
-    ]);
-    const gracePeriodCall = baseRegistrar.interface.encodeFunctionData('GRACE_PERIOD');
-    return multicallWrapper.raw([
-        {
-            to: baseRegistrar.address,
-            data: expiryCall,
-        },
-        {
-            to: baseRegistrar.address,
-            data: gracePeriodCall,
-        },
-    ]);
+  ]);
 };
 const getWrapperExpiry = async ({ contracts }, labels) => {
-    const nameWrapper = await contracts?.getNameWrapper();
-    const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
-        (0, normalise_1.namehash)(labels.join('.')),
-    ]);
-    return {
-        to: nameWrapper.address,
-        data: expiryCall,
-    };
+  const nameWrapper = await contracts?.getNameWrapper();
+  const expiryCall = nameWrapper.interface.encodeFunctionData("getData", [
+    (0, import_normalise.namehash)(labels.join("."))
+  ]);
+  return {
+    to: nameWrapper.address,
+    data: expiryCall
+  };
 };
 const getContractToUse = (contract, labels) => {
-    if (contract)
-        return contract;
-    if (labels.length === 2 && labels[1] === 'eth') {
-        return 'registrar';
-    }
-    return 'nameWrapper';
+  if (contract)
+    return contract;
+  if (labels.length === 2 && labels[1] === "eth") {
+    return "registrar";
+  }
+  return "nameWrapper";
 };
 const raw = async (ensArgs, name, { contract } = {}) => {
-    const labels = name.split('.');
-    const contractToUse = getContractToUse(contract, labels);
-    return contractToUse === 'nameWrapper'
-        ? getWrapperExpiry(ensArgs, labels)
-        : getRegistrarExpiry(ensArgs, labels);
+  const labels = name.split(".");
+  const contractToUse = getContractToUse(contract, labels);
+  return contractToUse === "nameWrapper" ? getWrapperExpiry(ensArgs, labels) : getRegistrarExpiry(ensArgs, labels);
 };
 const decodeRegistrarExpiry = async ({ contracts, multicallWrapper }, data) => {
-    const result = await multicallWrapper.decode(data);
-    const baseRegistrar = await contracts?.getBaseRegistrar();
-    try {
-        const [nameExpires] = baseRegistrar.interface.decodeFunctionResult('nameExpires', result[0].returnData);
-        const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult('GRACE_PERIOD', result[1].returnData);
-        return {
-            expiry: nameExpires > 0 ? new Date(nameExpires * 1000) : null,
-            gracePeriod: gracePeriod.toNumber() * 1000,
-        };
-    }
-    catch {
-        return;
-    }
+  const result = await multicallWrapper.decode(data);
+  const baseRegistrar = await contracts?.getBaseRegistrar();
+  try {
+    const [nameExpires] = baseRegistrar.interface.decodeFunctionResult(
+      "nameExpires",
+      result[0].returnData
+    );
+    const [gracePeriod] = baseRegistrar.interface.decodeFunctionResult(
+      "GRACE_PERIOD",
+      result[1].returnData
+    );
+    return {
+      expiry: nameExpires > 0 ? new Date(nameExpires * 1e3) : null,
+      gracePeriod: gracePeriod.toNumber() * 1e3
+    };
+  } catch {
+    return;
+  }
 };
 const decodeWrapperExpiry = async ({ contracts }, data) => {
-    const nameWrapper = await contracts?.getNameWrapper();
-    try {
-        const [_owner, _fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getData', data);
-        return {
-            expiry: new Date(expiry * 1000),
-            gracePeriod: null,
-        };
-    }
-    catch {
-        return;
-    }
+  const nameWrapper = await contracts?.getNameWrapper();
+  try {
+    const [, , expiry] = nameWrapper.interface.decodeFunctionResult(
+      "getData",
+      data
+    );
+    return {
+      expiry: new Date(expiry * 1e3),
+      gracePeriod: null
+    };
+  } catch {
+    return;
+  }
 };
 const decode = async (ensArgs, data, name, { contract } = {}) => {
-    if (data === null)
-        return;
-    const labels = name.split('.');
-    const contractToUse = getContractToUse(contract, labels);
-    return contractToUse === 'nameWrapper'
-        ? decodeWrapperExpiry(ensArgs, data)
-        : decodeRegistrarExpiry(ensArgs, data);
+  if (data === null)
+    return;
+  const labels = name.split(".");
+  const contractToUse = getContractToUse(contract, labels);
+  return contractToUse === "nameWrapper" ? decodeWrapperExpiry(ensArgs, data) : decodeRegistrarExpiry(ensArgs, data);
 };
-exports.default = {
-    raw,
-    decode,
+var getExpiry_default = {
+  raw,
+  decode
 };

package/dist/cjs/functions/getFuses.js

@@ -1,44 +1,69 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const fuses_1 = require("../utils/fuses");
-const normalise_1 = require("../utils/normalise");
+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 getFuses_exports = {};
+__export(getFuses_exports, {
+  default: () => getFuses_default
+});
+module.exports = __toCommonJS(getFuses_exports);
+var import_ethers = require("ethers");
+var import_fuses = require("../utils/fuses");
+var import_normalise = require("../utils/normalise");
 const raw = async ({ contracts }, name) => {
-    const nameWrapper = await contracts?.getNameWrapper();
-    return {
-        to: nameWrapper.address,
-        data: nameWrapper.interface.encodeFunctionData('getData', [(0, normalise_1.namehash)(name)]),
-    };
+  const nameWrapper = await contracts?.getNameWrapper();
+  return {
+    to: nameWrapper.address,
+    data: nameWrapper.interface.encodeFunctionData("getData", [(0, import_normalise.namehash)(name)])
+  };
 };
 const decode = async ({ contracts }, data) => {
-    const nameWrapper = await contracts?.getNameWrapper();
-    try {
-        const { owner, fuses: _fuses, expiry, } = nameWrapper.interface.decodeFunctionResult('getData', data);
-        const fuses = ethers_1.BigNumber.from(_fuses);
-        const fuseObj = Object.fromEntries(Object.keys(fuses_1.fuseEnum).map((fuse) => [
-            fuse,
-            fuses.and(fuses_1.fuseEnum[fuse]).gt(0),
-        ]));
-        if (fuses.eq(0)) {
-            fuseObj.canDoEverything = true;
-        }
-        else {
-            fuseObj.canDoEverything = false;
-        }
-        const expiryDate = new Date(expiry * 1000);
-        return {
-            fuseObj,
-            expiryDate,
-            rawFuses: fuses,
-            owner,
-        };
-    }
-    catch (e) {
-        console.error('Error decoding fuses data: ', e);
-        return;
+  const nameWrapper = await contracts?.getNameWrapper();
+  try {
+    const {
+      owner,
+      fuses: _fuses,
+      expiry
+    } = nameWrapper.interface.decodeFunctionResult("getData", data);
+    const fuses = import_ethers.BigNumber.from(_fuses);
+    const fuseObj = Object.fromEntries(
+      Object.keys(import_fuses.fuseEnum).map((fuse) => [
+        fuse,
+        fuses.and(import_fuses.fuseEnum[fuse]).gt(0)
+      ])
+    );
+    if (fuses.eq(0)) {
+      fuseObj.CAN_DO_EVERYTHING = true;
+    } else {
+      fuseObj.CAN_DO_EVERYTHING = false;
     }
+    const expiryDate = new Date(expiry * 1e3);
+    return {
+      fuseObj,
+      expiryDate,
+      rawFuses: fuses,
+      owner
+    };
+  } catch (e) {
+    console.error("Error decoding fuses data: ", e);
+    return;
+  }
 };
-exports.default = {
-    raw,
-    decode,
+var getFuses_default = {
+  raw,
+  decode
 };

package/dist/cjs/functions/getHistory.js

@@ -1,73 +1,95 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHistory = void 0;
-const address_encoder_1 = require("@ensdomains/address-encoder");
-const ethers_1 = require("ethers");
-const contentHash_1 = require("../utils/contentHash");
+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 getHistory_exports = {};
+__export(getHistory_exports, {
+  getHistory: () => getHistory
+});
+module.exports = __toCommonJS(getHistory_exports);
+var import_address_encoder = require("@ensdomains/address-encoder");
+var import_ethers = require("ethers");
+var import_contentHash = require("../utils/contentHash");
 const 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 = address_encoder_1.formatsByCoinType[parseInt(args.coinType)];
-            if (!format) {
-                return {
-                    coinType: args.coinType,
-                    rawAddr: args.multiaddr,
-                };
-            }
-            if (ethers_1.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: (0, contentHash_1.decodeContenthash)(args.hash) }),
-        InterfaceChanged: (args) => ({
-            interfaceId: args.interfaceId,
-            implementer: args.implementer,
-        }),
-        AuthorisationChanged: (args) => ({
-            owner: args.owner,
-            target: args.target,
-            isAuthorized: args.isAuthorized,
-        }),
+  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 = import_address_encoder.formatsByCoinType[parseInt(args.coinType)];
+      if (!format) {
+        return {
+          coinType: args.coinType,
+          rawAddr: args.multiaddr
+        };
+      }
+      if (import_ethers.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: (0, import_contentHash.decodeContenthash)(args.hash) }),
+    InterfaceChanged: (args) => ({
+      interfaceId: args.interfaceId,
+      implementer: args.implementer
+    }),
+    AuthorisationChanged: (args) => ({
+      owner: args.owner,
+      target: args.target,
+      isAuthorized: args.isAuthorized
+    })
+  }
 };
-const mapEvents = (eventArray, type) => eventArray.map((event) => ({
+const mapEvents = (eventArray, type) => eventArray.map(
+  (event) => ({
     type: event.__typename,
     blockNumber: event.blockNumber,
     transactionHash: event.transactionID,
     id: event.id,
-    data: eventFormat[type][event.__typename](event),
-}));
+    data: eventFormat[type][event.__typename](event)
+  })
+);
 async function getHistory({ gqlInstance }, name) {
-    const client = gqlInstance.client;
-    const query = gqlInstance.gql `
+  const { client } = gqlInstance;
+  const query = gqlInstance.gql`
       query getHistory($name: String!, $label: String!) {
         domains(where: { name: $name }) {
           events {
@@ -164,20 +186,30 @@ async function getHistory({ gqlInstance }, name) {
         }
       }
       `;
-    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');
-    let resolverHistory = mapEvents(
-    // remove duplicate events for ETH cointype
-    resolverEvents.filter((event) => !event.coinType || event.coinType !== '60'), 'Resolver');
-    return {
-        domain: domainHistory,
-        registration: registrationHistory,
-        resolver: resolverHistory,
-    };
+  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
+  };
 }
-exports.getHistory = getHistory;