Test branch

.babelrc

@@ -0,0 +1,12 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": true
+        }
+      }
+    ]
+  ]
+}

auth/permission/contracts/EventLogType.sol

@@ -0,0 +1,9 @@
+contract EventLogType {
+  // event log type
+  enum EventLogType { // TODO expose -LS
+    NULL,
+    GRANT,
+    REVOKE,
+    CHECK
+  }
+}

auth/permission/contracts/PermissionManager.sol

@@ -1,9 +1,10 @@
 import "../../../rest/contracts/RestStatus.sol";
+import "./EventLogType.sol";
 
 /**
 * Permission Manager for all
 */
-contract PermissionManager is RestStatus {
+contract PermissionManager is RestStatus, EventLogType {
   // master account
   address master;
   // owner account
@@ -30,14 +31,6 @@ contract PermissionManager is RestStatus {
     uint result;
   }
 
-  // event log type
-  enum EventLogType { // TODO expose -LS
-    NULL,
-    GRANT,
-    REVOKE,
-    CHECK
-  }
-
   // event log
   EventLogEntry[] eventLog;
 

auth/permission/permissionManager.js

@@ -1,12 +1,13 @@
-const ba = require('blockapps-rest');
-const util = ba.common.util;
-const BigNumber = ba.common.BigNumber;
-const config = ba.common.config;
-const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`];
+import RestStatus from 'http-status-codes';
+import { rest, util, importer } from 'blockapps-rest';
+const { createContract, getState, call, RestError } = rest;
+
+import { getYamlFile } from '../../util/config';
+const config = getYamlFile('config.yaml');
 
 const contractName = 'PermissionManager';
-const contractFilename = `${config.libPath}/auth/permission/contracts/PermissionManager.sol`;
-const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`);
+const contractFilename = `./auth/permission/contracts/PermissionManager.sol`;
+const options = { config }
 
 util.bitmaskToEnumString = function (bitmask, bitmaskEnum) {
   const strings = []
@@ -20,50 +21,53 @@ util.bitmaskToEnumString = function (bitmask, bitmaskEnum) {
 }
 
 
-function* uploadContract(admin, master) {
+async function uploadContract(admin, master) {
   // NOTE: in production, the contract is created and owned by the AdminInterface
   // for testing purposes the creator is the admin user
-  const args = {
-    owner: admin.address,
-    master: master.address,
+  const args = { master: master.address, owner: admin.address };
+  const contractArgs = {
+    name: contractName,
+    source: await importer.combine(contractFilename),
+    args: util.usc(args)
   }
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args));
+
+  const contract = await createContract(admin, contractArgs, options)
   contract.src = 'removed';
   return bind(admin, contract);
 }
 
-function* createPermissionsAdmin(admin, master, permissions) {
-  const contract = yield uploadContract(admin, master);
+async function createPermissionsAdmin(admin, master, permissions) {
+  const contract = await uploadContract(admin, master);
   // add permission to create and modify contracts
-  const args = {address: admin.address, id: admin.name, permissions: permissions};
-  yield contract.grant(args);
+  const args = { address: admin.address, id: admin.name, permissions: permissions };
+  await contract.grant(args);
   return contract;
 }
 
 function bind(admin, contract) {
-  contract.getState = function* () {
-    return yield rest.getState(contract);
+  contract.getState = async function () {
+    return await getState(contract, options);
   }
-  contract.grant = function* (args) {
-    return yield grant(admin, contract, args);
+  contract.grant = async function (args) {
+    return await grant(admin, contract, args);
   }
-  contract.getPermissions = function* (args) {
-    return yield getPermissions(admin, contract, args);
+  contract.getPermissions = async function (args) {
+    return await getPermissions(admin, contract, args);
   }
-  contract.revoke = function* (args) {
-    return yield revoke(admin, contract, args);
+  contract.revoke = async function (args) {
+    return await revoke(admin, contract, args);
   }
-  contract.check = function* (args) {
-    return yield check(admin, contract, args);
+  contract.check = async function (args) {
+    return await check(admin, contract, args);
   }
-  contract.listPermits = function* (args) {
-    return yield listPermits(admin, contract, args);
+  contract.listPermits = async function (args) {
+    return await listPermits(admin, contract, args);
   }
-  contract.listEvents = function* (args) {
-    return yield listEvents(admin, contract, args);
+  contract.listEvents = async function (args) {
+    return await listEvents(admin, contract, args);
   }
-  contract.transferOwnership = function* (args) {
-    return yield transferOwnership(admin, contract, args);
+  contract.transferOwnership = async function (args) {
+    return await transferOwnership(admin, contract, args);
   }
   return contract;
 }
@@ -78,68 +82,89 @@ function bindAddress(admin, address) {
 
 // throws: ErrorCodes
 // returns: updated permissions
-function* grant(admin, contract, args) {
-  rest.verbose('grant', args);
+async function grant(admin, contract, args) {
   // function grant(address _address, uint _permissions) returns (ErrorCodes) {
-  const method = 'grant';
-  const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const callArgs = {
+    contract,
+    method: 'grant',
+    args: util.usc(args)
+  }
+
+  const [restStatus, permissions] = await call(admin, callArgs, options);
   if (restStatus != RestStatus.OK) {
-    throw new Error(restStatus);
+    throw new RestError(restStatus, callArgs.method, callArgs.args);
   }
   return permissions;
 }
 
 // throws: ErrorCodes
 // returns: permissions
-function* getPermissions(admin, contract, args) {
-  rest.verbose('getPermissions', args);
+async function getPermissions(admin, contract, args) {
   // function getPermissions(address _address) returns (ErrorCodes, uint) {
-  const method = 'getPermissions';
-  const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const callArgs = {
+    contract,
+    method: 'getPermissions',
+    args: util.usc(args)
+  }
+
+  const [restStatus, permissions] = await call(admin, callArgs, options);
   if (restStatus != RestStatus.OK) {
-    throw new rest.RestError(restStatus, method, args);
+    throw new RestError(restStatus, callArgs.method, callArgs.args);
   }
   return permissions;
 }
 
 // throws: ErrorCodes
 // returns: true if permitted
-function* check(admin, contract, args) {
-  rest.verbose('check', args);
+async function check(admin, contract, args) {
   // function check(address _address, uint _permissions) returns (ErrorCodes) {
-  const method = 'check';
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const callArgs = {
+    contract,
+    method: 'check',
+    args: util.usc(args)
+  }
+
+  const [restStatus] = await call(admin, callArgs, options);
   if (restStatus != RestStatus.OK) {
     return false;
   }
   return true;
 }
 
 // throws: ErrorCodes
-function* revoke(admin, contract, args) {
-  rest.verbose('revoke', args);
+async function revoke(admin, contract, args) {
   // function revoke(address _address) returns (ErrorCodes) {
-  const method = 'revoke';
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const callArgs = {
+    contract,
+    method: 'revoke',
+    args: util.usc(args)
+  }
+
+  const [restStatus] = await call(admin, callArgs, options);
   if (restStatus != RestStatus.OK) {
-    throw new rest.RestError(restStatus, method, args);
+    throw new RestError(restStatus, callArgs.method, callArgs.args);
   }
   return RestStatus.OK;
 }
 
 // transferOwnership
-function* transferOwnership(admin, contract, args) {
-  const method = "transferOwnership";
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+async function transferOwnership(admin, contract, args) {
+  const callArgs = {
+    contract,
+    method: 'transferOwnership',
+    args: util.usc(args)
+  }
+
+  const [restStatus] = await call(admin, callArgs, {});
   if (restStatus != RestStatus.OK) {
-    throw new rest.RestError(restStatus, method, args);
+    throw new RestError(restStatus, method, args);
   }
   return RestStatus.OK;
 }
 
 // list
-function* listPermits(admin, contract, args) {
-  const { permits } = yield contract.getState()
+async function listPermits(admin, contract, args) {
+  const { permits } = await contract.getState()
   const permitsJson = permits.map((permit) => {
     permit.permissionsHex = Number(permit.permissions).toString(16)
     permit.strings = util.bitmaskToEnumString(permit.permissions, args.enum)
@@ -148,8 +173,8 @@ function* listPermits(admin, contract, args) {
   return permitsJson
 }
 
-function* listEvents(admin, contract, args) {
-  const { eventLog } = yield contract.getState()
+async function listEvents(admin, contract, args) {
+  const { eventLog } = await contract.getState()
   const eventsJson = eventLog.map((event) => {
     event.permissionsHex = Number(event.permissions).toString(16)
     event.strings = util.bitmaskToEnumString(event.permissions, args.enum)
@@ -158,7 +183,7 @@ function* listEvents(admin, contract, args) {
   return eventsJson
 }
 
-module.exports = {
+export {
   bind,
   bindAddress,
   uploadContract,