@ensdomains/ensjs 3.0.0-alpha.9 → 3.0.0-beta.2

package/dist/cjs/functions/burnFuses.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, signer }, name, { fusesToBurn, }) {
-    const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-    const hash = (0, normalise_1.namehash)(name);
-    const encodedFuses = (0, generateFuseInput_1.default)(fusesToBurn);
-    return nameWrapper.populateTransaction.burnFuses(hash, encodedFuses);
-}
-exports.default = default_1;

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

@@ -1,15 +0,0 @@
-import { ethers } from 'ethers';
-import { ENSArgs } from '..';
-import { FuseOptions } from '../@types/FuseOptions';
-declare type BaseArgs = {
-    owner: string;
-    resolverAddress?: string;
-    contract: 'registry' | 'nameWrapper';
-};
-declare type NameWrapperArgs = {
-    contract: 'nameWrapper';
-    fuses?: FuseOptions;
-} & BaseArgs;
-declare type Args = BaseArgs | NameWrapperArgs;
-export default function ({ contracts, signer }: ENSArgs<'contracts' | 'signer'>, name: string, { owner, resolverAddress, contract, ...wrapperArgs }: Args): Promise<ethers.PopulatedTransaction>;
-export {};

package/dist/cjs/functions/createSubname.js

@@ -1,40 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const generateFuseInput_1 = __importDefault(require("../utils/generateFuseInput"));
-const normalise_1 = require("../utils/normalise");
-async function default_1({ contracts, signer }, 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');
-    }
-    if ('fuses' in wrapperArgs && contract === 'registry') {
-        throw new Error('Fuses can only be set on a wrapped name');
-    }
-    if (!resolverAddress) {
-        resolverAddress = (await contracts?.getPublicResolver()).address;
-    }
-    const label = labels.shift();
-    const labelhash = ethers_1.ethers.utils.solidityKeccak256(['string'], [label]);
-    const parentNodehash = (0, normalise_1.namehash)(labels.join('.'));
-    switch (contract) {
-        case 'registry': {
-            const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.populateTransaction.setSubnodeRecord(parentNodehash, labelhash, owner, resolverAddress, 0);
-        }
-        case 'nameWrapper': {
-            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            const generatedFuses = 'fuses' in wrapperArgs && wrapperArgs.fuses
-                ? (0, generateFuseInput_1.default)(wrapperArgs.fuses)
-                : '0';
-            return nameWrapper.populateTransaction.setSubnodeRecord(parentNodehash, label, owner, resolverAddress, 0, generatedFuses);
-        }
-        default: {
-            throw new Error(`Unknown contract: ${contract}`);
-        }
-    }
-}
-exports.default = default_1;

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

@@ -1,4 +0,0 @@
-import { ENSArgs } from '..';
-export default function ({ transferSubname }: ENSArgs<'transferSubname'>, name: string, { contract, }: {
-    contract: 'registry' | 'nameWrapper';
-}): Promise<import("ethers").PopulatedTransaction>;

package/dist/cjs/functions/deleteSubname.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1({ transferSubname }, name, { contract, }) {
-    return transferSubname.populateTransaction(name, {
-        contract,
-        address: '0x0000000000000000000000000000000000000000',
-    });
-}
-exports.default = default_1;

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

@@ -1,7 +0,0 @@
-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/cjs/functions/getDNSOwner.js

@@ -1,81 +0,0 @@
-"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

@@ -1,12 +0,0 @@
-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

@@ -1,45 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-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

@@ -1,62 +0,0 @@
-"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

@@ -1,54 +0,0 @@
-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

@@ -1,279 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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;