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

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

@@ -1,5 +1,15 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, contract: 'registry' | 'nameWrapper', address: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+import { Expiry } from '../utils/wrapperExpiry';
+declare type BaseArgs = {
+    owner: string;
+    resolverAddress?: string;
+    contract: 'registry' | 'nameWrapper';
+};
+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,21 +1,20 @@
 import { ethers } from 'ethers';
-export default async function ({ contracts, provider }, name, contract, address, options) {
-    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, { contract, owner, resolverAddress, ...wrapperArgs }) {
     const labels = name.split('.');
     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.setSubnodeOwner(parentNodehash, labelhash, address);
+            return registry.populateTransaction.setSubnodeOwner(parentNodehash, labelhash, owner);
         }
         case 'nameWrapper': {
             const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
-            return nameWrapper.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/unwrapName.d.ts

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

package/dist/esm/functions/unwrapName.js

@@ -1,24 +1,20 @@
 import { utils } from 'ethers';
-export default async function ({ contracts, provider }, name, newController, newRegistrant, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+import { namehash } from '../utils/normalise';
+export default async function ({ contracts, signer }, name, { newController, newRegistrant, }) {
     const labels = name.split('.');
     const labelhash = utils.solidityKeccak256(['string'], [labels[0]]);
-    const parentNodehash = utils.namehash(labels.slice(1).join('.'));
+    const parentNodehash = namehash(labels.slice(1).join('.'));
     const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
     if (labels.length === 2 && labels[1] === 'eth') {
         if (!newRegistrant) {
             throw new Error('newRegistrant must be specified for .eth names');
         }
-        return nameWrapper.unwrapETH2LD(labelhash, newRegistrant, newController);
+        return nameWrapper.populateTransaction.unwrapETH2LD(labelhash, newRegistrant, newController);
     }
     else {
         if (newRegistrant) {
             throw new Error('newRegistrant can only be specified for .eth names');
         }
-        return nameWrapper.unwrap(parentNodehash, labelhash, newController);
+        return nameWrapper.populateTransaction.unwrap(parentNodehash, labelhash, newController);
     }
 }

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

@@ -1,6 +1,10 @@
 import { ethers } from 'ethers';
 import { ENSArgs } from '..';
 import type { FuseOptions } from '../@types/FuseOptions';
-export default function ({ contracts, provider }: ENSArgs<'contracts' | 'provider'>, name: string, wrappedOwner: string, fuseOptions?: FuseOptions | string | number, resolverAddress?: string, options?: {
-    addressOrIndex?: string | number;
-}): Promise<ethers.ContractTransaction>;
+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,58 +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', 'uint96', 'address'], [labels[0], wrappedOwner, decodedFuses, resolverAddress]);
-    return baseRegistrar['safeTransferFrom(address,address,uint256,bytes)'](address, nameWrapper.address, labelhash, data);
+    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) {
-    const nameWrapper = await contracts?.getNameWrapper();
+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.wrap(hexEncodeName(name), wrappedOwner, decodedFuses, resolverAddress);
+    return nameWrapper.populateTransaction.wrap(hexEncodeName(name), wrappedOwner, resolverAddress);
 }
-export default async function ({ contracts, provider }, name, wrappedOwner, fuseOptions, resolverAddress, options) {
-    const signer = provider?.getSigner(options?.addressOrIndex);
-    const address = await signer?.getAddress();
-    if (!signer || !address) {
-        throw new Error('No signer found');
-    }
+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);
+        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);
     }
 }