@ensdomains/ensjs 3.0.0-alpha.24 → 3.0.0-alpha.25

package/dist/cjs/contracts/dnsRegistrar.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dnsRegistrar_exports = {};
+__export(dnsRegistrar_exports, {
+  default: () => dnsRegistrar_default
+});
+module.exports = __toCommonJS(dnsRegistrar_exports);
+var import_DNSRegistrar_factory = require("../generated/factories/DNSRegistrar__factory");
+var dnsRegistrar_default = (provider, address) => import_DNSRegistrar_factory.DNSRegistrar__factory.connect(address, provider);

package/dist/cjs/contracts/getContractAddress.js

@@ -28,6 +28,11 @@ const addresses = {
     "4": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
     "5": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85"
   },
+  DNSRegistrar: {
+    "1": "0x58774Bb8acD458A640aF0B88238369A167546ef2",
+    "3": "0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F",
+    "5": "0x8edc487D26F6c8Fa76e032066A3D4F87E273515d"
+  },
   ETHRegistrarController: {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",

package/dist/cjs/contracts/index.js

@@ -31,6 +31,7 @@ var import_baseRegistrar = __toESM(require("./baseRegistrar"));
 var import_ethRegistrarController = __toESM(require("./ethRegistrarController"));
 var import_multicall = __toESM(require("./multicall"));
 var import_nameWrapper = __toESM(require("./nameWrapper"));
+var import_dnsRegistrar = __toESM(require("./dnsRegistrar"));
 var import_publicResolver = __toESM(require("./publicResolver"));
 var import_registry = __toESM(require("./registry"));
 var import_reverseRegistrar = __toESM(require("./reverseRegistrar"));
@@ -70,6 +71,10 @@ class ContractManager {
     "NameWrapper",
     import_nameWrapper.default
   );
+  getDNSRegistrar = this.generateContractGetter(
+    "DNSRegistrar",
+    import_dnsRegistrar.default
+  );
   getBaseRegistrar = this.generateContractGetter(
     "BaseRegistrarImplementation",
     import_baseRegistrar.default

package/dist/cjs/functions/batchWrappers.js

@@ -94,8 +94,8 @@ const multicallWrapper = {
         data
       );
       return result;
-    } catch {
-      return;
+    } catch (e) {
+      return e;
     }
   }
 };

package/dist/cjs/functions/importDNSSECName.js

@@ -0,0 +1,65 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var importDNSSECName_exports = {};
+__export(importDNSSECName_exports, {
+  DNS_OVER_HTTP_ENDPOINT: () => DNS_OVER_HTTP_ENDPOINT,
+  default: () => importDNSSECName_default
+});
+module.exports = __toCommonJS(importDNSSECName_exports);
+var import_dnssecoraclejs = require("@ensdomains/dnssecoraclejs");
+var import_dns_packet = __toESM(require("dns-packet"));
+var import_consts = require("../utils/consts");
+const DNS_OVER_HTTP_ENDPOINT = "https://1.1.1.1/dns-query";
+async function importDNSSECName_default({ contracts, provider }, name, { address, proverResult }) {
+  const dnsRegistrarContract = await contracts?.getDNSRegistrar();
+  const resolverContract = await contracts?.getPublicResolver();
+  const registrarOracle = await dnsRegistrarContract?.oracle();
+  if (!registrarOracle) {
+    throw new Error("No oracle found");
+  }
+  const oracle = new import_dnssecoraclejs.Oracle(registrarOracle, provider);
+  const proofData = await oracle.getProofData(proverResult);
+  const encodedName = `0x${import_dns_packet.default.name.encode(name).toString("hex")}`;
+  const data = proofData.rrsets.map(
+    (x) => Object.values(x)
+  );
+  const { proof } = proofData;
+  if (address === import_consts.EMPTY_ADDRESS) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaim(
+      encodedName,
+      data,
+      proof
+    );
+  }
+  if (address) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaimWithResolver(
+      encodedName,
+      data,
+      proof,
+      resolverContract.address,
+      address
+    );
+  }
+}

package/dist/cjs/index.js

