fix(@embark/ens): fix Infura connection and testnet use of ENS

dapps/tests/app/test/token_spec.js

@@ -8,6 +8,12 @@ const Test = require('Embark/contracts/Test');
 const SomeContract = require('Embark/contracts/SomeContract');
 
 config({
+  namesystem: {
+    enabled: true,
+    register: {
+      rootDomain: "embark.eth"
+    }
+  },
   contracts: {
     deploy: {
       ZAMyLib: {},

packages/embarkjs/ens/src/ENSFunctions.js

@@ -1,4 +1,3 @@
-/* global require */
 const namehash = require('eth-ens-namehash');
 
 // Price of ENS registration contract functions

packages/embarkjs/ens/src/index.js

@@ -1,10 +1,9 @@
-/* global global require */
+/* global ethereum*/
 import { reduce } from 'async';
 let EmbarkJS = global.EmbarkJS || require('embarkjs');
 EmbarkJS = EmbarkJS.default || EmbarkJS;
 const ENSFunctions = require('./ENSFunctions').default;
 const Web3 = require('web3');
-const { RequestManager } = require('web3-core-requestmanager');
 const namehash = require('eth-ens-namehash');
 
 const __embarkENS = {};
@@ -175,7 +174,7 @@ async function connectWeb3(web3, callback) {
     try {
       await ethereum.enable();
       web3.setProvider(ethereum);
-      return checkConnect(callback);
+      return checkConnection(callback);
     } catch (e) {
       return callback(null, {
         error: e,
@@ -204,48 +203,45 @@ function checkConnection(web3, callback) {
 __embarkENS.web3 = new Web3();
 
 __embarkENS.setProvider = function(config) {
-  const self = this;
   const ERROR_MESSAGE = 'ENS is not available in this chain';
-  self.registration = config.registration;
-  self.env = config.env;
-  self.ready = false;
-
-  let connectionErrors = {};
+  this.registration = config.registration;
+  this.env = config.env;
+  this.ready = false;
 
   reduce(config.dappConnection, false, (result, connectionString, next) => {
     if (result.connected) {
       return next(null, result);
     }
 
     if (connectionString === '$WEB3') {
-      connectWeb3(self.web3, next);
+      connectWeb3(this.web3, next);
     } else if ((/^wss?:\/\//).test(connectionString)) {
-      connectWebSocket(self.web3, connectionString, next);
+      connectWebSocket(this.web3, connectionString, next);
     } else {
-      connectHttp(self.web3, connectionString, next);
+      connectHttp(this.web3, connectionString, next);
     }
   }, async (err, result) => {
-    if (!result.connected || result.error) {
+    if (result.error) {
       console.error(result.error);
     }
     try {
-      const accounts = await self.web3.eth.getAccounts();
-      self.web3.eth.defaultAccount = accounts[0];
-      const id = await self.web3.eth.net.getId()
-      const registryAddress = self.registryAddresses[id] || config.registryAddress;
-      self._isAvailable = true;
-      self.ens = new self.web3.eth.Contract(config.registryAbi, registryAddress);
-      self.registrar = new self.web3.eth.Contract(config.registrarAbi, config.registrarAddress);
-      self.resolver = new self.web3.eth.Contract(config.resolverAbi, config.resolverAddress);
-      self.ready = true;
-    } catch (err) {
-      self.ready = true;
-      if (err.message.indexOf('Provider not set or invalid') > -1) {
+      const accounts = await this.web3.eth.getAccounts();
+      this.web3.eth.defaultAccount = accounts[0];
+      const id = await this.web3.eth.net.getId();
+      const registryAddress = this.registryAddresses[id] || config.registryAddress;
+      this._isAvailable = true;
+      this.ens = new this.web3.eth.Contract(config.registryAbi, registryAddress);
+      this.registrar = new this.web3.eth.Contract(config.registrarAbi, config.registrarAddress);
+      this.resolver = new this.web3.eth.Contract(config.resolverAbi, config.resolverAddress);
+      this.ready = true;
+    } catch (e) {
+      this.ready = true;
+      if (e.message.indexOf('Provider not set or invalid') > -1) {
         console.warn(ERROR_MESSAGE);
         return;
       }
-      console.error(err);
-    };
+      console.error(e);
+    }
   });
 };
 

packages/plugins/ens/src/index.js

@@ -89,7 +89,7 @@ class ENS {
   }
 
   async init(cb = () => {}) {
-    if (this.initated || this.config.namesystemConfig === {} ||
+    if (this.initated ||
       this.config.namesystemConfig.enabled !== true ||
       !this.config.namesystemConfig.available_providers ||
       this.config.namesystemConfig.available_providers.indexOf('ens') < 0) {
@@ -277,18 +277,17 @@ class ENS {
       return cb();
     }
     const web3 = await this.web3;
-    
+
     const networkId = await web3.eth.net.getId();
-
-
+
     if (ensContractAddresses[networkId]) {
       if (this.config.namesystemConfig.register && this.config.namesystemConfig.register.rootDomain) {
         this.logger.warn(__("Cannot register subdomains on this network, because we do not own the ENS contracts. Are you on testnet or mainnet?"));
       }
       this.config.namesystemConfig.register = false; // force subdomains from being registered
       this.ensConfig = recursiveMerge(this.ensConfig, ensContractAddresses[networkId]);
     }
-    
+
     const registration = this.config.namesystemConfig.register;
     const doRegister = registration && registration.rootDomain;
 
@@ -298,6 +297,16 @@ class ENS {
     this.ensConfig.Resolver = await this.events.request2('contracts:add', this.ensConfig.Resolver);
     await this.events.request2('deployment:contract:deploy', this.ensConfig.Resolver);
 
+    const config = {
+      registryAbi: self.ensConfig.ENSRegistry.abiDefinition,
+      registryAddress: self.ensConfig.ENSRegistry.deployedAddress,
+      resolverAbi: self.ensConfig.Resolver.abiDefinition,
+      resolverAddress: self.ensConfig.Resolver.deployedAddress
+    };
+
+    self.ensContract = new web3.eth.Contract(config.registryAbi, config.registryAddress);
+    self.resolverContract = new web3.eth.Contract(config.resolverAbi, config.resolverAddress);
+
     async.waterfall([
       function checkRootNode(next) {
         if (!doRegister) {
@@ -317,25 +326,15 @@ class ENS {
         self.events.request('contracts:add', self.ensConfig.FIFSRegistrar, (_err, contract) => {
           self.ensConfig.FIFSRegistrar = contract;
           self.events.request('deployment:contract:deploy', self.ensConfig.FIFSRegistrar, (err) => {
+            config.registrarAbi = self.ensConfig.FIFSRegistrar.abiDefinition;
+            config.registrarAddress = self.ensConfig.FIFSRegistrar.deployedAddress;
+            self.registrarContract = new web3.eth.Contract(config.registrarAbi, config.registrarAddress);
             return next(err);
           });
         });
       },
       function registerRoot(next) {
-        let config = {
-          registryAbi: self.ensConfig.ENSRegistry.abiDefinition,
-          registryAddress: self.ensConfig.ENSRegistry.deployedAddress,
-          registrarAbi: self.ensConfig.FIFSRegistrar.abiDefinition,
-          registrarAddress: self.ensConfig.FIFSRegistrar.deployedAddress,
-          resolverAbi: self.ensConfig.Resolver.abiDefinition,
-          resolverAddress: self.ensConfig.Resolver.deployedAddress
-        };
-
         async function send() {
-          self.ensContract = new web3.eth.Contract(config.registryAbi, config.registryAddress);
-          self.registrarContract = new web3.eth.Contract(config.registrarAbi, config.registrarAddress);
-          self.resolverContract = new web3.eth.Contract(config.resolverAbi, config.resolverAddress);
-
           const defaultAccount = await self.web3DefaultAccount;
 
           const rootNode = namehash.hash(registration.rootDomain);

packages/stack/embarkjs/src/index.js

@@ -117,13 +117,18 @@ class EmbarkJS {
     let code = "";
     if (stackName === 'storage') {
       code = `EmbarkJS.${moduleName}.setProviders(${JSON.stringify(config)});`;
-    } else if (stackName === 'blockchain') {
+    } else if (stackName === 'blockchain' || stackName === 'names') {
       const endpoint = await this.events.request2("proxy:endpoint:get");
       const dappConnectionConfig = {
         dappConnection: [endpoint]
       };
-      code = `EmbarkJS.${moduleName}.setProvider('${pluginName}', ${config});
+      if (stackName === 'blockchain') {
+        code = `EmbarkJS.${moduleName}.setProvider('${pluginName}', ${config});
               EmbarkJS.Blockchain.connect(${JSON.stringify(dappConnectionConfig)}, (err) => {if (err) { console.error(err); } });`;
+      } else {
+        code = `EmbarkJS.${moduleName}.setProvider('${pluginName}', ${JSON.stringify(Object.assign(config, dappConnectionConfig))});`;
+      }
+
     } else {
       code = `EmbarkJS.${moduleName}.setProvider('${pluginName}', ${JSON.stringify(config)});`;
     }