@ensdomains/ensjs 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/cjs/functions/getHistory.js

@@ -1,101 +1,108 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHistoryDetailForTransactionHash = exports.getHistoryWithDetail = exports.getHistory = void 0;
-const address_encoder_1 = require("@ensdomains/address-encoder");
-const ethers_1 = require("ethers");
-const contentHash_1 = require("../utils/contentHash");
-const makeHashIndexes_1 = require("../utils/makeHashIndexes");
+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");
+var import_labels = require("../utils/labels");
+var import_normalise = require("../utils/normalise");
 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 }),
-        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 }),
+    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 = 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
+    }),
+    VersionChanged: (args) => ({ version: args.version })
+  }
 };
-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),
-}));
-const mapResultDetailDecode = (publicResolver) => (result) => {
-    const hashIndexes = (0, makeHashIndexes_1.makeOtherIndexes)(result.input, '10f13a8c');
-    const abiLengths = hashIndexes.map((x) => ({
-        index: x,
-        length: x === 0
-            ? ethers_1.ethers.utils.hexDataLength(result.input)
-            : parseInt(ethers_1.ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }));
-    const ABIs = abiLengths.map(({ index, length }) => ethers_1.ethers.utils.hexDataSlice(result.input, index, index + length));
-    return ABIs.map((abi) => {
-        try {
-            return publicResolver.interface.decodeFunctionData('setText(bytes32,string,string)', abi);
-        }
-        catch {
-            return;
-        }
-    });
-};
-const expandDecode = (prev, curr) => {
-    if (!curr)
-        return [...prev, { value: null }];
-    if (!curr.length)
-        return [...prev, curr];
-    return [...prev, ...curr];
-};
+    data: eventFormat[type][event.__typename](event)
+  })
+);
 async function getHistory({ gqlInstance }, name) {
-    const client = gqlInstance.client;
-    const query = gqlInstance.gql `
-      query getHistory($name: String!, $label: String!) {
-        domains(where: { name: $name }) {
+  const { client } = gqlInstance;
+  const query = gqlInstance.gql`
+      query getHistory($namehash: String!, $labelhash: String!) {
+        domain(id: $namehash) {
           events {
             id
             blockNumber
@@ -119,27 +126,46 @@ async function getHistory({ gqlInstance }, name) {
             ...on NewTTL {
               ttl
             }
-          }
-          owner {
-            registrations (where: { labelName: $label }) {
-              events {
+            ...on WrappedTransfer {
+              owner {
                 id
-                blockNumber
-                transactionID
-                __typename
-                ...on NameRegistered {
-                  registrant {
-                    id
-                  }
-                  expiryDate
-                }
-                ...on NameRenewed {
-                  expiryDate
+              }
+            }
+            ...on NameWrapped {
+              fuses
+              expiry
+              owner {
+                id
+              }
+            }
+            ...on NameUnwrapped {
+              owner {
+                id
+              }
+            }
+            ...on FusesSet {
+              fuses
+              expiry
+            }
+          }
+          registration {
+            events {
+              id
+              blockNumber
+              transactionID
+              __typename
+              ...on NameRegistered {
+                registrant {
+                  id
                 }
-                ...on NameTransferred {
-                  newOwner {
-                    id
-                  }
+                expiryDate
+              }
+              ...on NameRenewed {
+                expiryDate
+              }
+              ...on NameTransferred {
+                newOwner {
+                  id
                 }
               }
             }
@@ -171,6 +197,7 @@ async function getHistory({ gqlInstance }, name) {
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -184,96 +211,39 @@ async function getHistory({ gqlInstance }, name) {
                 target
                 isAuthorized
               }
+              ...on VersionChanged {
+                version
+              }
             }
           }
         }
       }
       `;
-    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,
-    };
-}
-exports.getHistory = getHistory;
-async function getHistoryWithDetail({ contracts, gqlInstance, provider, }, name) {
-    const historyRes = await getHistory({ gqlInstance }, name);
-    if (!historyRes)
-        return;
-    const { domain, registration, resolver: resolverHistory } = historyRes;
-    const textEvents = resolverHistory.filter((event) => event.type === 'TextChanged');
-    const transactions = textEvents.reduce((prev, curr) => {
-        if (prev.includes(curr.transactionHash)) {
-            return prev;
-        }
-        return [...prev, curr.transactionHash];
-    }, []);
-    const publicResolver = await contracts?.getPublicResolver();
-    const fetchResult = (await ethers_1.ethers.utils.fetchJson(provider.connection, JSON.stringify(transactions.map((tx, i) => ({
-        jsonrpc: '2.0',
-        id: i,
-        method: 'eth_getTransactionByHash',
-        params: [tx],
-    })))))
-        .map((result) => result.result)
-        .map(mapResultDetailDecode(publicResolver))
-        .reduce(expandDecode, []);
-    const detailedResolverHistory = resolverHistory.map((event) => {
-        if (event.type !== 'TextChanged')
-            return event;
-        const { id } = event;
-        const matchedTextInx = textEvents.findIndex((x) => x.id === id);
-        return {
-            ...event,
-            data: {
-                ...event.data,
-                value: fetchResult[matchedTextInx] && fetchResult[matchedTextInx].value,
-            },
-        };
-    });
-    return {
-        domain,
-        registration,
-        resolver: detailedResolverHistory,
-    };
-}
-exports.getHistoryWithDetail = getHistoryWithDetail;
-async function getHistoryDetailForTransactionHash({ contracts, provider }, hash, indexInTransaction) {
-    const publicResolver = await contracts?.getPublicResolver();
-    const transaction = await provider.getTransaction(hash);
-    if (!transaction)
-        return;
-    const result = mapResultDetailDecode(publicResolver)({
-        input: transaction.data,
-    });
-    if (!result || !result.length)
-        return;
-    if (typeof indexInTransaction === 'number') {
-        if (indexInTransaction + 1 > result.length)
-            return;
-        const resultItem = result[indexInTransaction];
-        if (!resultItem ||
-            !resultItem.key ||
-            (!resultItem.value && resultItem.value !== ''))
-            return;
-        return { key: resultItem.key, value: resultItem.value };
-    }
-    return result.map((item) => {
-        if (!item.key)
-            return;
-        if (!item.value && item.value !== '')
-            return { key: item.key, value: null };
-        return { key: item.key, value: item.value };
-    });
+  const label = name.split(".")[0];
+  const nameHash = (0, import_normalise.namehash)(name);
+  const labelHash = (0, import_labels.labelhash)(label);
+  const { domain } = await client.request(query, {
+    namehash: nameHash,
+    labelhash: labelHash
+  });
+  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
+  };
 }
-exports.getHistoryDetailForTransactionHash = getHistoryDetailForTransactionHash;

package/dist/cjs/functions/getName.js

@@ -1,34 +1,57 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hexEncodedName_1 = require("../utils/hexEncodedName");
+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 getName_exports = {};
+__export(getName_exports, {
+  default: () => getName_default
+});
+module.exports = __toCommonJS(getName_exports);
+var import_hexEncodedName = require("../utils/hexEncodedName");
 const 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', [
-            (0, hexEncodedName_1.hexEncodeName)(reverseNode),
-        ]),
-    };
+  const universalResolver = await contracts?.getUniversalResolver();
+  const reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`;
+  return {
+    to: universalResolver.address,
+    data: universalResolver.interface.encodeFunctionData("reverse(bytes)", [
+      (0, import_hexEncodedName.hexEncodeName)(reverseNode)
+    ])
+  };
 };
 const 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: null, match: false };
-    }
+  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 };
+  }
 };
-exports.default = {
-    raw,
-    decode,
+var getName_default = {
+  raw,
+  decode
 };