@@ -304,6 +304,10 @@ class ENS {
   burnFuses = this.generateWriteFunction("burnFuses", [
     "contracts"
   ]);
+  importDNSSECName = this.generateWriteFunction(
+    "importDNSSECName",
+    ["contracts", "provider", "signer"]
+  );
   createSubname = this.generateWriteFunction(
     "createSubname",
     ["contracts", "getExpiry"]

package/dist/cjs/utils/consts.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var consts_exports = {};
+__export(consts_exports, {
+  EMPTY_ADDRESS: () => EMPTY_ADDRESS
+});
+module.exports = __toCommonJS(consts_exports);
+const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";

package/dist/esm/contracts/dnsRegistrar.mjs

@@ -0,0 +1,6 @@
+// src/contracts/dnsRegistrar.ts
+import { DNSRegistrar__factory } from "../generated/factories/DNSRegistrar__factory.mjs";
+var dnsRegistrar_default = (provider, address) => DNSRegistrar__factory.connect(address, provider);
+export {
+  dnsRegistrar_default as default
+};

package/dist/esm/contracts/getContractAddress.mjs

@@ -6,6 +6,11 @@ var addresses = {
     "4": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85",
     "5": "0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85"
   },
+  DNSRegistrar: {
+    "1": "0x58774Bb8acD458A640aF0B88238369A167546ef2",
+    "3": "0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F",
+    "5": "0x8edc487D26F6c8Fa76e032066A3D4F87E273515d"
+  },
   ETHRegistrarController: {
     "1": "0x283af0b28c62c092c9727f1ee09c02ca627eb7f5",
     "3": "0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8",

package/dist/esm/contracts/index.mjs

@@ -3,6 +3,7 @@ import getBaseRegistrar from "./baseRegistrar.mjs";
 import getEthRegistrarController from "./ethRegistrarController.mjs";
 import getMulticall from "./multicall.mjs";
 import getNameWrapper from "./nameWrapper.mjs";
+import getDNSRegistrar from "./dnsRegistrar.mjs";
 import getPublicResolver from "./publicResolver.mjs";
 import getRegistry from "./registry.mjs";
 import getReverseRegistrar from "./reverseRegistrar.mjs";
@@ -42,6 +43,10 @@ var ContractManager = class {
     "NameWrapper",
     getNameWrapper
   );
+  getDNSRegistrar = this.generateContractGetter(
+    "DNSRegistrar",
+    getDNSRegistrar
+  );
   getBaseRegistrar = this.generateContractGetter(
     "BaseRegistrarImplementation",
     getBaseRegistrar

package/dist/esm/functions/batchWrappers.mjs

@@ -70,8 +70,8 @@ var multicallWrapper = {
         data
       );
       return result;
-    } catch {
-      return;
+    } catch (e) {
+      return e;
     }
   }
 };

package/dist/esm/functions/importDNSSECName.mjs

@@ -0,0 +1,40 @@
+// src/functions/importDNSSECName.ts
+import { Oracle as NewOracle } from "@ensdomains/dnssecoraclejs";
+import packet from "dns-packet";
+import { EMPTY_ADDRESS } from "../utils/consts.mjs";
+var DNS_OVER_HTTP_ENDPOINT = "https://1.1.1.1/dns-query";
+async function importDNSSECName_default({ contracts, provider }, name, { address, proverResult }) {
+  const dnsRegistrarContract = await contracts?.getDNSRegistrar();
+  const resolverContract = await contracts?.getPublicResolver();
+  const registrarOracle = await dnsRegistrarContract?.oracle();
+  if (!registrarOracle) {
+    throw new Error("No oracle found");
+  }
+  const oracle = new NewOracle(registrarOracle, provider);
+  const proofData = await oracle.getProofData(proverResult);
+  const encodedName = `0x${packet.name.encode(name).toString("hex")}`;
+  const data = proofData.rrsets.map(
+    (x) => Object.values(x)
+  );
+  const { proof } = proofData;
+  if (address === EMPTY_ADDRESS) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaim(
+      encodedName,
+      data,
+      proof
+    );
+  }
+  if (address) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaimWithResolver(
+      encodedName,
+      data,
+      proof,
+      resolverContract.address,
+      address
+    );
+  }
+}
+export {
+  DNS_OVER_HTTP_ENDPOINT,
+  importDNSSECName_default as default
+};

package/dist/esm/index.mjs

