@ensdomains/ensjs 2.0.1 → 3.0.0-alpha.2

package/dist/cjs/functions/getNames.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_1 = require("../utils/format");
+const labels_1 = require("../utils/labels");
+const mapDomain = (domain) => {
+    const decrypted = (0, labels_1.decryptName)(domain.name);
+    return {
+        ...domain,
+        name: decrypted,
+        truncatedName: (0, format_1.truncateFormat)(decrypted),
+        createdAt: new Date(parseInt(domain.createdAt) * 1000),
+        type: 'domain',
+    };
+};
+const mapRegistration = (registration) => {
+    const decrypted = (0, labels_1.decryptName)(registration.domain.name);
+    return {
+        expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
+        registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
+        ...registration.domain,
+        name: decrypted,
+        truncatedName: (0, format_1.truncateFormat)(decrypted),
+        type: 'registration',
+    };
+};
+const getNames = async ({ gqlInstance }, { address: _address, type, page, pageSize = 10, orderDirection, orderBy, }) => {
+    const address = _address.toLowerCase();
+    const client = gqlInstance.client;
+    const domainQueryData = `
+    id
+    labelName
+    labelhash
+    name
+    isMigrated
+    parent {
+        name
+    }
+  `;
+    let queryVars = {};
+    let finalQuery = '';
+    if (type === 'all') {
+        finalQuery = gqlInstance.gql `
+      query getNames(
+        $id: ID!
+        $expiryDate: Int
+      ) {
+        account(id: $id) {
+          registrations(
+            first: 1000
+            where: { expiryDate_gt: $expiryDate }
+          ) {
+            registrationDate
+            expiryDate
+            domain {
+              ${domainQueryData}
+            }
+          }
+          domains(first: 1000) {
+            ${domainQueryData}
+            createdAt
+          }
+        }
+      }
+    `;
+        queryVars = {
+            id: address,
+            expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+        };
+    }
+    else if (type === 'owner') {
+        if (typeof page !== 'number') {
+            finalQuery = gqlInstance.gql `
+        query getNames(
+          $id: ID! 
+          $orderBy: Domain_orderBy 
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(orderBy: $orderBy, orderDirection: $orderDirection) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `;
+            queryVars = {
+                id: address,
+                orderBy,
+                orderDirection,
+            };
+        }
+        else {
+            finalQuery = gqlInstance.gql `
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Domain_orderBy
+          $orderDirection: OrderDirection
+        ) {
+          account(id: $id) {
+            domains(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+            ) {
+              ${domainQueryData}
+              createdAt
+            }
+          }
+        }
+      `;
+            queryVars = {
+                id: address,
+                first: pageSize,
+                skip: (page || 0) * pageSize,
+                orderBy,
+                orderDirection,
+            };
+        }
+    }
+    else {
+        if (typeof page !== 'number') {
+            finalQuery = gqlInstance.gql `
+        query getNames(
+          $id: ID!
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+            queryVars = {
+                id: address,
+                orderBy,
+                orderDirection,
+                expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+            };
+        }
+        else {
+            finalQuery = gqlInstance.gql `
+        query getNames(
+          $id: ID!
+          $first: Int
+          $skip: Int
+          $orderBy: Registration_orderBy
+          $orderDirection: OrderDirection
+          $expiryDate: Int
+        ) {
+          account(id: $id) {
+            registrations(
+              first: $first
+              skip: $skip
+              orderBy: $orderBy
+              orderDirection: $orderDirection
+              where: { expiryDate_gt: $expiryDate }
+            ) {
+              registrationDate
+              expiryDate
+              domain {
+                ${domainQueryData}
+              }
+            }
+          }
+        }
+      `;
+            queryVars = {
+                id: address,
+                first: pageSize,
+                skip: (page || 0) * pageSize,
+                orderBy: orderBy,
+                orderDirection: orderDirection,
+                expiryDate: Math.floor(Date.now() / 1000) - 90 * 24 * 60 * 60,
+            };
+        }
+    }
+    const { account } = await client.request(finalQuery, queryVars);
+    if (type === 'all') {
+        return [
+            ...account.domains.map(mapDomain),
+            ...account.registrations.map(mapRegistration),
+        ].sort((a, b) => {
+            if (orderDirection === 'desc') {
+                if (orderBy === 'labelName') {
+                    return b.name.localeCompare(a.name);
+                }
+                else {
+                    return b.createdAt.getTime() - a.createdAt.getTime();
+                }
+            }
+            else {
+                if (orderBy === 'labelName') {
+                    return a.name.localeCompare(b.name);
+                }
+                else if (orderBy === 'creationDate') {
+                    return a.createdAt.getTime() - b.createdAt.getTime();
+                }
+            }
+        });
+    }
+    else if (type === 'owner') {
+        return account.domains.map(mapDomain);
+    }
+    else {
+        return account.registrations.map(mapRegistration);
+    }
+};
+exports.default = getNames;

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

@@ -0,0 +1,14 @@
+import { ENSArgs } from '..';
+declare type Owner = {
+    registrant?: string;
+    owner?: string;
+    ownershipLevel: 'nameWrapper' | 'registry' | 'registrar';
+};
+declare const _default: {
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, name: string, contract?: "nameWrapper" | "registrar" | "registry" | undefined) => Promise<Owner | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getOwner.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const labels_1 = require("../utils/labels");
+const normalise_1 = require("../utils/normalise");
+const singleContractOwnerRaw = async ({ contracts }, contract, namehash, labels) => {
+    switch (contract) {
+        case 'nameWrapper': {
+            const nameWrapper = await contracts?.getNameWrapper();
+            return {
+                to: nameWrapper.address,
+                data: nameWrapper.interface.encodeFunctionData('ownerOf', [namehash]),
+            };
+        }
+        case 'registry': {
+            const registry = await contracts?.getRegistry();
+            return {
+                to: registry.address,
+                data: registry.interface.encodeFunctionData('owner', [namehash]),
+            };
+        }
+        case 'registrar': {
+            const registrar = await contracts?.getBaseRegistrar();
+            return {
+                to: registrar.address,
+                data: registrar.interface.encodeFunctionData('ownerOf', [
+                    (0, labels_1.labelhash)(labels[0]),
+                ]),
+            };
+        }
+    }
+};
+const raw = async ({ contracts, multicallWrapper }, name, contract) => {
+    const namehash = (0, normalise_1.namehash)(name);
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
+        return await singleContractOwnerRaw({ contracts }, contract || 'registry', namehash, labels);
+    }
+    const registryData = await singleContractOwnerRaw({ contracts }, 'registry', namehash, labels);
+    const nameWrapperData = await singleContractOwnerRaw({ contracts }, 'nameWrapper', namehash, labels);
+    const registrarData = await singleContractOwnerRaw({ contracts }, 'registrar', namehash, labels);
+    const data = [registryData, nameWrapperData];
+    if (labels.length == 2 && labels[1] === 'eth') {
+        data.push(registrarData);
+    }
+    return multicallWrapper.raw(data);
+};
+const singleContractOwnerDecode = (data) => ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], data)[0];
+const decode = async ({ contracts, multicallWrapper }, data, name, contract) => {
+    if (data === null)
+        return;
+    const labels = name.split('.');
+    if (contract || labels.length === 1) {
+        const singleOwner = singleContractOwnerDecode(data);
+        let obj = {
+            ownershipLevel: contract || 'registry',
+        };
+        if (contract === 'registrar') {
+            return {
+                ...obj,
+                registrant: singleOwner,
+            };
+        }
+        else {
+            return {
+                ...obj,
+                owner: singleOwner,
+            };
+        }
+    }
+    const result = await multicallWrapper.decode(data);
+    if (result === null)
+        return;
+    const nameWrapper = await contracts?.getNameWrapper();
+    const decodedData = [result[0][1], result[1][1], result[2]?.[1]].map((ret) => ret &&
+        ret !== '0x' &&
+        ethers_1.ethers.utils.defaultAbiCoder.decode(['address'], ret));
+    const registryOwner = decodedData[0][0];
+    const nameWrapperOwner = decodedData[1][0];
+    const registrarOwner = decodedData[2]?.[0];
+    // check for only .eth names
+    if (labels[labels.length - 1] === 'eth') {
+        // if the owner on the registrar is the namewrapper, then the namewrapper owner is the owner
+        // there is no "registrant" for wrapped names
+        if (registrarOwner === nameWrapper.address) {
+            return {
+                owner: nameWrapperOwner,
+                ownershipLevel: 'nameWrapper',
+            };
+        }
+        // if there is a registrar owner, then it's not a subdomain but we have also passed the namewrapper clause
+        // this means that it's an unwrapped second-level name
+        // the registrant is the owner of the NFT
+        // the owner is the controller of the records
+        if (registrarOwner) {
+            return {
+                registrant: registrarOwner,
+                owner: registryOwner,
+                ownershipLevel: 'registrar',
+            };
+        }
+        if (labels.length > 2 &&
+            ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+            // this means that the subname is wrapped
+            if (registryOwner === nameWrapper.address) {
+                return {
+                    owner: nameWrapperOwner,
+                    ownershipLevel: 'nameWrapper',
+                };
+            }
+            // unwrapped subnames do not have NFTs associated, so do not have a registrant
+            return {
+                owner: registryOwner,
+                ownershipLevel: 'registry',
+            };
+        }
+        // .eth names with no registrar owner are either unregistered or expired
+        return;
+    }
+    // non .eth names inherit the owner from the registry
+    // there will only ever be an owner for non .eth names, not a registrant
+    // this is because for unwrapped names, there is no associated NFT
+    // and for wrapped names, owner and registrant are the same thing
+    if (registryOwner == nameWrapper.address) {
+        return {
+            owner: nameWrapperOwner,
+            ownershipLevel: 'nameWrapper',
+        };
+    }
+    // for unwrapped non .eth names, the owner is the registry owner
+    if (ethers_1.ethers.utils.hexStripZeros(registryOwner) !== '0x') {
+        return {
+            owner: registryOwner,
+            ownershipLevel: 'registry',
+        };
+    }
+    // for anything else, return
+    return;
+};
+exports.default = { raw, decode };

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

@@ -0,0 +1,13 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+declare const _default: {
+    raw: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, name: string, duration: number, legacy?: boolean | undefined) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: ({ contracts, multicallWrapper }: ENSArgs<"contracts" | "multicallWrapper">, data: string, _name: string, _number: number, legacy?: boolean | undefined) => Promise<{
+        base: BigNumber;
+        premium: BigNumber;
+    } | undefined>;
+};
+export default _default;

package/dist/cjs/functions/getPrice.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const raw = async ({ contracts, multicallWrapper }, name, duration, legacy) => {
+    const controller = await contracts?.getEthRegistrarController();
+    const baseCall = {
+        to: controller.address,
+        data: controller.interface.encodeFunctionData('rentPrice', [
+            name,
+            duration,
+        ]),
+    };
+    if (legacy) {
+        return multicallWrapper.raw([
+            baseCall,
+            {
+                to: controller.address,
+                data: controller.interface.encodeFunctionData('rentPrice', [name, 0]),
+            },
+        ]);
+    }
+    return baseCall;
+};
+const decode = async ({ contracts, multicallWrapper }, data, _name, _number, legacy) => {
+    if (data === null)
+        return;
+    const controller = await contracts?.getEthRegistrarController();
+    try {
+        let base;
+        let premium;
+        if (legacy) {
+            const result = await multicallWrapper.decode(data);
+            const [price] = ethers_1.utils.defaultAbiCoder.decode(['uint256'], result[0].returnData);
+            [premium] = ethers_1.utils.defaultAbiCoder.decode(['uint256'], result[1].returnData);
+            base = price.sub(premium);
+        }
+        else {
+            ;
+            [base, premium] = controller.interface.decodeFunctionData('rentPrice', data);
+        }
+        return {
+            base,
+            premium,
+        };
+    }
+    catch {
+        return;
+    }
+};
+exports.default = { raw, decode };

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

@@ -0,0 +1,30 @@
+import { ENSArgs } from '..';
+import { DecodedContentHash } from '../utils/contentHash';
+declare type DataItem = {
+    key: string | number;
+    type: 'addr' | 'text' | 'contentHash';
+    coin?: string;
+    value: string;
+};
+declare type ResolvedProfile = {
+    isMigrated: boolean | null;
+    createdAt: string | null;
+    address?: string;
+    name?: string | null;
+    match?: boolean;
+    message?: string;
+    records?: {
+        contentHash?: DecodedContentHash | string | null;
+        texts?: DataItem[];
+        coinTypes?: DataItem[];
+    };
+    resolverAddress?: string;
+    reverseResolverAddress?: string;
+};
+declare type ProfileOptions = {
+    contentHash?: boolean;
+    texts?: boolean | string[];
+    coinTypes?: boolean | string[];
+};
+export default function ({ contracts, gqlInstance, getName, _getAddr, _getContentHash, _getText, resolverMulticallWrapper, multicallWrapper, }: ENSArgs<'contracts' | 'gqlInstance' | 'getName' | '_getText' | '_getAddr' | '_getContentHash' | 'resolverMulticallWrapper' | 'multicallWrapper'>, nameOrAddress: string, options?: ProfileOptions): Promise<ResolvedProfile | undefined>;
+export {};