@ensdomains/ensjs 2.1.0 → 3.0.0-alpha.11

package/dist/esm/utils/recordHelpers.js

@@ -0,0 +1,65 @@
+import { formatsByCoinType, formatsByName } from '@ensdomains/address-encoder';
+import { encodeContenthash } from './contentHash';
+export const generateSetAddr = (namehash, coinType, address, resolver) => {
+    let coinTypeInstance;
+    if (!isNaN(parseInt(coinType))) {
+        coinTypeInstance = formatsByCoinType[parseInt(coinType)];
+    }
+    else {
+        coinTypeInstance = formatsByName[coinType.toUpperCase()];
+    }
+    const inputCoinType = coinTypeInstance.coinType;
+    const encodedAddress = coinTypeInstance.decoder(address);
+    return resolver?.interface.encodeFunctionData('setAddr(bytes32,uint256,bytes)', [namehash, inputCoinType, encodedAddress]);
+};
+export function generateSingleRecordCall(namehash, resolver, type) {
+    if (type === 'contentHash') {
+        return (_r) => {
+            const record = _r;
+            let _contentHash = '';
+            if (record !== _contentHash) {
+                const encoded = encodeContenthash(record);
+                if (encoded.error)
+                    throw new Error(encoded.error);
+                _contentHash = encoded.encoded;
+            }
+            return resolver.interface.encodeFunctionData('setContenthash', [
+                namehash,
+                _contentHash,
+            ]);
+        };
+    }
+    else {
+        return (_r) => {
+            const record = _r;
+            if (type === 'text') {
+                return resolver.interface.encodeFunctionData('setText', [
+                    namehash,
+                    record.key,
+                    record.value,
+                ]);
+            }
+            else {
+                return generateSetAddr(namehash, record.key, record.value, resolver);
+            }
+        };
+    }
+}
+export const generateRecordCallArray = (namehash, records, resolver) => {
+    const calls = [];
+    if (records.contentHash) {
+        const data = generateSingleRecordCall(namehash, resolver, 'contentHash')(records.contentHash);
+        data && calls.push(data);
+    }
+    if (records.texts && records.texts.length > 0) {
+        records.texts
+            .map(generateSingleRecordCall(namehash, resolver, 'text'))
+            .forEach((call) => calls.push(call));
+    }
+    if (records.coinTypes && records.coinTypes.length > 0) {
+        records.coinTypes
+            .map(generateSingleRecordCall(namehash, resolver, 'addr'))
+            .forEach((call) => calls.push(call));
+    }
+    return calls;
+};

package/dist/esm/utils/registerHelpers.d.ts

@@ -0,0 +1,26 @@
+import type { FuseOptions } from '../@types/FuseOptions';
+import type { PublicResolver } from '../generated';
+import { RecordOptions } from './recordHelpers';
+export declare const randomSecret: () => string;
+export declare const makeCommitment: ({ name, owner, duration, resolver, records, reverseRecord, fuses, }: {
+    name: string;
+    owner: string;
+    duration: number;
+    resolver: PublicResolver;
+    records?: RecordOptions | undefined;
+    reverseRecord?: boolean | undefined;
+    fuses?: FuseOptions | undefined;
+}) => {
+    secret: string;
+    commitment: string;
+};
+export declare 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;
+}) => string;

package/dist/esm/utils/registerHelpers.js

@@ -0,0 +1,43 @@
+import { utils } from 'ethers';
+import generateFuseInput from './generateFuseInput';
+import { labelhash } from './labels';
+import { namehash } from './normalise';
+import { generateRecordCallArray } from './recordHelpers';
+export const randomSecret = () => {
+    const bytes = Buffer.allocUnsafe(32);
+    return '0x' + crypto.getRandomValues(bytes).toString('hex');
+};
+export const makeCommitment = ({ name, owner, duration, resolver, records, reverseRecord, fuses, }) => {
+    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,
+        owner,
+        duration,
+        secret,
+        resolver: resolverAddress,
+        data,
+        reverseRecord: !!reverseRecord,
+        fuses: fuseData,
+    });
+    return {
+        secret,
+        commitment,
+    };
+};
+export const _makeCommitment = ({ labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses, }) => {
+    return utils.solidityKeccak256([
+        'bytes32',
+        'address',
+        'uint256',
+        'bytes32',
+        'address',
+        'bytes[]',
+        'bool',
+        'uint96',
+    ], [labelhash, owner, duration, secret, resolver, data, reverseRecord, fuses]);
+};

