@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.10

package/dist/cjs/functions/getDNSOwner.js

@@ -0,0 +1,81 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dnsQuery = exports.getDNS = exports.encodeURLParams = void 0;
+const packet = __importStar(require("dns-packet"));
+function encodeURLParams(p) {
+    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);
+};
+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;
+};
+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;
+}
+exports.default = default_1;

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

@@ -0,0 +1,12 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string) => Promise<{
+        expiry: Date | null;
+        gracePeriod: number;
+    } | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getExpiry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("ethers/lib/utils");
+const raw = async ({ contracts, multicallWrapper }, name) => {
+    const baseRegistrar = await contracts?.getBaseRegistrar();
+    const labels = name.split('.');
+    if (labels.length > 2 || labels[1] !== 'eth') {
+        throw new Error('Only .eth names have expiry dates');
+    }
+    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 decode = async ({ contracts, multicallWrapper }, data) => {
+    if (data === null)
+        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 * 1000) : null,
+            gracePeriod: gracePeriod.toNumber() * 1000,
+        };
+    }
+    catch {
+        return;
+    }
+};
+exports.default = {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,17 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, name: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string, name: string) => Promise<{
+        fuseObj: {
+            [k: string]: any;
+        };
+        vulnerability: any;
+        vulnerableNode: null;
+        rawFuses: BigNumber;
+    } | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getFuses.js

@@ -0,0 +1,62 @@
+"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");
+const NameSafety = [
+    'Safe',
+    'RegistrantNotWrapped',
+    'ControllerNotWrapped',
+    'SubdomainReplacementAllowed',
+    'Expired',
+];
+const raw = async ({ contracts }, name) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    return {
+        to: nameWrapper.address,
+        data: nameWrapper.interface.encodeFunctionData('getFuses', [
+            (0, normalise_1.namehash)(name),
+        ]),
+    };
+};
+const decode = async ({ contracts }, data, name) => {
+    const nameWrapper = await contracts?.getNameWrapper();
+    try {
+        const [fuses, vulnerability, vulnerableNode] = nameWrapper.interface.decodeFunctionResult('getFuses', data);
+        const fuseObj = Object.fromEntries(Object.keys(fuses_1.testable).map((fuseEnum) => [
+            fuseEnum
+                .toLowerCase()
+                .replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', '')),
+            fuses.and(fuses_1.testable[fuseEnum]).gt(0),
+        ]));
+        if (fuses.eq(0)) {
+            fuseObj.canDoEverything = true;
+        }
+        else {
+            fuseObj.canDoEverything = false;
+        }
+        let returnVulnerableNode = null;
+        if (ethers_1.utils.hexStripZeros(vulnerableNode) !== '0x') {
+            name.split('.').forEach((label, index, arr) => {
+                const node = arr.slice(index).join('.');
+                const nodehash = (0, normalise_1.namehash)(node);
+                if (nodehash === vulnerableNode) {
+                    returnVulnerableNode = node;
+                }
+            });
+        }
+        return {
+            fuseObj,
+            vulnerability: NameSafety[vulnerability] || vulnerability,
+            vulnerableNode: returnVulnerableNode,
+            rawFuses: fuses,
+        };
+    }
+    catch {
+        return;
+    }
+};
+exports.default = {
+    raw,
+    decode,
+};

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

@@ -0,0 +1,54 @@
+import { ENSArgs } from '..';
+export declare function getHistory({ gqlInstance }: ENSArgs<'gqlInstance'>, 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 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/cjs/functions/getHistory.js

@@ -0,0 +1,279 @@
+"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");
+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,
+        }),
+    },
+};
+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];
+};
+async function getHistory({ gqlInstance }, name) {
+    const client = gqlInstance.client;
+    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
+              }
+              ...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');
+    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 };
+    });
+}
+exports.getHistoryDetailForTransactionHash = getHistoryDetailForTransactionHash;

package/dist/cjs/functions/getName.d.ts

@@ -0,0 +1,19 @@
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts }: ENSArgs<"contracts">, address: string) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts }: ENSArgs<"contracts">, data: string, address: string) => Promise<{
+        name: any;
+        match: boolean;
+        reverseResolverAddress: any;
+        resolverAddress: any;
+    } | {
+        name: null;
+        match: boolean;
+        reverseResolverAddress?: undefined;
+        resolverAddress?: undefined;
+    } | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getName.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hexEncodedName_1 = 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 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 };
+    }
+};
+exports.default = {
+    raw,
+    decode,
+};

package/dist/cjs/functions/getNames.d.ts

@@ -0,0 +1,40 @@
+import { ENSArgs } from '..';
+export declare type Name = {
+    id: string;
+    labelName: string | null;
+    truncatedName?: string;
+    labelhash: string;
+    isMigrated: boolean;
+    name: string;
+    parent: {
+        name: string;
+    };
+    createdAt?: Date;
+    registrationDate?: Date;
+    expiryDate?: Date;
+    type: 'domain' | 'registration';
+};
+declare type BaseParams = {
+    address: string;
+    type: 'registrant' | 'owner' | 'all';
+    page?: number;
+    pageSize?: number;
+    orderDirection?: 'asc' | 'desc';
+};
+declare type RegistrantParams = {
+    type: 'registrant';
+    orderBy?: 'registrationDate' | 'expiryDate' | 'labelName';
+};
+declare type OwnerParams = {
+    type: 'owner';
+    orderBy?: 'createdAt' | 'labelName';
+};
+declare type AllParams = {
+    type: 'all';
+    orderBy?: 'labelName' | 'creationDate';
+    page?: never;
+    pageSize?: never;
+};
+declare type Params = BaseParams & (RegistrantParams | OwnerParams | AllParams);
+declare const getNames: ({ gqlInstance }: ENSArgs<'gqlInstance'>, { address: _address, type, page, pageSize, orderDirection, orderBy, }: Params) => Promise<Name[]>;
+export default getNames;