diff --git a/auth/permission/permissionManager.js b/auth/permission/permissionManager.js
index d6bdcdc..6a5aea0 100644
--- a/auth/permission/permissionManager.js
+++ b/auth/permission/permissionManager.js
@@ -20,14 +20,16 @@ util.bitmaskToEnumString = function (bitmask, bitmaskEnum) {
 }
 
 
-function* uploadContract(admin, master) {
+function* uploadContract(admin, master, chainId) {
   // 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 contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args));
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId);
   contract.src = 'removed';
   return bind(admin, contract);
 }
@@ -40,9 +42,9 @@ function* createPermissionsAdmin(admin, master, permissions) {
   return contract;
 }
 
-function bind(admin, contract) {
+function bind(admin, contract, chainId) {
   contract.getState = function* () {
-    return yield rest.getState(contract);
+    return yield rest.getState(contract, chainId);
   }
   contract.grant = function* (args) {
     return yield grant(admin, contract, args);
@@ -78,11 +80,13 @@ function bindAddress(admin, address) {
 
 // throws: ErrorCodes
 // returns: updated permissions
-function* grant(admin, contract, args) {
+function* grant(admin, contract, args, chainId) {
   rest.verbose('grant', 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 value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.OK) {
     throw new Error(restStatus);
   }
@@ -91,11 +95,13 @@ function* grant(admin, contract, args) {
 
 // throws: ErrorCodes
 // returns: permissions
-function* getPermissions(admin, contract, args) {
+function* getPermissions(admin, contract, args, chainId) {
   rest.verbose('getPermissions', args);
   // function getPermissions(address _address) returns (ErrorCodes, uint) {
   const method = 'getPermissions';
-  const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.OK) {
     throw new rest.RestError(restStatus, method, args);
   }
@@ -104,11 +110,13 @@ function* getPermissions(admin, contract, args) {
 
 // throws: ErrorCodes
 // returns: true if permitted
-function* check(admin, contract, args) {
+function* check(admin, contract, args, chainId) {
   rest.verbose('check', args);
   // function check(address _address, uint _permissions) returns (ErrorCodes) {
   const method = 'check';
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.OK) {
     return false;
   }
@@ -116,11 +124,13 @@ function* check(admin, contract, args) {
 }
 
 // throws: ErrorCodes
-function* revoke(admin, contract, args) {
+function* revoke(admin, contract, args, chainId) {
   rest.verbose('revoke', args);
   // function revoke(address _address) returns (ErrorCodes) {
   const method = 'revoke';
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.OK) {
     throw new rest.RestError(restStatus, method, args);
   }
@@ -128,9 +138,11 @@ function* revoke(admin, contract, args) {
 }
 
 // transferOwnership
-function* transferOwnership(admin, contract, args) {
+function* transferOwnership(admin, contract, args, chainId) {
   const method = "transferOwnership";
-  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.OK) {
     throw new rest.RestError(restStatus, method, args);
   }
diff --git a/auth/permission/permissionedHashmap.js b/auth/permission/permissionedHashmap.js
index 320dc60..eb6d1fe 100644
--- a/auth/permission/permissionedHashmap.js
+++ b/auth/permission/permissionedHashmap.js
@@ -7,20 +7,22 @@ const { config, util } = ba.common
 const contractName = 'PermissionedHashmap'
 const contractFilename = `${config.libPath}/auth/permission/contracts/PermissionedHashmap.sol`
 
-function* uploadContract(admin, permissionManager) {
+function* uploadContract(admin, permissionManager, chainId) {
   const args = { permissionManager: permissionManager.address }
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args))
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId)
   contract.src = 'removed'
   return bind(admin, contract)
 }
 
-function bind(admin, _contract) {
+function bind(admin, _contract, chainId) {
   const contract = _contract
   contract.getState = function* () {
-    return yield rest.getState(contract)
+    return yield rest.getState(contract, chainId)
   }
   contract.getStateVar = function* (args) {
-    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length)
+    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length, chainId)
   }
   contract.put = function* (args) {
     return yield put(admin, contract, args)
@@ -49,38 +51,48 @@ function bindAddress(admin, address) {
   return bind(admin, contract)
 }
 
-function* put(admin, contract, args) {
+function* put(admin, contract, args, chainId) {
   rest.verbose('put', args)
   const method = 'put'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result
 }
 
-function* get(admin, contract, args) {
+function* get(admin, contract, args, chainId) {
   rest.verbose('get', args)
   const method = 'get'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result[0]
 }
 
-function* contains(admin, contract, args) {
+function* contains(admin, contract, args, chainId) {
   rest.verbose('contains', args)
   const method = 'contains'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result[0] == true
 }
 
-function* size(admin, contract, args) {
+function* size(admin, contract, args, chainId) {
   rest.verbose('size', args)
   const method = 'size'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return parseInt(result[0], 10)
 }
 
-function* remove(admin, contract, args) {
+function* remove(admin, contract, args, chainId) {
   rest.verbose('remove', args)
   const method = 'remove'
-  yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
 }
 
 module.exports = {
diff --git a/auth/permission/test/permissionManager.test.js b/auth/permission/test/permissionManager.test.js
index 9e8fba7..a72b20a 100644
--- a/auth/permission/test/permissionManager.test.js
+++ b/auth/permission/test/permissionManager.test.js
@@ -175,8 +175,11 @@ describe('PermissionManager tests', function() {
     // transfer ownership to a new admin, by the master
     {
       const args = { newOwner: newOwner.address }
-      const method = 'transferOwnership'
-      const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args))
+      const method = 'transferOwnership';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.OK, 'should succeed')
     }
   })
@@ -190,27 +193,39 @@ describe('PermissionManager tests', function() {
     yield contract.grant(args)
     // new admin unauthorized
     {
-      const method = 'grant'
-      const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args))
+      const method = 'grant';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail')
     }
     // transfer ownership - must be master
     {
       const args = { newOwner: newOwner.address }
-      const method = 'transferOwnership'
-      const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args))
+      const method = 'transferOwnership';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.OK, 'should succeed')
     }
     // old admin unauthorized
     {
-      const method = 'grant'
-      const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args))
+      const method = 'grant';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail')
     }
     // new admin works
     {
-      const method = 'grant'
-      const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args))
+      const method = 'grant';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.OK, 'should succeed')
     }
   })
@@ -222,8 +237,11 @@ describe('PermissionManager tests', function() {
     {
       const attacker = yield rest.createUser('Attacker_' + uid, '' + uid)
       const args = { newOwner: attacker.address }
-      const method = 'transferOwnership'
-      const [restStatus, permissions] = yield rest.callMethod(attacker, contract, method, util.usc(args))
+      const method = 'transferOwnership';
+      const chainId = '';
+      const value = undefined;
+      const doNotResolve = undefined;
+      const [restStatus, permissions] = yield rest.callMethod(attacker, contract, method, util.usc(args), value, doNotResolve, chainId)
       assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail')
     }
   })
diff --git a/auth/permission/test/permissionedHashmap.test.js b/auth/permission/test/permissionedHashmap.test.js
index 9bc30be..ef77bb8 100644
--- a/auth/permission/test/permissionedHashmap.test.js
+++ b/auth/permission/test/permissionedHashmap.test.js
@@ -44,8 +44,11 @@ describe('PermissionedHashmap tests', function() {
     const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager)
     const iuid = util.iuid();
     const args = factory.createEntity(iuid);
-    const method = 'put'
-    const result = yield rest.callMethod(attacker, contract, method, util.usc(args))
+    const method = 'put';
+    const chainId = '';
+    const value = undefined;
+    const doNotResolve = undefined;
+    const result = yield rest.callMethod(attacker, contract, method, util.usc(args), value, doNotResolve, chainId)
 
     const state = yield contract.getState();
     assert.equal(state.values.length, 1, 'length 1 - did not put');
@@ -126,8 +129,11 @@ describe('PermissionedHashmap tests', function() {
       assert.equal(result, true, 'contains: true');
     }
     // remove
-    const method = 'remove'
-    const result = yield rest.callMethod(attacker, contract, method, util.usc(args))
+    const method = 'remove';
+    const chainId = '';
+    const value = undefined;
+    const doNotResolve = undefined;
+    const result = yield rest.callMethod(attacker, contract, method, util.usc(args), value, doNotResolve, chainId)
 
     yield contract.getState()
     // still contained - was not removed
@@ -146,14 +152,14 @@ describe('PermissionedHashmap tests', function() {
  * @returns {object} the contract
  */
 
-function* createHashmapPermissionManager(admin, master) {
+function* createHashmapPermissionManager(admin, master, doNotResolve, txParams, chainId) {
   const contractName = 'HashmapPermissionManager';
   const contractFilename = `${config.libPath}/auth/permission/test/fixtures/HashmapPermissionManager.sol`;
   const args = {
     owner: admin.address,
     master: master.address,
   }
-  const hashmapPermissionManager = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args));
+  const hashmapPermissionManager = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId);
   return hashmapPermissionManager
 }
 
diff --git a/auth/user/test/userManager.test.js b/auth/user/test/userManager.test.js
index 6fd5503..95ab0b7 100644
--- a/auth/user/test/userManager.test.js
+++ b/auth/user/test/userManager.test.js
@@ -53,7 +53,10 @@ describe('UserManager tests', function() {
 
     // create user UNAUTHORIZED
     const method = 'createUser';
-    const [restStatus, address] = yield rest.callMethod(attacker, contract, method, util.usc(args));
+    const chainId = '';
+    const value = undefined;
+    const doNotResolve = undefined;
+    const [restStatus, address] = yield rest.callMethod(attacker, contract, method, util.usc(args), value, doNotResolve, chainId);
     assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail');
   });
 
diff --git a/auth/user/user.js b/auth/user/user.js
index 7dd1f5c..e7e36de 100644
--- a/auth/user/user.js
+++ b/auth/user/user.js
@@ -9,16 +9,18 @@ const contractFilename = `${ba.common.cwd}/${config.libPath}/auth/user/contracts
 const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`);
 const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole;
 
-function* uploadContract(admin, args) {
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args));
+function* uploadContract(admin, args, chainId) {
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId);
   yield compileSearch(contract);
   contract.src = 'removed';
   return bind(admin, contract);
 }
 
-function bind(admin, contract) {
+function bind(admin, contract, chainId) {
   contract.getState = function* () {
-    return yield rest.getState(contract);
+    return yield rest.getState(contract, chainId);
   }
   contract.authenticate = function* (pwHash) {
     return yield authenticate(admin, contract, pwHash);
@@ -50,14 +52,16 @@ function* getUserByAddress(address) {
   return (yield rest.waitQuery(`${contractName}?address=eq.${address}`, 1))[0];
 }
 
-function* authenticate(admin, contract, pwHash) {
+function* authenticate(admin, contract, pwHash, chainId) {
   rest.verbose('authenticate', pwHash);
   // function authenticate(bytes32 _pwHash) return (bool) {
   const method = 'authenticate';
   const args = {
     _pwHash: pwHash,
   };
-  const result = yield rest.callMethod(admin, contract, method, args);
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, args, value, doNotResolve, chainId);
   const isAuthenticated = (result[0] === true);
   return isAuthenticated;
 }
diff --git a/auth/user/userManager.js b/auth/user/userManager.js
index 19cdf83..ebf8e24 100644
--- a/auth/user/userManager.js
+++ b/auth/user/userManager.js
@@ -12,34 +12,36 @@ const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.s
 const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole;
 const userJs = require(`${cwd}/${config.libPath}/auth/user/user`);
 
-function* uploadContract(admin) {
+function* uploadContract(admin, chainId) {
   // 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 };
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, args);
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, args, doNotResolve, txParams, chainId);
   yield compileSearch(contract);
   contract.src = 'removed';
   return bind(admin, contract);
 }
 
-function bind(admin, contract) {
+function bind(admin, contract, chainId) {
   contract.getState = function* () {
-    return yield rest.getState(contract);
+    return yield rest.getState(contract, chainId);
   }
   contract.createUser = function* (args) {
-    return yield createUser(admin, contract, args);
+    return yield createUser(admin, contract, args, chainId);
   }
   contract.exists = function* (username) {
-    return yield exists(admin, contract, username);
+    return yield exists(admin, contract, username, chainId);
   }
   contract.getUser = function* (username) {
-    return yield getUser(admin, contract, username);
+    return yield getUser(admin, contract, username, chainId);
   }
   contract.getUsers = function* () {
-    return yield getUsers(admin, contract);
+    return yield getUsers(admin, contract, chainId);
   }
   contract.authenticate = function* (args) {
-    return yield authenticate(admin, contract, args);
+    return yield authenticate(admin, contract, args, chainId);
   }
   return contract;
 }
@@ -57,14 +59,16 @@ function* compileSearch(contract) {
 
 // throws: RestStatus
 // returns: user record from search
-function* createUser(admin, contract, args) {
+function* createUser(admin, contract, args, chainId) {
   rest.verbose('createUser', args);
 
   // function createUser(address account, string username, bytes32 pwHash, uint role) returns (ErrorCodes) {
   const method = 'createUser';
 
   // create the user, with the eth account
-  const [restStatus, address] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [restStatus, address] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (restStatus != RestStatus.CREATED) {
     throw new rest.RestError(restStatus, method, args);
   }
@@ -73,19 +77,21 @@ function* createUser(admin, contract, args) {
   return user;
 }
 
-function* exists(admin, contract, username) {
+function* exists(admin, contract, username, chainId) {
   rest.verbose('exists', username);
   // function exists(string username) returns (bool) {
   const method = 'exists';
   const args = {
     username: username,
   };
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   const exist = (result[0] === true);
   return exist;
 }
 
-function* getUser(admin, contract, username) {
+function* getUser(admin, contract, username, chainId) {
   rest.verbose('getUser', username);
   // function getUser(string username) returns (address) {
   const method = 'getUser';
@@ -94,7 +100,9 @@ function* getUser(admin, contract, username) {
   };
 
   // get the use address
-  const [address] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [address] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   if (address == 0) {
     throw new rest.RestError(RestStatus.NOT_FOUND, method, args);
   }
@@ -102,20 +110,22 @@ function* getUser(admin, contract, username) {
   return yield userJs.getUserByAddress(address);
 }
 
-function* getUsers(admin, contract) {
+function* getUsers(admin, contract, chainId) {
   rest.verbose('getUsers');
-  const {users: usersHashmap} = yield rest.getState(contract);
-  const {values} = yield rest.getState({name: 'Hashmap', address:usersHashmap});
+  const {users: usersHashmap} = yield rest.getState(contract, chainId);
+  const {values} = yield rest.getState({name: 'Hashmap', address:usersHashmap}, chainId);
   const addresses = values.slice(1);
   return yield userJs.getUsers(addresses);
 }
 
-function* authenticate(admin, contract, args) {
+function* authenticate(admin, contract, args, chainId) {
   rest.verbose('authenticate', args);
 
   // function authenticate(string _username, bytes32 _pwHash) returns (bool) {
   const method = 'authenticate';
-  const [result] = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const [result] = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   const isOK = (result == true);
   return isOK;
 }
diff --git a/collections/hashmap/hashmap.js b/collections/hashmap/hashmap.js
index 1511cdd..b0ab835 100644
--- a/collections/hashmap/hashmap.js
+++ b/collections/hashmap/hashmap.js
@@ -6,19 +6,21 @@ const config = ba.common.config;
 const contractName = 'Hashmap';
 const contractFilename = `${config.libPath}/collections/hashmap/contracts/Hashmap.sol`;
 
-function* uploadContract(admin) {
+function* uploadContract(admin, chainId) {
   const args = {};
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args));
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId);
   contract.src = 'removed';
   return bind(admin, contract);
 }
 
-function bind(admin, contract) {
+function bind(admin, contract, chainId) {
   contract.getState = function* () {
-    return yield rest.getState(contract);
+    return yield rest.getState(contract, chainId);
   }
   contract.getStateVar = function* (args) {
-    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length);
+    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length, chainId);
   }
   contract.put = function* (args) {
     return yield put(admin, contract, args);
@@ -42,45 +44,57 @@ function bind(admin, contract) {
   return contract;
 }
 
-function* put(admin, contract, args) {
+function* put(admin, contract, args, chainId) {
   rest.verbose('put', args);
   const method = 'put';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return result;
 }
 
-function* get(admin, contract, args) {
+function* get(admin, contract, args, chainId) {
   rest.verbose('get', args);
   const method = 'get';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return result[0];
 }
 
-function* contains(admin, contract, args) {
+function* contains(admin, contract, args, chainId) {
   rest.verbose('contains', args);
   const method = 'contains';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return result[0] == true;
 }
 
-function* size(admin, contract, args) {
+function* size(admin, contract, args, chainId) {
   rest.verbose('size', args);
   const method = 'size';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return parseInt(result[0]);
 }
 
-function* transferOwnership(admin, contract, args) {
+function* transferOwnership(admin, contract, args, chainId) {
   rest.verbose('transferOwnership', args);
   const method = 'transferOwnership';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return result[0] == true;
 }
 
-function* getOwner(admin, contract, args) {
+function* getOwner(admin, contract, args, chainId) {
   rest.verbose('getOwner', args);
   const method = 'getOwner';
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args));
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId);
   return result[0];
 }
 
diff --git a/collections/hashmap/unsafeHashmap.js b/collections/hashmap/unsafeHashmap.js
index adde6f0..bb66034 100644
--- a/collections/hashmap/unsafeHashmap.js
+++ b/collections/hashmap/unsafeHashmap.js
@@ -6,71 +6,83 @@ const { config, util } = ba.common
 const contractName = 'UnsafeHashmap'
 const contractFilename = `${config.libPath}/collections/hashmap/contracts/UnsafeHashmap.sol`
 
-function* uploadContract(admin) {
+function* uploadContract(admin, chainId) {
   const args = {}
-  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args))
+  const doNotResolve = undefined;
+  const txParams = undefined;
+  const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args), doNotResolve, txParams, chainId)
   contract.src = 'removed'
   return bind(admin, contract)
 }
 
-function bind(admin, _contract) {
+function bind(admin, _contract, chainId) {
   const contract = _contract
   contract.getState = function* () {
-    return yield rest.getState(contract)
+    return yield rest.getState(contract, chainId)
   }
   contract.getStateVar = function* (args) {
-    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length)
+    return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length, chainId)
   }
   contract.put = function* (args) {
-    return yield put(admin, contract, args)
+    return yield put(admin, contract, args, chainId)
   }
   contract.get = function* (args) {
-    return yield get(admin, contract, args)
+    return yield get(admin, contract, args, chainId)
   }
   contract.contains = function* (args) {
-    return yield contains(admin, contract, args)
+    return yield contains(admin, contract, args, chainId)
   }
   contract.size = function* (args) {
-    return yield size(admin, contract, args)
+    return yield size(admin, contract, args, chainId)
   }
   contract.remove = function* (args) {
-    return yield remove(admin, contract, args)
+    return yield remove(admin, contract, args, chainId)
   }
   return contract
 }
 
-function* put(admin, contract, args) {
+function* put(admin, contract, args, chainId) {
   rest.verbose('put', args)
   const method = 'put'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result
 }
 
-function* get(admin, contract, args) {
+function* get(admin, contract, args, chainId) {
   rest.verbose('get', args)
   const method = 'get'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result[0]
 }
 
-function* contains(admin, contract, args) {
+function* contains(admin, contract, args, chainId) {
   rest.verbose('contains', args)
   const method = 'contains'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return result[0] == true
 }
 
-function* size(admin, contract, args) {
+function* size(admin, contract, args, chainId) {
   rest.verbose('size', args)
   const method = 'size'
-  const result = yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  const result = yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
   return parseInt(result[0])
 }
 
-function* remove(admin, contract, args) {
+function* remove(admin, contract, args, chainId) {
   rest.verbose('remove', args)
   const method = 'remove'
-  yield rest.callMethod(admin, contract, method, util.usc(args))
+  const value = undefined;
+  const doNotResolve = undefined;
+  yield rest.callMethod(admin, contract, method, util.usc(args), value, doNotResolve, chainId)
 }
 
 module.exports = {