package/dist/esm/utils/singleCall.d.ts

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+declare const _default: (provider: ethers.providers.Provider, ensData: any, func: {
+    raw: (...args: any[]) => Promise<{
+        to: string;
+        data: string;
+    }>;
+    decode: (...args: any[]) => Promise<any>;
+}, ...data: any[]) => Promise<any>;
+export default _default;

package/dist/esm/utils/singleCall.js

@@ -0,0 +1,5 @@
+export default async (provider, ensData, func, ...data) => func
+    .raw(ensData, ...data)
+    .then((rawData) => provider.call(rawData))
+    .catch(() => null)
+    .then((ret) => func.decode(ensData, ret, ...data));

package/dist/esm/utils/validation.d.ts

@@ -0,0 +1,8 @@
+export declare const validateName: (name: string) => string;
+export declare const validateTLD: (name: string) => string;
+declare type InputType = {
+    type: 'name' | 'label' | 'address' | 'unknown';
+    info?: 'short' | 'supported' | 'unsupported';
+};
+export declare const parseInputType: (input: string) => InputType;
+export {};

package/dist/esm/utils/validation.js

@@ -0,0 +1,67 @@
+import { isAddress } from 'ethers/lib/utils';
+import { isEncodedLabelhash, saveName } from './labels';
+import { normalise } from './normalise';
+export const validateName = (name) => {
+    const nameArray = name.split('.');
+    const hasEmptyLabels = nameArray.some((label) => label.length == 0);
+    if (hasEmptyLabels)
+        throw new Error('Name cannot have empty labels');
+    const normalizedArray = nameArray.map((label) => {
+        if (label === '[root]') {
+            return label;
+        }
+        else {
+            return isEncodedLabelhash(label) ? label : normalise(label);
+        }
+    });
+    const normalizedName = normalizedArray.join('.');
+    saveName(normalizedName);
+    return normalizedName;
+};
+export const validateTLD = (name) => {
+    const labels = name.split('.');
+    return validateName(labels[labels.length - 1]);
+};
+export const parseInputType = (input) => {
+    const validTLD = validateTLD(input);
+    let regex = /[^.]+$/;
+    try {
+        validateName(input);
+    }
+    catch (e) {
+        return {
+            type: 'unknown',
+        };
+    }
+    if (input.indexOf('.') !== -1) {
+        const termArray = input.split('.');
+        const tld = input.match(regex) ? input.match(regex)[0] : '';
+        if (validTLD) {
+            if (tld === 'eth' && [...termArray[termArray.length - 2]].length < 3) {
+                // code-point length
+                return {
+                    type: 'name',
+                    info: 'short',
+                };
+            }
+            return {
+                type: 'name',
+                info: 'supported',
+            };
+        }
+        return {
+            type: 'name',
+            info: 'unsupported',
+        };
+    }
+    else if (isAddress(input)) {
+        return {
+            type: 'address',
+        };
+    }
+    else {
+        return {
+            type: 'label',
+        };
+    }
+};

package/dist/esm/utils/wrapperExpiry.d.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from 'ethers';
+import { ENSArgs } from '..';
+export declare type Expiry = string | number | Date | BigNumber;
+export declare const MAX_EXPIRY: BigNumber;
+export declare const makeExpiry: ({ getExpiry }: ENSArgs<'getExpiry'>, name: string, expiry?: Expiry | undefined) => Promise<BigNumber>;

package/dist/esm/utils/wrapperExpiry.js

