@ensdomains/ensjs 3.0.0-alpha.10 → 3.0.0-alpha.13

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,4 +1,4 @@
-import { utils } from 'ethers';
+import { BigNumber } from 'ethers';
 import { testable as fuseEnums } from '../utils/fuses';
 import { namehash } from '../utils/normalise';
 const NameSafety = [
@@ -20,7 +20,8 @@ const raw = async ({ contracts }, 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()
@@ -33,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 = 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 };
-    });
-}

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

@@ -10,8 +10,8 @@ declare const _default: {
         reverseResolverAddress: any;
         resolverAddress: any;
     } | {
-        name: null;
-        match: boolean;
+        name: undefined;
+        match?: undefined;
         reverseResolverAddress?: undefined;
         resolverAddress?: undefined;
     } | undefined>;

package/dist/esm/functions/getName.js

@@ -23,7 +23,7 @@ const decode = async ({ contracts }, data, address) => {
         };
     }
     catch {
-        return { name: null, match: false };
+        return { name: undefined };
     }
 };
 export default {

package/dist/esm/functions/getProfile.js

@@ -215,7 +215,7 @@ const graphFetch = async ({ gqlInstance }, name, wantedRecords, resolverAddress)
         resolverResponse = domain?.resolver;
     }
     else {
-        const resolverId = `${resolverAddress}-${id}`;
+        const resolverId = `${resolverAddress.toLowerCase()}-${id}`;
         ({ resolver: resolverResponse, domain } = await client.request(customResolverQuery, { id, resolverId }));
     }
     if (!domain)

package/dist/esm/functions/getSpecificRecord.js

