@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

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

@@ -0,0 +1,15 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+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/cjs/functions/transferSubname.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
+const wrapperExpiry_1 = require("../utils/wrapperExpiry");
+async function default_1({ contracts, signer, getExpiry, }, name, { contract, owner, resolverAddress, ...wrapperArgs }) {
+    const labels = name.split('.');
+    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.setSubnodeOwner(parentNodehash, labelhash, owner);
+        }
+        case 'nameWrapper': {
+            const nameWrapper = (await contracts?.getNameWrapper()).connect(signer);
+            const expiry = await (0, wrapperExpiry_1.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}`);
+        }
+    }
+}
+exports.default = default_1;

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

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

package/dist/cjs/functions/unwrapName.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const normalise_1 = require("../utils/normalise");
+async function default_1({ contracts, signer }, name, { newController, newRegistrant, }) {
+    const labels = name.split('.');
+    const labelhash = ethers_1.utils.solidityKeccak256(['string'], [labels[0]]);
+    const parentNodehash = (0, normalise_1.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.populateTransaction.unwrapETH2LD(labelhash, newRegistrant, newController);
+    }
+    else {
+        if (newRegistrant) {
+            throw new Error('newRegistrant can only be specified for .eth names');
+        }
+        return nameWrapper.populateTransaction.unwrap(parentNodehash, labelhash, newController);
+    }
+}
+exports.default = default_1;

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

@@ -0,0 +1,10 @@
+import { ethers } from 'ethers';
+import { ENSArgs } from '..';
+import type { FuseOptions } from '../@types/FuseOptions';
+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/cjs/functions/wrapName.js

@@ -0,0 +1,66 @@
+"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 hexEncodedName_1 = require("../utils/hexEncodedName");
+const wrapperExpiry_1 = require("../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_1.ethers.utils.solidityKeccak256(['string'], [labels[0]]);
+    const data = ethers_1.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, 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((0, hexEncodedName_1.hexEncodeName)(name), wrappedOwner, resolverAddress);
+}
+async function default_1({ contracts, signer, getExpiry, }, name, { wrappedOwner, fuseOptions, expiry, resolverAddress, }) {
+    const address = await signer.getAddress();
+    let decodedFuses;
+    const publicResolver = await contracts?.getPublicResolver();
+    if (!resolverAddress)
+        resolverAddress = publicResolver.address;
+    const labels = name.split('.');
+    if (labels.length === 2 && labels[1] === 'eth') {
+        switch (typeof fuseOptions) {
+            case 'object': {
+                decodedFuses = (0, generateFuseInput_1.default)(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 (0, wrapperExpiry_1.makeExpiry)({ getExpiry }, name, expiry);
+        return wrapETH({ contracts }, labels, wrappedOwner, expiryToUse, decodedFuses, resolverAddress, signer, address);
+    }
+    else {
+        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);
+    }
+}
+exports.default = default_1;