@@ -0,0 +1,26 @@
+import { BigNumber } from 'ethers';
+export const MAX_EXPIRY = BigNumber.from(2).pow(64).sub(1);
+export const makeExpiry = async ({ getExpiry }, name, 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/dist/esm/utils/writeTx.d.ts

@@ -0,0 +1,4 @@
+import { JsonRpcSigner } from '@ethersproject/providers';
+import type { PopulatedTransaction } from 'ethers';
+declare const _default: (signer: JsonRpcSigner, populate: boolean) => (tx: PopulatedTransaction) => PopulatedTransaction | Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
+export default _default;

package/dist/esm/utils/writeTx.js

@@ -0,0 +1 @@
+export default (signer, populate) => (tx) => populate ? tx : signer.sendTransaction(tx);

package/package.json

@@ -1,57 +1,89 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "2.1.0",
-  "description": "ens.js v2",
-  "main": "dist/index.js",
-  "repository": "ensdomains/ensjs",
+  "version": "3.0.0-alpha.11",
+  "description": "ENS javascript library for contract interaction",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./*": {
+      "default": "./*"
+    }
+  },
   "files": [
-    "dist"
+    "dist/",
+    "src/",
+    "!src/tests"
   ],
+  "repository": "git@github.com:ensdomains/ensjs-v3.git",
+  "author": "TateB <yo@taytems.xyz>",
+  "license": "MIT",
   "scripts": {
-    "test": "jest --verbose",
-    "build": "babel src -d dist --ignore src/**/*.test.js,**/__tests__/**,src/testing-utils",
-    "pub": "yarn build && yarn publish --access public"
+    "env": "yarn ens-test-env",
+    "generate-types": "ts-node scripts/runTypechain.ts",
+    "generate-abis": "hardhat export-abi",
+    "start": "ts-node --files src/index.test.ts",
+    "test": "jest --run-in-band",
+    "test:watch": "jest --watch --run-in-band",
+    "test:specific": "ts-node --files ",
+    "clean": "rm -rf ./dist ./README.md ./LICENSE",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:cjs": "tsc --project tsconfig.cjs.json",
+    "build": "yarn clean && yarn build:esm && yarn build:cjs",
+    "prepublish": "yarn build && cp ../../{README.md,LICENSE} ./",
+    "remove-stableVersion": "ex -c '%s/,\\n\\s\\+\"stableVersion\".*\"//g' -cwq ./package.json",
+    "version:create": "yarn remove-stableVersion && yarn version",
+    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1659500634000"
+  },
+  "packageManager": "yarn@3.2.0",
+  "dependencies": {
+    "@ensdomains/address-encoder": "^0.2.16",
+    "@ensdomains/content-hash": "^2.5.7",
+    "dns-packet": "^5.3.1",
+    "ethers": "^5.6.1",
+    "graphql": "^16.3.0",
+    "graphql-request": "next",
+    "idna-uts46-hx": "3.4.0",
+    "traverse": "^0.6.6"
   },
-  "author": "",
-  "license": "ISC",
   "devDependencies": {
-    "@babel/cli": "^7.4.4",
-    "@babel/core": "^7.4.4",
-    "@babel/plugin-transform-async-to-generator": "^7.4.4",
-    "@babel/plugin-transform-regenerator": "^7.4.4",
-    "@babel/plugin-transform-runtime": "^7.4.4",
-    "@babel/plugin-transform-spread": "^7.2.2",
-    "@babel/polyfill": "^7.4.4",
-    "@babel/preset-env": "^7.4.4",
-    "@ensdomains/mock": "^2.0.37",
-    "babel-eslint": "^9.0.0",
-    "babel-jest": "^23.6.0",
-    "babel-jest-assertions": "^0.1.0",
-    "babel-plugin-add-module-exports": "^1.0.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-preset-env": "^1.7.0",
-    "coveralls": "^3.0.2",
-    "eslint": "^5.6.1",
-    "eslint-config-airbnb-base": "^12.1.0",
-    "eslint-plugin-import": "^2.7.0",
-    "eslint-plugin-node": "^5.1.1",
-    "eslint-plugin-promise": "^3.5.0",
-    "eslint-plugin-react": "^7.1.0",
-    "eslint-plugin-standard": "^3.0.1",
-    "esm": "^3.2.22",
-    "ganache-cli": "^6.4.3",
-    "ganache-core": "^2.11.3",
-    "jest": "^26.4.2",
-    "web3": "^1.7.0"
+    "@ensdomains/buffer": "^0.0.13",
+    "@ensdomains/ens-contracts": "^0.0.12",
+    "@ensdomains/ens-test-env": "0.1.5",
+    "@ethersproject/abi": "^5.6.0",
+    "@ethersproject/providers": "^5.6.2",
+    "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers",
+    "@openzeppelin/contracts": "^4.5.0",
+    "@swc/core": "^1.2.162",
+    "@swc/jest": "^0.2.20",
+    "@typechain/ethers-v5": "^10.1.0",
+    "@types/bn.js": "^5.1.0",
+    "@types/jest": "^27.4.1",
+    "@types/traverse": "^0.6.32",
+    "dotenv": "^16.0.0",
+    "ganache": "^7.4.0",
+    "hardhat": "^2.10.1",
+    "hardhat-abi-exporter": "^2.8.0",
+    "hardhat-deploy": "^0.11.12",
+    "jest": "^27.5.1",
+    "jest-environment-node": "^27.5.1",
+    "jest-localstorage-mock": "^2.4.21",
+    "nock": "^13.2.8",
+    "node-fetch": "^3.2.6",
+    "node-fetch-commonjs": "^3.1.1",
+    "solc": "^0.8.13",
+    "ts-jest": "^27.1.4",
+    "ts-node": "^10.7.0",
+    "typechain": "^8.1.0",
+    "typescript": "^4.6.2",
+    "wait-on": "^6.0.1"
   },
-  "dependencies": {
-    "@babel/runtime": "^7.4.4",
-    "@ensdomains/address-encoder": "^0.1.7",
-    "@ensdomains/ens": "0.4.5",
-    "@ensdomains/resolver": "0.2.4",
-    "content-hash": "^2.5.2",
-    "eth-ens-namehash": "^2.0.8",
-    "ethers": "^5.0.13",
-    "js-sha3": "^0.8.0"
-  }
-}
+  "peerDependencies": {
+    "ethers": "*"
+  },
+  "stableVersion": "3.0.0-alpha.10"
+}

package/src/@types/@ensdomains/content-hash.d.ts

@@ -0,0 +1 @@
+declare module '@ensdomains/content-hash'

package/src/@types/@ensdomains/ens-contracts.d.ts

@@ -0,0 +1 @@
+declare module "@ensdomains/ens-contracts"

package/src/@types/FuseOptions.d.ts

@@ -0,0 +1,9 @@
+export type FuseOptions = {
+  cannotUnwrap: true
+  cannotBurnFuses?: boolean
+  cannotTransfer?: boolean
+  cannotSetResolver?: boolean
+  cannotSetTtl?: boolean
+  cannotCreateSubdomain?: boolean
+  parentCannotControl?: boolean
+}

package/src/@types/dns-packet/index.d.ts

@@ -0,0 +1,114 @@
+declare module 'dns-packet' {
+    const AUTHORITATIVE_ANSWER: number
+    const TRUNCATED_RESPONSE: number
+    const RECURSION_DESIRED: number
+    const RECURSION_AVAILABLE: number
+    const AUTHENTIC_DATA: number
+    const CHECKING_DISABLED: number
+    const DNSSEC_OK: number
+     
+   interface decoder<T> {
+     (buf: Buffer, offset?: number): T
+     bytes: number;
+   }
+ 
+   const decode: decoder<Packet>;
+ 
+   interface encoder<T> {
+     (packet: T, buf?: Buffer, offset?: number): Buffer
+     bytes: number;
+   }
+ 
+   const encode: encoder<Packet>;
+ 
+   interface Packet {
+     id?: number
+     type: 'query' | 'response'
+     flags?: number
+     rcode?: string
+     questions: Question[]
+     answers?: Answer[]
+     authorities?: Answer[]
+     additionals?: Answer[]
+   }
+     
+   interface Question {
+     type: string
+     class: string
+     name: string
+   }
+ 
+   interface AnswerBase {
+     type: string
+     class: string
+     name: string
+     ttl?: number
+   }
+ 
+   interface A extends AnswerBase {
+     type: 'A'
+     data: string
+   }
+ 
+   interface Dnskey extends AnswerBase {
+     type: 'DNSKEY'
+     data: {
+       flags: number
+       algorithm: number
+       key: Buffer
+     }
+   }
+ 
+   interface Ds extends AnswerBase {
+     type: 'DS'
+     data: {
+       keyTag: number
+       algorithm: number
+       digestType: number
+       digest: Buffer
+     }
+   }
+ 
+   interface Opt extends AnswerBase {
+     type: 'OPT'
+     udpPayloadSize?: number
+     extendedRcode?: number
+     ednsVersion?: number
+     flags?: number
+     data?: any
+   }
+ 
+   interface Rrsig extends AnswerBase {
+     type: 'RRSIG'
+     data: {
+       typeCovered: string
+       algorithm: number
+       labels: number
+       originalTTL: number
+       expiration: number
+       inception: number
+       keyTag: number
+       signersName: string
+       signature: Buffer
+     }
+   }
+ 
+   interface Rtxt extends AnswerBase {
+     type: 'TXT'
+     data: Buffer[]
+   }
+ 
+   type Answer = A|Dnskey|Ds|Opt|Rrsig|Rtxt
+ 
+   interface Encodable<T> {
+     decode: decoder<T>
+     encode: encoder<T>
+   }
+ 
+   const record: (type: string) => Encodable<Answer>
+   const answer: Encodable<Answer>
+   const dnskey: Encodable<Dnskey['data']>
+   const name: Encodable<string>
+   const rrsig: Encodable<Rrsig['data']>
+ }
+ 

package/src/@types/dns-packet.d.ts

@@ -0,0 +1 @@
+declare module 'dns-packet'

package/src/@types/idna-uts46-hx.d.ts

@@ -0,0 +1 @@
+declare module 'idna-uts46-hx/uts46bundle.js'