@ensdomains/ensjs 3.0.0-alpha.1 → 3.0.0-alpha.12

package/dist/cjs/utils/wrapperExpiry.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeExpiry = exports.MAX_EXPIRY = void 0;
+const ethers_1 = require("ethers");
+exports.MAX_EXPIRY = ethers_1.BigNumber.from(2).pow(64).sub(1);
+const makeExpiry = async ({ getExpiry }, name, expiry) => {
+    if (expiry) {
+        if (expiry instanceof Date) {
+            return ethers_1.BigNumber.from(expiry.getTime() / 1000);
+        }
+        else if (expiry instanceof ethers_1.BigNumber) {
+            return expiry;
+        }
+        else {
+            return ethers_1.BigNumber.from(expiry);
+        }
+    }
+    else {
+        if (name.endsWith('.eth')) {
+            const expResponse = await getExpiry(name);
+            if (!expResponse?.expiry)
+                throw new Error("Couldn't get expiry for name, please provide one.");
+            return ethers_1.BigNumber.from(expResponse.expiry.getTime() / 1000);
+        }
+        else {
+            return exports.MAX_EXPIRY;
+        }
+    }
+};
+exports.makeExpiry = makeExpiry;

package/dist/cjs/utils/writeTx.d.ts

@@ -0,0 +1,4 @@
+import { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+export default _default;

package/dist/cjs/utils/writeTx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/dist/esm/GqlManager.d.ts

@@ -1,3 +1,6 @@
+export declare const enter: (node: any) => any;
+export declare const requestMiddleware: (visit: any, parse: any) => (request: any) => any;
+export declare const responseMiddleware: (traverse: any) => (response: any) => any;
 export default class GqlManager {
     gql: any;
     client?: any | null;

package/dist/esm/GqlManager.js

@@ -1,11 +1,67 @@
+// @ts-nocheck
+import { namehash } from './utils/normalise';
+const generateSelection = (selection) => ({
+    kind: 'Field',
+    name: {
+        kind: 'Name',
+        value: selection,
+    },
+    arguments: [],
+    directives: [],
+    alias: undefined,
+    selectionSet: undefined,
+});
+export const enter = (node) => {
+    if (node.kind === 'SelectionSet') {
+        const id = node.selections.find((x) => x.name && x.name.value === 'id');
+        const name = node.selections.find((x) => x.name && x.name.value === 'name');
+        if (!id && name) {
+            node.selections = [...node.selections, generateSelection('id')];
+            return node;
+        }
+    }
+};
+export const requestMiddleware = (visit, parse) => (request) => {
+    const requestBody = JSON.parse(request.body);
+    const rawQuery = requestBody.query;
+    const parsedQuery = parse(rawQuery);
+    const updatedQuery = visit(parsedQuery, { enter });
+    const updatedBody = { ...requestBody, query: updatedQuery.loc.source.body };
+    return {
+        ...request,
+        body: JSON.stringify(updatedBody),
+    };
+};
+export const responseMiddleware = (traverse) => (response) => {
+    traverse(response).forEach(function (responseItem) {
+        if (responseItem instanceof Object && responseItem.name) {
+            //Name already in hashed form
+            if (responseItem.name && responseItem.name.includes('[')) {
+                return;
+            }
+            const hashedName = namehash(responseItem.name);
+            if (responseItem.id !== hashedName) {
+                this.update({ ...responseItem, name: hashedName, invalidName: true });
+            }
+        }
+    });
+    return response;
+};
 export default class GqlManager {
     constructor() {
         this.gql = () => null;
         this.client = null;
         this.setUrl = async (url) => {
             if (url) {
-                const imported = await import('graphql-request');
-                this.client = new imported.GraphQLClient(url);
+                const [imported, traverse, { visit, parse }] = await Promise.all([
+                    import('graphql-request'),
+                    import('traverse'),
+                    import('graphql/language'),
+                ]);
+                this.client = new imported.GraphQLClient(url, {
+                    requestMiddleware: requestMiddleware(visit, parse),
+                    responseMiddleware: responseMiddleware(traverse.default),
+                });
                 this.gql = imported.gql;
             }
             else {

package/dist/esm/contracts/baseRegistrar.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").BaseRegistrarImplementation;
 export default _default;

package/dist/esm/contracts/index.d.ts

@@ -7,10 +7,10 @@ export default class ContractManager {
     private generateContractGetter;
     getPublicResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").PublicResolver>;
     getUniversalResolver: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").UniversalResolver>;
-    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
+    getRegistry: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ENSRegistry>;
     getReverseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ReverseRegistrar>;
     getNameWrapper: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").NameWrapper>;
-    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
+    getBaseRegistrar: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").BaseRegistrarImplementation>;
     getEthRegistrarController: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").ETHRegistrarController>;
-    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated/Multicall").Multicall>;
+    getMulticall: (passedProvider?: any, address?: string | undefined) => Promise<import("../generated").Multicall>;
 }

package/dist/esm/contracts/multicall.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/Multicall").Multicall;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").Multicall;
 export default _default;

package/dist/esm/contracts/registry.d.ts

@@ -1,3 +1,3 @@
 import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/ENSRegistry").ENSRegistry;
+declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated").ENSRegistry;
 export default _default;

package/dist/esm/functions/burnFuses.d.ts

@@ -1,4 +1,5 @@
-import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, fusesToBurn: FuseOptions): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { fusesToBurn, }: {
+    fusesToBurn: FuseOptions;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/burnFuses.js

@@ -1,12 +1,8 @@
-import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
-export default async function ({ contracts, provider }, name, fusesToBurn) {
-    const signer = provider?.getSigner();
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { fusesToBurn, }) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const namehash = ethers.utils.namehash(name);
+    const hash = namehash(name);
     const encodedFuses = generateFuseInput(fusesToBurn);
-    return nameWrapper.burnFuses(namehash, encodedFuses);
+    return nameWrapper.populateTransaction.setFuses(hash, encodedFuses);
 }

package/dist/esm/functions/createSubname.d.ts

@@ -1,19 +1,17 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import { FuseOptions } from '../@types/FuseOptions';
+import { Expiry } from '../utils/wrapperExpiry';
 declare type BaseArgs = {
-    name: string;
     owner: string;
     resolverAddress?: string;
     contract: 'registry' | 'nameWrapper';
-    options?: {
-        addressOrIndex?: string | number;
-    };
 };
 declare type NameWrapperArgs = {
     contract: 'nameWrapper';
     fuses?: FuseOptions;
+    expiry?: Expiry;
 } & BaseArgs;
 declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, { name, owner, resolverAddress, contract, options, ...wrapperArgs }: Args): Promise<ethers.ContractTransaction>;
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
 export {};

package/dist/esm/functions/createSubname.js

@@ -1,10 +1,8 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
-export default async function ({ contracts, provider }, { name, owner, resolverAddress, contract, options, ...wrapperArgs }) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    if (!signer) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { owner, resolverAddress, contract, ...wrapperArgs }) {
     const labels = name.split('.');
     if (labels.length === 1) {
         throw new Error('Subnames in ENS.js can only be created for 2LDs, not TLDs');
@@ -17,18 +15,19 @@ export default async function ({ contracts, provider }, { name, owner, resolverA
     }
     const label = labels.shift();
     const labelhash = ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = ethers.utils.namehash(labels.join('.'));
+    const parentNodehash = namehash(labels.join('.'));
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
+            return registry.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await makeExpiry({ getExpiry }, name, 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
             const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
                 ? generateFuseInput(wrapperArgs.fuses)
                 : '0';
-            return nameWrapper.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
+            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses, expiry);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

package/dist/esm/functions/deleteSubname.d.ts

@@ -1,4 +1,4 @@
 import { ENSArgs } from '..';
-export default function ({ contracts, provider, transferSubname, }: ENSArgs<'contracts' | 'provider' | 'transferSubname'>, name: string, contract: 'registry' | 'nameWrapper', options?: {
-    addressOrIndex?: string | number;
-}): Promise<import("ethers").ContractTransaction>;
+export default function ({ transferSubname, signer }: ENSArgs<'transferSubname' | 'signer'>, name: string, { contract, }: {
+    contract: 'registry' | 'nameWrapper';
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/deleteSubname.js

@@ -1,3 +1,7 @@
-export default async function ({ contracts, provider, transferSubname, }, name, contract, options) {
-    return transferSubname(name, contract, '0x0000000000000000000000000000000000000000', options);
+export default async function ({ transferSubname, signer }, name, { contract, }) {
+    return transferSubname.populateTransaction(name, {
+        contract,
+        owner: '0x0000000000000000000000000000000000000000',
+        signer,
+    });
 }

package/dist/esm/functions/getDNSOwner.d.ts

@@ -0,0 +1,7 @@
+import * as packet from 'dns-packet';
+export declare function encodeURLParams(p: {
+    [key: string]: string;
+}): string;
+export declare const getDNS: (q: packet.Packet) => Promise<packet.Packet>;
+export declare const dnsQuery: (qtype: string, qname: string) => Promise<packet.Packet>;
+export default function (_: any, dnsName: string): Promise<any>;

package/dist/esm/functions/getDNSOwner.js

@@ -0,0 +1,51 @@
+import * as packet from 'dns-packet';
+export function encodeURLParams(p) {
+    return Object.entries(p)
+        .map((kv) => kv.map(encodeURIComponent).join('='))
+        .join('&');
+}
+export 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);
+};
+export 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 getDNS(query);
+    if (response.rcode !== 'NOERROR') {
+        throw new Error(`DNS query failed: ${response.rcode}`);
+    }
+    return response;
+};
+export default async function (_, dnsName) {
+    const result = await dnsQuery('TXT', `_ens.${dnsName}`);
+    const address = result?.answers?.[0]?.data?.[0]?.toString()?.split('=')?.[1];
+    return address;
+}

package/dist/esm/functions/getExpiry.d.ts

@@ -1,10 +1,17 @@
 import { ENSArgs } from '..';
+declare type ContractOption = 'registrar' | 'nameWrapper';
+declare type Args = {
+    contract?: ContractOption;
+};
 declare const _default: {
-    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+    raw: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, name: string, { contract }?: Args) => Promise<{
         to: string;
         data: string;
     }>;
-    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+    decode: (ensArgs: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, { contract }?: Args) => Promise<{
+        expiry: Date;
+        gracePeriod: null;
+    } | {
         expiry: Date | null;
         gracePeriod: number;
     } | undefined>;

package/dist/esm/functions/getExpiry.js

@@ -1,10 +1,10 @@
 import { solidityKeccak256 } from 'ethers/lib/utils';
-const raw = async ({ contracts, multicallWrapper }, name) => {
-    const baseRegistrar = await contracts?.getBaseRegistrar();
-    const labels = name.split('.');
+import { namehash } from '../utils/normalise';
+const getRegistrarExpiry = async ({ contracts, multicallWrapper }, labels) => {
     if (labels.length > 2 || labels[1] !== 'eth') {
-        throw new Error('Only .eth names have expiry dates');
+        throw new Error('Only .eth names have expiry dates on the registrar');
     }
+    const baseRegistrar = await contracts?.getBaseRegistrar();
     const expiryCall = baseRegistrar.interface.encodeFunctionData('nameExpires', [
         solidityKeccak256(['string'], [labels[0]]),
     ]);
@@ -20,9 +20,32 @@ const raw = async ({ contracts, multicallWrapper }, name) => {
         },
     ]);
 };
-const decode = async ({ contracts, multicallWrapper }, data) => {
-    if (data === null)
-        return;
+const getWrapperExpiry = async ({ contracts }, labels) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    const expiryCall = nameWrapper.interface.encodeFunctionData('getData', [
+        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';
+};
+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 decodeRegistrarExpiry = async ({ contracts, multicallWrapper }, data) => {
     const result = await multicallWrapper.decode(data);
     const baseRegistrar = await contracts?.getBaseRegistrar();
     try {
@@ -37,6 +60,28 @@ const decode = async ({ contracts, multicallWrapper }, data) => {
         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 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);
+};
 export default {
     raw,
     decode,

package/dist/esm/functions/getFuses.d.ts

@@ -7,10 +7,9 @@ declare const _default: {
     }>;
     decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
         fuseObj: {
-            [k: string]: any;
+            [k: string]: boolean;
         };
-        vulnerability: any;
-        vulnerableNode: null;
+        expiryDate: Date;
         rawFuses: BigNumber;
     } | undefined>;
 };

package/dist/esm/functions/getFuses.js

@@ -1,5 +1,6 @@
-import { ethers, utils } from 'ethers';
+import { BigNumber } from 'ethers';
 import { testable as fuseEnums } from '../utils/fuses';
+import { namehash } from '../utils/normalise';
 const NameSafety = [
     'Safe',
     'RegistrantNotWrapped',
@@ -12,14 +13,15 @@ const raw = async ({ contracts }, name) => {
     return {
         to: nameWrapper.address,
         data: nameWrapper.interface.encodeFunctionData('getFuses', [
-            ethers.utils.namehash(name),
+            namehash(name),
         ]),
     };
 };
 const decode = async ({ contracts }, data, name) => {
     const nameWrapper = await contracts?.getNameWrapper();
     try {
-        const [fuses, vulnerability, vulnerableNode] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const [_fuses, expiry] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const fuses = BigNumber.from(_fuses);
         const fuseObj = Object.fromEntries(Object.keys(fuseEnums).map((fuseEnum) => [
             fuseEnum
                 .toLowerCase()
@@ -32,20 +34,10 @@ const decode = async ({ contracts }, data, name) => {
         else {
             fuseObj.canDoEverything = false;
         }
-        let returnVulnerableNode = null;
-        if (utils.hexStripZeros(vulnerableNode) !== '0x') {
-            name.split('.').forEach((label, index, arr) => {
-                const node = arr.slice(index).join('.');
-                const nodehash = utils.namehash(node);
-                if (nodehash === vulnerableNode) {
-                    returnVulnerableNode = node;
-                }
-            });
-        }
+        const expiryDate = new Date(expiry * 1000);
         return {
             fuseObj,
-            vulnerability: NameSafety[vulnerability] || vulnerability,
-            vulnerableNode: returnVulnerableNode,
+            expiryDate,
             rawFuses: fuses,
         };
     }

package/dist/esm/functions/getHistory.d.ts

@@ -22,33 +22,3 @@ export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, name
         data: Record<string, any>;
     }[];
 } | undefined>;
-export declare function getHistoryWithDetail({ contracts, gqlInstance, provider, }: ENSArgs<'contracts' | 'gqlInstance' | 'provider'>, name: string): Promise<{
-    domain: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-    registration: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-    resolver: {
-        type: any;
-        blockNumber: any;
-        transactionHash: any;
-        id: any;
-        data: Record<string, any>;
-    }[];
-} | undefined>;
-export declare function getHistoryDetailForTransactionHash({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, hash: string, indexInTransaction?: number): Promise<({
-    key: any;
-    value: any;
-} | undefined)[] | {
-    key: any;
-    value: any;
-} | undefined>;

package/dist/esm/functions/getHistory.js

@@ -1,7 +1,6 @@
 import { formatsByCoinType } from '@ensdomains/address-encoder';
 import { ethers } from 'ethers';
 import { decodeContenthash } from '../utils/contentHash';
-import { makeOtherIndexes } from '../utils/makeHashIndexes';
 const eventFormat = {
     Domain: {
         NewOwner: (args) => ({ owner: args.owner.id }),
@@ -43,7 +42,7 @@ const eventFormat = {
         NameChanged: (args) => ({ name: args.name }),
         AbiChanged: (args) => ({ contentType: args.contentType }),
         PubkeyChanged: (args) => ({ x: args.x, y: args.y }),
-        TextChanged: (args) => ({ key: args.key }),
+        TextChanged: (args) => ({ key: args.key, value: args.value }),
         ContenthashChanged: (args) => ({ hash: decodeContenthash(args.hash) }),
         InterfaceChanged: (args) => ({
             interfaceId: args.interfaceId,
@@ -63,31 +62,6 @@ const mapEvents = (eventArray, type) => eventArray.map((event) => ({
     id: event.id,
     data: eventFormat[type][event.__typename](event),
 }));
-const mapResultDetailDecode = (publicResolver) => (result) => {
-    const hashIndexes = makeOtherIndexes(result.input, '10f13a8c');
-    const abiLengths = hashIndexes.map((x) => ({
-        index: x,
-        length: x === 0
-            ? ethers.utils.hexDataLength(result.input)
-            : parseInt(ethers.utils.hexDataSlice(result.input, x - 32, x), 16),
-    }));
-    const ABIs = abiLengths.map(({ index, length }) => 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];
-};
 export async function getHistory({ gqlInstance }, name) {
     const client = gqlInstance.client;
     const query = gqlInstance.gql `
@@ -168,6 +142,7 @@ export async function getHistory({ gqlInstance }, name) {
               }
               ...on TextChanged {
                 key
+                value
               }
               ...on ContenthashChanged {
                 hash
@@ -202,72 +177,3 @@ export async function getHistory({ gqlInstance }, name) {
         resolver: resolverHistory,
     };
 }
-export 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.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,
-    };
-}
-export 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 };
-    });
-}