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

package/src/utils/registerHelpers.ts

@@ -6,12 +6,56 @@ import { labelhash } from './labels'
 import { namehash } from './normalise'
 import { generateRecordCallArray, RecordOptions } from './recordHelpers'
 
+export type RegistrationParams = {
+  name: string
+  owner: string
+  duration: number
+  secret: string
+  resolver: PublicResolver
+  records?: RecordOptions
+  reverseRecord?: boolean
+  fuses?: FuseOptions
+  wrapperExpiry: number
+}
+
+export type CommitmentParams = Omit<
+  RegistrationParams,
+  'secret' | 'wrapperExpiry'
+> & {
+  secret?: string
+  wrapperExpiry?: number
+}
+
+export type RegistrationTuple = [
+  name: string,
+  owner: string,
+  duration: number,
+  secret: string,
+  resolver: string,
+  data: string[],
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: number,
+]
+
+export type CommitmentTuple = [
+  labelhash: string,
+  owner: string,
+  duration: number,
+  resolver: string,
+  data: string[],
+  secret: string,
+  reverseRecord: boolean,
+  fuses: string,
+  wrapperExpiry: number,
+]
+
 export const randomSecret = () => {
   const bytes = Buffer.allocUnsafe(32)
   return '0x' + crypto.getRandomValues(bytes).toString('hex')
 }
 