@@ -276,6 +276,10 @@ var ENS = class {
   burnFuses = this.generateWriteFunction("burnFuses", [
     "contracts"
   ]);
+  importDNSSECName = this.generateWriteFunction(
+    "importDNSSECName",
+    ["contracts", "provider", "signer"]
+  );
   createSubname = this.generateWriteFunction(
     "createSubname",
     ["contracts", "getExpiry"]

package/dist/esm/utils/consts.mjs

@@ -0,0 +1,5 @@
+// src/utils/consts.ts
+var EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export {
+  EMPTY_ADDRESS
+};

package/dist/types/contracts/dnsRegistrar.d.ts

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

package/dist/types/contracts/index.d.ts

@@ -10,6 +10,7 @@ export default class ContractManager {
     getRegistry: (passedProvider?: any, address?: string) => Promise<import("../generated/ENSRegistry").ENSRegistry>;
     getReverseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/ReverseRegistrar").ReverseRegistrar>;
     getNameWrapper: (passedProvider?: any, address?: string) => Promise<import("../generated/NameWrapper").NameWrapper>;
+    getDNSRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/DNSRegistrar").DNSRegistrar>;
     getBaseRegistrar: (passedProvider?: any, address?: string) => Promise<import("../generated/BaseRegistrarImplementation").BaseRegistrarImplementation>;
     getEthRegistrarController: (passedProvider?: any, address?: string) => Promise<import("../generated/ETHRegistrarController").ETHRegistrarController>;
     getMulticall: (passedProvider?: any, address?: string) => Promise<import("../generated/Multicall").Multicall>;

package/dist/types/contracts/types.d.ts

@@ -1,2 +1,2 @@
 export declare type SupportedNetworkId = '1' | '3' | '4' | '5' | '1337';
-export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver' | 'BulkRenewal';
+export declare type ContractName = 'BaseRegistrarImplementation' | 'ETHRegistrarController' | 'Multicall' | 'NameWrapper' | 'DNSRegistrar' | 'PublicResolver' | 'ENSRegistryWithFallback' | 'ReverseRegistrar' | 'UniversalResolver' | 'BulkRenewal';

package/dist/types/functions/importDNSSECName.d.ts

@@ -0,0 +1,7 @@
+import type { ENSArgs } from '..';
+export declare const DNS_OVER_HTTP_ENDPOINT = "https://1.1.1.1/dns-query";
+export declare type ImportDNSSECNameProps = {
+    address: string;
+    proverResult: any;
+};
+export default function ({ contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>, name: string, { address, proverResult }: ImportDNSSECNameProps): Promise<import("ethers").PopulatedTransaction | undefined>;

package/dist/types/index.d.ts

@@ -19,6 +19,7 @@ import type transferSubname from './functions/transferSubname';
 import type unwrapName from './functions/unwrapName';
 import type wrapName from './functions/wrapName';
 import GqlManager from './GqlManager';
+import importDNSSECName from './functions/importDNSSECName';
 export type { Fuse, FuseArrayPossibilities, FuseObj, NamedFusesToBurn, UnnamedFuseType, UnnamedFuseValues, } from './utils/fuses';
 declare type ENSOptions = {
     graphURI?: string | null;
@@ -448,6 +449,7 @@ export declare class ENS {
     wrapName: WriteFunction<typeof wrapName>;
     unwrapName: WriteFunction<typeof unwrapName>;
     burnFuses: WriteFunction<typeof burnFuses>;
+    importDNSSECName: WriteFunction<typeof importDNSSECName>;
     createSubname: WriteFunction<typeof createSubname>;
     deleteSubname: WriteFunction<typeof deleteSubname>;
     transferSubname: WriteFunction<typeof transferSubname>;

package/dist/types/utils/consts.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_ADDRESS = "0x0000000000000000000000000000000000000000";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.24",
+  "version": "3.0.0-alpha.25",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -54,6 +54,8 @@
   "dependencies": {
     "@ensdomains/address-encoder": "0.2.16",
     "@ensdomains/content-hash": "^2.5.7",
+    "@ensdomains/dnsprovejs": "^0.4.1",
+    "@ensdomains/dnssecoraclejs": "^0.2.7",
     "dns-packet": "^5.3.1",
     "ethers": "^5.6.1",
     "graphql": "^16.3.0",
@@ -114,7 +116,7 @@
     "build:types": "tsc --emitDeclarationOnly --project tsconfig.build.json",
     "build": "pnpm clean && pnpm lint && pnpm build:types && pnpm node esbuild.js",
     "prepublish": "pnpm build && cp ../../README.md ../../LICENSE ./",
-    "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",
+    "enode": "ganache --wallet.mnemonic=\"test test test test test test test test test test test junk\" --chain.chainId 1337 --chain.networkId 1337 --chain.time 1663311099000",
     "ver": "pnpm version --no-workspaces-update"
   }
 }

package/src/contracts/dnsRegistrar.ts

@@ -0,0 +1,5 @@
+import { ethers } from 'ethers'
+import { DNSRegistrar__factory } from '../generated/factories/DNSRegistrar__factory'
+
+export default (provider: ethers.providers.JsonRpcProvider, address: string) =>
+  DNSRegistrar__factory.connect(address, provider)

package/src/contracts/getContractAddress.ts

@@ -11,6 +11,11 @@ const addresses: Record<
     '4': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
     '5': '0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85',
   },
+  DNSRegistrar: {
+    '1': '0x58774Bb8acD458A640aF0B88238369A167546ef2',
+    '3': '0xdB328BA5FEcb432AF325Ca59E3778441eF5aa14F',
+    '5': '0x8edc487D26F6c8Fa76e032066A3D4F87E273515d',
+  },
   ETHRegistrarController: {
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',

package/src/contracts/index.ts

@@ -4,6 +4,7 @@ import getEthRegistrarController from './ethRegistrarController'
 import { ContractAddressFetch } from './getContractAddress'
 import getMulticall from './multicall'
 import getNameWrapper from './nameWrapper'
+import getDNSRegistrar from './dnsRegistrar'
 import getPublicResolver from './publicResolver'
 import getRegistry from './registry'
 import getReverseRegistrar from './reverseRegistrar'
@@ -63,6 +64,11 @@ export default class ContractManager {
     getNameWrapper,
   )
 
+  public getDNSRegistrar = this.generateContractGetter(
+    'DNSRegistrar',
+    getDNSRegistrar,
+  )
+
   public getBaseRegistrar = this.generateContractGetter(
     'BaseRegistrarImplementation',
     getBaseRegistrar,

package/src/contracts/types.ts

@@ -5,6 +5,7 @@ export type ContractName =
   | 'ETHRegistrarController'
   | 'Multicall'
   | 'NameWrapper'
+  | 'DNSRegistrar'
   | 'PublicResolver'
   | 'ENSRegistryWithFallback'
   | 'ReverseRegistrar'

package/src/functions/batchWrappers.ts

@@ -84,8 +84,8 @@ export const multicallWrapper = {
         data,
       )
       return result
-    } catch {
-      return
+    } catch (e) {
+      return e
     }
   },
 }

package/src/functions/importDNSSECName.ts

@@ -0,0 +1,54 @@
+import { Oracle as NewOracle } from '@ensdomains/dnssecoraclejs'
+import packet from 'dns-packet'
+import type { ENSArgs } from '..'
+import { EMPTY_ADDRESS } from '../utils/consts'
+
+export const DNS_OVER_HTTP_ENDPOINT = 'https://1.1.1.1/dns-query'
+
+export type ImportDNSSECNameProps = {
+  address: string
+  proverResult: any
+}
+
+export default async function (
+  { contracts, provider }: ENSArgs<'contracts' | 'signer' | 'provider'>,
+  name: string,
+  { address, proverResult }: ImportDNSSECNameProps,
+) {
+  const dnsRegistrarContract = await contracts?.getDNSRegistrar()
+  const resolverContract = await contracts?.getPublicResolver()
+  const registrarOracle = await dnsRegistrarContract?.oracle()
+
+  if (!registrarOracle) {
+    throw new Error('No oracle found')
+  }
+
+  const oracle = new NewOracle(registrarOracle, provider!)
+  const proofData = await oracle.getProofData(proverResult)
+  const encodedName = `0x${packet.name.encode(name).toString('hex')}`
+  const data = proofData.rrsets.map((x) =>
+    Object.values(x),
+  ) as unknown as Array<{
+    rrset: string
+    sig: string
+  }>
+  const { proof } = proofData
+
+  if (address === EMPTY_ADDRESS) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaim(
+      encodedName,
+      data,
+      proof,
+    )
+  }
+
+  if (address) {
+    return dnsRegistrarContract?.populateTransaction.proveAndClaimWithResolver(
+      encodedName,
+      data,
+      proof,
+      resolverContract!.address,
+      address,
+    )
+  }
+}

package/src/index.ts

@@ -51,6 +51,7 @@ import type wrapName from './functions/wrapName'
 import GqlManager from './GqlManager'
 import singleCall from './utils/singleCall'
 import writeTx from './utils/writeTx'
+import importDNSSECName from './functions/importDNSSECName'
 
 export type {
   Fuse,
@@ -591,6 +592,11 @@ export class ENS {
     'contracts',
   ])
 
+  public importDNSSECName = this.generateWriteFunction<typeof importDNSSECName>(
+    'importDNSSECName',
+    ['contracts', 'provider', 'signer'],
+  )
+
   public createSubname = this.generateWriteFunction<typeof createSubname>(
     'createSubname',
     ['contracts', 'getExpiry'],

package/src/utils/consts.ts

@@ -0,0 +1 @@
+export const EMPTY_ADDRESS = '0x0000000000000000000000000000000000000000'