small cleanups

lib/modules/ens/embarkjs.js

@@ -153,6 +153,8 @@ __embarkENS.setProvider = function (config) {
   self.registration = config.registration;
   self.env = config.env;
   EmbarkJS.onReady(() => {
+    self.registration = config.registration;
+
     web3.eth.net.getId()
       .then((id) => {
       const registryAddress = self.registryAddresses[id] || config.registryAddress;

lib/modules/ens/index.js

@@ -2,29 +2,17 @@ const fs = require('../../core/fs.js');
 const utils = require('../../utils/utils.js');
 const namehash = require('eth-ens-namehash');
 const async = require('async');
-const embarkJsUtils = require('embarkjs').Utils;
+
 const reverseAddrSuffix = '.addr.reverse';
 
 class ENS {
   constructor(embark, _options) {
-    this.env = embark.env;
-    this.isDev = embark.config.blockchainConfig.isDev;
     this.logger = embark.logger;
     this.events = embark.events;
     this.namesConfig = embark.config.namesystemConfig;
     this.registration = this.namesConfig.register || {};
     this.embark = embark;
 
-<<<<<<< HEAD
-    if (this.namesConfig === {} ||
-      this.namesConfig.enabled !== true ||
-      this.namesConfig.available_providers.indexOf('ens') < 0) {
-      return;
-    }
-    this.doSetENSProvider = this.namesConfig.provider === 'ens';
-
-=======
->>>>>>> if no register config, dont register anything
     this.addENSToEmbarkJS();
     this.configureContracts();
     this.registerEvents();
@@ -75,124 +63,26 @@ class ENS {
 
       if (self.doSetENSProvider) {
         self.addSetProvider(config);
-      }
 
-<<<<<<< HEAD
-      if ((!self.isDev && self.env !== 'privatenet') || !self.registration || !self.registration.subdomains || !Object.keys(self.registration.subdomains).length) {
-        return cb();
-      }
-      self.registerConfigDomains(config, cb);
-=======
         if (!self.registration || !self.registration.subdomains || !Object.keys(self.registration.subdomains).length) {
           return cb();
         }
         self.registerConfigDomains(config, cb);
       });
->>>>>>> if no register config, dont register anything
     });
   }
 
-  associateStorageToEns(options, cb) {
-    const self = this;
-    // Code inspired by https://github.com/monkybrain/ipfs-to-ens
-    const {name, storageHash} = options;
-
-    if (!utils.isValidEthDomain(name)) {
-      return cb('Invalid domain name ' + name);
-    }
-
-    let hashedName = namehash.hash(name);
-    let contentHash;
-    try {
-      contentHash = utils.hashTo32ByteHexString(storageHash);
-    } catch (e) {
-      return cb('Invalid IPFS hash');
-    }
-
-    // Set content
-    async.waterfall([
-      function getRegistryABI(next) {
-        self.events.request('contracts:contract', "ENSRegistry", (contract) => {
-          next(null, contract);
-        });
-      },
-      function createRegistryContract(contract, next) {
-        self.events.request("blockchain:contract:create",
-          {abi: contract.abiDefinition, address: contract.deployedAddress},
-          (resolver) => {
-            next(null, resolver);
-          });
-      },
-      function getResolverForName(registry, next) {
-        registry.methods.resolver(hashedName).call((err, resolverAddress) => {
-          if (err) {
-            return cb(err);
-          }
-          if (resolverAddress === '0x0000000000000000000000000000000000000000') {
-            return cb('Name not yet registered');
-          }
-          next(null, resolverAddress);
-        });
-      },
-      function getResolverABI(resolverAddress, next) {
-        self.events.request('contracts:contract', "Resolver", (contract) => {
-          next(null, resolverAddress, contract);
-        });
-      },
-      function createResolverContract(resolverAddress, contract, next) {
-        self.events.request("blockchain:contract:create",
-          {abi: contract.abiDefinition, address: resolverAddress},
-          (resolver) => {
-            next(null, resolver);
-          });
-      },
-      function getDefaultAccount(resolver, next) {
-        self.events.request("blockchain:defaultAccount:get", (defaultAccount) => {
-          next(null, resolver, defaultAccount);
-        });
-      },
-      function setContent(resolver, defaultAccount, next) {
-        resolver.methods.setContent(hashedName, contentHash).send({from: defaultAccount}).then((transaction) => {
-          if (transaction.status !== "0x1" && transaction.status !== "0x01" && transaction.status !== true) {
-            return next('Association failed. Status: ' + transaction.status);
-          }
-          next();
-        }).catch(next);
-      }
-    ], cb);
-  }
-
   registerConfigDomains(config, cb) {
     const self = this;
     const register = require('./register');
     const secureSend = embarkJsUtils.secureSend;
     self.events.request("blockchain:defaultAccount:get", (defaultAccount) => {
-<<<<<<< HEAD
       async.parallel([
         function createRegistryContract(paraCb) {
           self.events.request("blockchain:contract:create",
             {abi: config.registryAbi, address: config.registryAddress},
             (registry) => {
               paraCb(null, registry);
-=======
-      self.events.request("blockchain:contract:create",
-        {abi: config.registrarAbi, address: config.registrarAddress},
-        (registrar) => {
-          async.each(Object.keys(self.registration.subdomains), (subDomainName, eachCb) => {
-            const toSend = registrar.methods.register(utils.soliditySha3(subDomainName), defaultAccount);
-
-            toSend.estimateGas().then(gasEstimated => {
-              return toSend.send({gas: gasEstimated + 1000, from: defaultAccount}).then(transaction => {
-                if (transaction.status !== "0x1" && transaction.status !== "0x01" && transaction.status !== true) {
-                  return eachCb('Failed to register. Check gas cost.');
-                }
-                eachCb(null, transaction);
-              }).catch(err => {
-                eachCb('Failed to register with error: ' + (err.message || err));
-              });
-            }).catch(err => {
-              eachCb("Register would error. Is it already registered? Do you have token balance? Is Allowance set? " + (err.message || err));
->>>>>>> if no register config, dont register anything
             });
         },
         function createRegistrarContract(paraCb) {
@@ -228,12 +118,20 @@ class ENS {
 
   addENSToEmbarkJS() {
     const self = this;
+    // TODO: make this a shouldAdd condition
+    if (this.namesConfig === {}) {
+      return;
+    }
+
+    if ((this.namesConfig.available_providers.indexOf('ens') < 0) && (this.namesConfig.provider !== 'ens' || this.namesConfig.enabled !== true)) {
+      return;
+    }
 
     // get namehash, import it into file
-    self.events.request("version:get:eth-ens-namehash", function(EnsNamehashVersion) {
+    self.events.request("version:get:eth-ens-namehash", function (EnsNamehashVersion) {
       let currentEnsNamehashVersion = require('../../../package.json').dependencies["eth-ens-namehash"];
       if (EnsNamehashVersion !== currentEnsNamehashVersion) {
-        self.events.request("version:getPackageLocation", "eth-ens-namehash", EnsNamehashVersion, function(err, location) {
+        self.events.request("version:getPackageLocation", "eth-ens-namehash", EnsNamehashVersion, function (err, location) {
           self.embark.registerImportFile("eth-ens-namehash", fs.dappPath(location));
         });
       }
@@ -259,12 +157,10 @@ class ENS {
           },
           "ENSRegistry": {
             "deploy": true,
-            "silent": true,
             "args": []
           },
           "Resolver": {
             "deploy": true,
-            "silent": true,
             "args": ["$ENSRegistry"]
           },
           "FIFSRegistrar": {
@@ -275,11 +171,7 @@ class ENS {
       "ropsten": {
         "contracts": {
           "ENSRegistry": {
-            "address": "0x112234455c3a32fd11230c42e7bccd4a84e02010",
+            "address": "0x112234455c3a32fd11230c42e7bccd4a84e02010"
-            "silent": true
-          },
-          "Resolver": {
-            "deploy": false
           },
           "Resolver": {
             "deploy": false
@@ -292,11 +184,7 @@ class ENS {
       "rinkeby": {
         "contracts": {
           "ENSRegistry": {
-            "address": "0xe7410170f87102DF0055eB195163A03B7F2Bff4A",
+            "address": "0xe7410170f87102DF0055eB195163A03B7F2Bff4A"
-            "silent": true
-          },
-          "Resolver": {
-            "deploy": false
           },
           "Resolver": {
             "deploy": false
@@ -309,11 +197,7 @@ class ENS {
       "livenet": {
         "contracts": {
           "ENSRegistry": {
-            "address": "0x314159265dd8dbb310642f98f50c066173c1259b",
+            "address": "0x314159265dd8dbb310642f98f50c066173c1259b"
-            "silent": true
-          },
-          "Resolver": {
-            "deploy": false
           },
           "Resolver": {
             "deploy": false
@@ -324,9 +208,6 @@ class ENS {
         }
       }
     };
-<<<<<<< HEAD
-    config.testnet = config.ropsten;
-=======
 
     if (this.registration && this.registration.rootDomain) {
       // Register root domain if it is defined
@@ -337,7 +218,7 @@ class ENS {
         "onDeploy": [
           `ENSRegistry.methods.setOwner('${rootNode}', web3.eth.defaultAccount).send().then(() => {
               ENSRegistry.methods.setResolver('${rootNode}', "$Resolver").send();
-              var reverseNode = web3.utils.soliditySha3(web3.eth.defaultAccount.toLowerCase().substr(2) + '.addr.reverse');
+              var reverseNode = web3.utils.soliditySha3(web3.eth.defaultAccount.toLowerCase().substr(2) + '${reverseAddrSuffix}');
               ENSRegistry.methods.setResolver(reverseNode, "$Resolver").send();
               Resolver.methods.setAddr('${rootNode}', web3.eth.defaultAccount).send();
               Resolver.methods.setName(reverseNode, '${this.registration.rootDomain}').send();
@@ -347,7 +228,6 @@ class ENS {
     }
 
     this.embark.registerContractConfiguration(config);
->>>>>>> if no register config, dont register anything
 
     if (this.registration && this.registration.rootDomain) {
       // Register root domain if it is defined

test_apps/test_app/test/ens_spec.js

@@ -17,28 +17,22 @@ config({
       "args": ["$ENSRegistry", rootNode],
       "onDeploy": [
         `ENSRegistry.methods.setOwner('${rootNode}', web3.eth.defaultAccount).send().then(() => {
-          ENSRegistry.methods.setResolver('${rootNode}', "$Resolver").send();
+              ENSRegistry.methods.setResolver('${rootNode}', "$Resolver").send();
-          Resolver.methods.setAddr('${rootNode}', '${address}').send().then(() => {
+              Resolver.methods.setAddr('${rootNode}', '${address}').send();
-            global.ensTestReady = true;
+              })`
-          });
-        });`
       ]
     }
   }
 });
 
 contract("ENS", function () {
-  this.timeout(1000);
+  this.timeout(0);
 
   before(function (done) {
   //   Wait for onDeploy to finish
-    const wait = setInterval(() => {
+    setTimeout(function () {
-      if (!global.ensTestReady) {
-        return;
-      }
-      clearInterval(wait);
       done();
-    }, 50);
+    }, 500);
   });
 
   it("should have registered embark.eth", async function () {