-export const makeCommitment = ({
+export const makeCommitmentData = ({
   name,
   owner,
   duration,
@@ -19,69 +63,83 @@ export const makeCommitment = ({
   records,
   reverseRecord,
   fuses,
-}: {
-  name: string
-  owner: string
-  duration: number
-  resolver: PublicResolver
-  records?: RecordOptions
-  reverseRecord?: boolean
-  fuses?: FuseOptions
-}) => {
+  wrapperExpiry,
+  secret,
+}: CommitmentParams & {
+  secret: string
+}): CommitmentTuple => {
   const label = labelhash(name.split('.')[0])
   const hash = namehash(name)
   const resolverAddress = resolver.address
-  const data = records ? generateRecordCallArray(hash, records, resolver) : []
-  const secret = randomSecret()
   const fuseData = fuses ? generateFuseInput(fuses) : '0'
 
-  const commitment = _makeCommitment({
-    labelhash: label,
+  if (reverseRecord) {
+    if (!records) {
+      records = { coinTypes: [{ key: 'ETH', value: owner }] }
+    } else if (!records.coinTypes?.find((c) => c.key === 'ETH')) {
+      if (!records.coinTypes) records.coinTypes = []
+      records.coinTypes.push({ key: 'ETH', value: owner })
+    }
+  }
+
+  const data = records ? generateRecordCallArray(hash, records, resolver) : []
+
+  return [
+    label,
     owner,
     duration,
-    secret,
-    resolver: resolverAddress,
+    resolverAddress,
     data,
-    reverseRecord: !!reverseRecord,
-    fuses: fuseData,
+    secret,
+    !!reverseRecord,
+    fuseData,
+    wrapperExpiry || Math.floor(Date.now() / 1000) + duration,
+  ]
+}
+
+export const makeRegistrationData = (
+  params: RegistrationParams,
+): RegistrationTuple => {
+  const commitmentData = makeCommitmentData(params)
+  commitmentData[0] = params.name.split('.')[0]
+  const secret = commitmentData.splice(5, 1)[0]
+  commitmentData.splice(3, 0, secret)
+  return commitmentData as unknown as RegistrationTuple
+}
+
+export const makeCommitment = ({
+  secret = randomSecret(),
+  ...inputParams
+}: CommitmentParams) => {
+  const generatedParams = makeCommitmentData({
+    ...inputParams,
+    secret,
   })
 
+  const commitment = _makeCommitment(generatedParams)
+
   return {
     secret,
     commitment,
+    wrapperExpiry: generatedParams[8],
   }
 }
 
-export const _makeCommitment = ({
-  labelhash,
-  owner,
-  duration,
-  secret,
-  resolver,
-  data,
-  reverseRecord,
-  fuses,
-}: {
-  labelhash: string
-  owner: string
-  duration: number
-  secret: string
-  resolver: string
-  data: string[]
-  reverseRecord: boolean
-  fuses: string
-}) => {
-  return utils.solidityKeccak256(
-    [
-      'bytes32',
-      'address',
-      'uint256',
-      'bytes32',
-      'address',
-      'bytes[]',
-      'bool',
-      'uint96',
-    ],
-    [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses],
+export const _makeCommitment = (params: CommitmentTuple) => {
+  return utils.keccak256(
+    utils.defaultAbiCoder.encode(
+      [
+        'bytes32',
+        'address',
+        'uint256',
+        'address',
+        'bytes[]',
+        'bytes32',
+        'bool',
+        'uint32',
+        'uint64',
+      ],
+      params,
+    ),
   )
 }

package/src/utils/wrapperExpiry.ts

@@ -0,0 +1,31 @@
+import { BigNumber } from 'ethers'
+import { ENSArgs } from '..'
+
+export type Expiry = string | number | Date | BigNumber
+
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1)
+
+export const makeExpiry = async (
+  { getExpiry }: ENSArgs<'getExpiry'>,
+  name: string,
+  expiry?: Expiry,
+) => {
+  if (expiry) {
+    if (expiry instanceof Date) {
+      return BigNumber.from(expiry.getTime() / 1000)
+    } else if (expiry instanceof BigNumber) {
+      return expiry
+    } else {
+      return BigNumber.from(expiry)
+    }
+  } else {
+    if (name.endsWith('.eth')) {
+      const expResponse = await getExpiry(name)
+      if (!expResponse?.expiry)
+        throw new Error("Couldn't get expiry for name, please provide one.")
+      return BigNumber.from(expResponse.expiry.getTime() / 1000)
+    } else {
+      return MAX_EXPIRY
+    }
+  }
+}

package/src/utils/writeTx.ts

@@ -1,6 +1,16 @@
 import { JsonRpcSigner } from '@ethersproject/providers'
 import type { PopulatedTransaction } from 'ethers'
 
+type CustomData = Record<string, any>
+
+const withCustomData = <T extends object>(
+  tx: T,
+  customData: CustomData | undefined,
+): (T & { customData: CustomData }) | T =>
+  customData ? { ...tx, customData } : tx
+
 export default (signer: JsonRpcSigner, populate: boolean) =>
-  (tx: PopulatedTransaction) =>
-    populate ? tx : signer.sendTransaction(tx)
+  ({ customData, ...tx }: PopulatedTransaction) =>
+    populate
+      ? withCustomData(tx, customData)
+      : signer.sendTransaction(tx).then((r) => withCustomData(r, customData))

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/DoNotCallOnChainUniversalResolverProxy").DoNotCallOnChainUniversalResolverProxy;
-export default _default;

package/dist/cjs/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const DoNotCallOnChainUniversalResolverProxy__factory_1 = require("../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory");
-exports.default = (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory_1.DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);

package/dist/cjs/generated/DoNotCallOnChainUniversalResolverProxy.d.ts

@@ -1,144 +0,0 @@
-import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
-import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
-import type { Listener, Provider } from "@ethersproject/providers";
-import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
-export declare namespace DoNotCallOnChainUniversalResolverProxy {
-    type ReverseCallStruct = {
-        target: string;
-        data: BytesLike;
-        dataType: BigNumberish;
-        locations: BigNumberish[];
-    };
-    type ReverseCallStructOutput = [
-        string,
-        string,
-        number,
-        BigNumber[]
-    ] & {
-        target: string;
-        data: string;
-        dataType: number;
-        locations: BigNumber[];
-    };
-}
-export interface DoNotCallOnChainUniversalResolverProxyInterface extends utils.Interface {
-    functions: {
-        "isOwner(address)": FunctionFragment;
-        "owner()": FunctionFragment;
-        "reverse(bytes,(address,bytes,uint8,uint256[])[])": FunctionFragment;
-        "setUniversalResolver(address)": FunctionFragment;
-        "transferOwnership(address)": FunctionFragment;
-        "universalResolver()": FunctionFragment;
-    };
-    getFunction(nameOrSignatureOrTopic: "isOwner" | "owner" | "reverse" | "setUniversalResolver" | "transferOwnership" | "universalResolver"): FunctionFragment;
-    encodeFunctionData(functionFragment: "isOwner", values: [string]): string;
-    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
-    encodeFunctionData(functionFragment: "reverse", values: [
-        BytesLike,
-        DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[]
-    ]): string;
-    encodeFunctionData(functionFragment: "setUniversalResolver", values: [string]): string;
-    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
-    encodeFunctionData(functionFragment: "universalResolver", values?: undefined): string;
-    decodeFunctionResult(functionFragment: "isOwner", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "reverse", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "setUniversalResolver", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
-    decodeFunctionResult(functionFragment: "universalResolver", data: BytesLike): Result;
-    events: {
-        "OwnershipTransferred(address,address)": EventFragment;
-    };
-    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
-}
-export interface OwnershipTransferredEventObject {
-    previousOwner: string;
-    newOwner: string;
-}
-export declare type OwnershipTransferredEvent = TypedEvent<[
-    string,
-    string
-], OwnershipTransferredEventObject>;
-export declare type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
-export interface DoNotCallOnChainUniversalResolverProxy extends BaseContract {
-    connect(signerOrProvider: Signer | Provider | string): this;
-    attach(addressOrName: string): this;
-    deployed(): Promise<this>;
-    interface: DoNotCallOnChainUniversalResolverProxyInterface;
-    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
-    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
-    listeners(eventName?: string): Array<Listener>;
-    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
-    removeAllListeners(eventName?: string): this;
-    off: OnEvent<this>;
-    on: OnEvent<this>;
-    once: OnEvent<this>;
-    removeListener: OnEvent<this>;
-    functions: {
-        isOwner(addr: string, overrides?: CallOverrides): Promise<[boolean]>;
-        owner(overrides?: CallOverrides): Promise<[string]>;
-        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
-            name: string;
-            returnData: string[];
-        }>;
-        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<ContractTransaction>;
-        universalResolver(overrides?: CallOverrides): Promise<[string]>;
-    };
-    isOwner(addr: string, overrides?: CallOverrides): Promise<boolean>;
-    owner(overrides?: CallOverrides): Promise<string>;
-    reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
-        name: string;
-        returnData: string[];
-    }>;
-    setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    transferOwnership(newOwner: string, overrides?: Overrides & {
-        from?: string | Promise<string>;
-    }): Promise<ContractTransaction>;
-    universalResolver(overrides?: CallOverrides): Promise<string>;
-    callStatic: {
-        isOwner(addr: string, overrides?: CallOverrides): Promise<boolean>;
-        owner(overrides?: CallOverrides): Promise<string>;
-        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<[string, string[]] & {
-            name: string;
-            returnData: string[];
-        }>;
-        setUniversalResolver(newUniversalResolver: string, overrides?: CallOverrides): Promise<void>;
-        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
-        universalResolver(overrides?: CallOverrides): Promise<string>;
-    };
-    filters: {
-        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
-        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
-    };
-    estimateGas: {
-        isOwner(addr: string, overrides?: CallOverrides): Promise<BigNumber>;
-        owner(overrides?: CallOverrides): Promise<BigNumber>;
-        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<BigNumber>;
-        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<BigNumber>;
-        universalResolver(overrides?: CallOverrides): Promise<BigNumber>;
-    };
-    populateTransaction: {
-        isOwner(addr: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        reverse(reverseNode: BytesLike, calls: DoNotCallOnChainUniversalResolverProxy.ReverseCallStruct[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        setUniversalResolver(newUniversalResolver: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        transferOwnership(newOwner: string, overrides?: Overrides & {
-            from?: string | Promise<string>;
-        }): Promise<PopulatedTransaction>;
-        universalResolver(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-    };
-}

package/dist/cjs/generated/DoNotCallOnChainUniversalResolverProxy.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/generated/factories/DoNotCallOnChainUniversalResolverProxy__factory.d.ts

@@ -1,56 +0,0 @@
-import { Signer } from "ethers";
-import type { Provider } from "@ethersproject/providers";
-import type { DoNotCallOnChainUniversalResolverProxy, DoNotCallOnChainUniversalResolverProxyInterface } from "../DoNotCallOnChainUniversalResolverProxy";
-export declare class DoNotCallOnChainUniversalResolverProxy__factory {
-    static readonly abi: ({
-        inputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-        name?: undefined;
-        outputs?: undefined;
-    } | {
-        anonymous: boolean;
-        inputs: {
-            indexed: boolean;
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        name: string;
-        type: string;
-        stateMutability?: undefined;
-        outputs?: undefined;
-    } | {
-        inputs: ({
-            internalType: string;
-            name: string;
-            type: string;
-            components?: undefined;
-        } | {
-            components: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
-            internalType: string;
-            name: string;
-            type: string;
-        })[];
-        name: string;
-        outputs: {
-            internalType: string;
-            name: string;
-            type: string;
-        }[];
-        stateMutability: string;
-        type: string;
-        anonymous?: undefined;
-    })[];
-    static createInterface(): DoNotCallOnChainUniversalResolverProxyInterface;
-    static connect(address: string, signerOrProvider: Signer | Provider): DoNotCallOnChainUniversalResolverProxy;
-}

package/dist/cjs/generated/factories/DoNotCallOnChainUniversalResolverProxy__factory.js

@@ -1,171 +0,0 @@
-"use strict";
-/* Autogenerated file. Do not edit manually. */
-/* tslint:disable */
-/* eslint-disable */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoNotCallOnChainUniversalResolverProxy__factory = void 0;
-const ethers_1 = require("ethers");
-const _abi = [
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "_resolver",
-                type: "address",
-            },
-        ],
-        stateMutability: "nonpayable",
-        type: "constructor",
-    },
-    {
-        anonymous: false,
-        inputs: [
-            {
-                indexed: true,
-                internalType: "address",
-                name: "previousOwner",
-                type: "address",
-            },
-            {
-                indexed: true,
-                internalType: "address",
-                name: "newOwner",
-                type: "address",
-            },
-        ],
-        name: "OwnershipTransferred",
-        type: "event",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "addr",
-                type: "address",
-            },
-        ],
-        name: "isOwner",
-        outputs: [
-            {
-                internalType: "bool",
-                name: "",
-                type: "bool",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "owner",
-        outputs: [
-            {
-                internalType: "address",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "bytes",
-                name: "reverseNode",
-                type: "bytes",
-            },
-            {
-                components: [
-                    {
-                        internalType: "address",
-                        name: "target",
-                        type: "address",
-                    },
-                    {
-                        internalType: "bytes",
-                        name: "data",
-                        type: "bytes",
-                    },
-                    {
-                        internalType: "enum DoNotCallOnChainUniversalResolverProxy.ReverseCallDataType",
-                        name: "dataType",
-                        type: "uint8",
-                    },
-                    {
-                        internalType: "uint256[]",
-                        name: "locations",
-                        type: "uint256[]",
-                    },
-                ],
-                internalType: "struct DoNotCallOnChainUniversalResolverProxy.ReverseCall[]",
-                name: "calls",
-                type: "tuple[]",
-            },
-        ],
-        name: "reverse",
-        outputs: [
-            {
-                internalType: "string",
-                name: "name",
-                type: "string",
-            },
-            {
-                internalType: "bytes[]",
-                name: "returnData",
-                type: "bytes[]",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "newUniversalResolver",
-                type: "address",
-            },
-        ],
-        name: "setUniversalResolver",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [
-            {
-                internalType: "address",
-                name: "newOwner",
-                type: "address",
-            },
-        ],
-        name: "transferOwnership",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function",
-    },
-    {
-        inputs: [],
-        name: "universalResolver",
-        outputs: [
-            {
-                internalType: "contract UniversalResolver",
-                name: "",
-                type: "address",
-            },
-        ],
-        stateMutability: "view",
-        type: "function",
-    },
-];
-class DoNotCallOnChainUniversalResolverProxy__factory {
-    static abi = _abi;
-    static createInterface() {
-        return new ethers_1.utils.Interface(_abi);
-    }
-    static connect(address, signerOrProvider) {
-        return new ethers_1.Contract(address, _abi, signerOrProvider);
-    }
-}
-exports.DoNotCallOnChainUniversalResolverProxy__factory = DoNotCallOnChainUniversalResolverProxy__factory;

package/dist/esm/contracts/doNotCallOnChainUniversalResolverProxy.d.ts

@@ -1,3 +0,0 @@
-import { ethers } from 'ethers';
-declare const _default: (provider: ethers.providers.JsonRpcProvider, address: string) => import("../generated/DoNotCallOnChainUniversalResolverProxy").DoNotCallOnChainUniversalResolverProxy;
-export default _default;

package/dist/esm/contracts/doNotCallOnChainUniversalResolverProxy.js

@@ -1,2 +0,0 @@
-import { DoNotCallOnChainUniversalResolverProxy__factory } from '../generated/factories/DoNotCallOnChainUniversalResolverProxy__factory';
-export default (provider, address) => DoNotCallOnChainUniversalResolverProxy__factory.connect(address, provider);