@@ -13,8 +13,15 @@ export const _getContentHash = {
         };
     },
     decode: async ({ contracts }, data) => {
+        let response;
         const publicResolver = await contracts?.getPublicResolver();
-        const [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        try {
+            ;
+            [response] = publicResolver.interface.decodeFunctionResult('contenthash', data);
+        }
+        catch {
+            return;
+        }
         if (!response) {
             return;
         }

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

@@ -16,7 +16,7 @@ declare type Params = {
     pageSize?: number;
     orderDirection?: 'asc' | 'desc';
     orderBy?: 'createdAt' | 'labelName';
-    lastSubnames: Array<any>;
+    lastSubnames?: Array<any>;
     isLargeQuery?: boolean;
 };
 declare const getSubnames: (injected: ENSArgs<'gqlInstance'>, functionArgs: Params) => Promise<{

package/dist/esm/functions/getSubnames.js

@@ -1,7 +1,7 @@
 import { truncateFormat } from '../utils/format';
 import { decryptName } from '../utils/labels';
 import { namehash } from '../utils/normalise';
-const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames }) => {
+const largeQuery = async ({ gqlInstance }, { name, page, pageSize = 10, orderDirection, orderBy, lastSubnames = [], }) => {
     const client = gqlInstance.client;
     let finalQuery = gqlInstance.gql `
     query getSubnames(

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

@@ -0,0 +1,11 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+import { CommitmentParams } from '../utils/registerHelpers';
+declare type Params = Omit<CommitmentParams, 'name' | 'resolver'> & {
+    resolverAddress?: string;
+    secret: string;
+    wrapperExpiry: number;
+    value: BigNumber;
+};
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { resolverAddress, value, ...params }: Params): Promise<import("ethers").PopulatedTransaction>;
+export {};

package/dist/esm/functions/registerName.js

@@ -0,0 +1,16 @@
+import { makeRegistrationData, } from '../utils/registerHelpers';
+export default async function ({ contracts }, name, { resolverAddress, value, ...params }) {
+    const labels = name.split('.');
+    if (labels.length !== 2 || labels[1] !== 'eth')
+        throw new Error('Currently only .eth TLD registrations are supported');
+    const controller = await contracts.getEthRegistrarController();
+    const _resolver = await contracts.getPublicResolver(undefined, resolverAddress);
+    const generatedParams = makeRegistrationData({
+        name,
+        resolver: _resolver,
+        ...params,
+    });
+    return controller.populateTransaction.register(...generatedParams, {
+        value,
+    });
+}

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

@@ -0,0 +1,6 @@
+import type { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+export default function ({ contracts }: ENSArgs<'contracts'>, name: string, { duration, value, }: {
+    duration: number;
+    value: BigNumber;
+}): Promise<import("ethers").PopulatedTransaction>;

package/dist/esm/functions/renewName.js

@@ -0,0 +1,7 @@
+export default async function ({ contracts }, name, { duration, value, }) {
+    const labels = name.split('.');
+    if (labels.length !== 2 || labels[1] !== 'eth')
+        throw new Error('Currently only .eth TLD renewals are supported');
+    const controller = await contracts.getEthRegistrarController();
+    return controller.populateTransaction.renew(labels[0], duration, { value });
+}

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

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

package/dist/esm/functions/transferSubname.js

@@ -1,6 +1,7 @@
 import { ethers } from 'ethers';
 import { namehash } from '../utils/normalise';
-export default async function ({ contracts, signer }, name, { contract, address, }) {
+import { makeExpiry } from '../utils/wrapperExpiry';
+export default async function ({ contracts, signer, getExpiry, }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
     const labels = name.split('.');
     const label = labels.shift();
     const labelhash = ethers.utils.solidityKeccak256(['string'], [label]);
@@ -8,11 +9,12 @@ export default async function ({ contracts, signer }, name, { contract, address,
     switch (contract) {
         case 'registry': {
             const registry = (await contracts?.getRegistry()).connect(signer);
-            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, address);
+            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, owner);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, address, '0');
+            const expiry = await makeExpiry({ getExpiry }, labels.join('.'), 'expiry' in wrapperArgs ? wrapperArgs.expiry : undefined);
+            return nameWrapper.populateTransaction.setSubnodeOwner(parentNodehash, label, owner, '0', expiry);
         }
         default: {
             throw new Error(`Unknown contract: ${contract}`);

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

@@ -1,8 +1,10 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, signer, populate }: ENSArgs<'contracts' | 'signer' | 'populate'>, name: string, { wrappedOwner, fuseOptions, resolverAddress, }: {
+import { Expiry } from '../utils/wrapperExpiry';
+export default function ({ contracts, signer, getExpiry, }: ENSArgs<'contracts' | 'signer' | 'getExpiry'>, name: string, { wrappedOwner, fuseOptions, expiry, resolverAddress, }: {
     wrappedOwner: string;
     fuseOptions?: FuseOptions | string | number;
+    expiry?: Expiry;
     resolverAddress?: string;
 }): Promise<ethers.PopulatedTransaction>;

package/dist/esm/functions/wrapName.js

@@ -1,54 +1,60 @@
 import { ethers } from 'ethers';
 import generateFuseInput from '../utils/generateFuseInput';
 import { hexEncodeName } from '../utils/hexEncodedName';
-async function wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address) {
+import { makeExpiry } from '../utils/wrapperExpiry';
+async function wrapETH({ contracts }, labels, wrappedOwner, expiry, decodedFuses, resolverAddress, signer, address) {
     const nameWrapper = await contracts?.getNameWrapper();
     const baseRegistrar = (await contracts?.getBaseRegistrar()).connect(signer);
     const labelhash = ethers.utils.solidityKeccak256(['string'], [labels[0]]);
-    const data = ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, '0x0', decodedFuses, resolverAddress]);
+    const data = ethers.utils.defaultAbiCoder.encode(['string', 'address', 'uint32', 'uint64', 'address'], [labels[0], wrappedOwner, decodedFuses, expiry, resolverAddress]);
     return baseRegistrar.populateTransaction['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
 }
-async function wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer) {
+async function wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer) {
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     const registry = await contracts?.getRegistry();
     const hasApproval = await registry.isApprovedForAll(address, nameWrapper.address);
     if (!hasApproval) {
         throw new Error('NameWrapper must have approval to wrap a name from this address.');
     }
-    return nameWrapper.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, resolverAddress);
 }
-export default async function ({ contracts, signer, populate }, name, { wrappedOwner, fuseOptions, resolverAddress, }) {
+export default async function ({ contracts, signer, getExpiry, }, name, { wrappedOwner, fuseOptions, expiry, resolverAddress, }) {
     const address = await signer.getAddress();
     let decodedFuses;
-    switch (typeof fuseOptions) {
-        case 'object': {
-            decodedFuses = generateFuseInput(fuseOptions);
-            break;
-        }
-        case 'number': {
-            decodedFuses = fuseOptions.toString(16);
-            break;
-        }
-        case 'string': {
-            decodedFuses = fuseOptions;
-            break;
-        }
-        case 'undefined': {
-            decodedFuses = '0';
-            break;
-        }
-        default: {
-            throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
-        }
-    }
     const publicResolver = await contracts?.getPublicResolver();
     if (!resolverAddress)
         resolverAddress = publicResolver.address;
     const labels = name.split('.');
-    if (labels.length < 3 && labels[labels.length - 1] === 'eth') {
-        return wrapETH({ contracts }, labels, wrappedOwner, decodedFuses, resolverAddress, signer, address);
+    if (labels.length === 2 && labels[1] === 'eth') {
+        switch (typeof fuseOptions) {
+            case 'object': {
+                decodedFuses = generateFuseInput(fuseOptions);
+                break;
+            }
+            case 'number': {
+                decodedFuses = fuseOptions.toString(16);
+                break;
+            }
+            case 'string': {
+                decodedFuses = fuseOptions;
+                break;
+            }
+            case 'undefined': {
+                decodedFuses = '0';
+                break;
+            }
+            default: {
+                throw new Error(`Invalid fuseOptions type: ${typeof fuseOptions}`);
+            }
+        }
+        const expiryToUse = await makeExpiry({ getExpiry }, name, expiry);
+        return wrapETH({ contracts }, labels, wrappedOwner, expiryToUse, decodedFuses, resolverAddress, signer, address);
     }
     else {
-        return wrapOther({ contracts }, name, wrappedOwner, decodedFuses, resolverAddress, address, signer);
+        if (fuseOptions)
+            throw new Error('Fuses can not be initially set when wrapping a non .eth name');
+        if (expiry)
+            throw new Error('Expiry can not be initially set when wrapping a non .eth name');
+        return wrapOther({ contracts }, name, wrappedOwner, resolverAddress, address, signer);
     }
 }