Merge pull request #87 from argentlabs/maintenance/deployment_gasPrice

Consistent deployment gas price

deployment/1_setup_test_environment.js

@@ -17,6 +17,7 @@ const BYTES32_NULL = "0x00000000000000000000000000000000000000000000000000000000
 
 // For development purpose
 async function deployENSRegistry(deployer, owner, domain) {
+  const { gasPrice } = deployer.defaultOverrides;
   // Deploy the public ENS registry
   const ensRegistryWithoutFallback = await deployer.deploy(ENSRegistry);
   const ENSWrapper = await deployer.deploy(ENSRegistryWithFallback, {}, ensRegistryWithoutFallback.contractAddress);
@@ -27,22 +28,23 @@ async function deployENSRegistry(deployer, owner, domain) {
   const domainName = parts[0];
 
   // Create the 'eth' and 'xyz' namespaces
-  const setSubnodeOwnerXYZ = await ENSWrapper.contract.setSubnodeOwner(BYTES32_NULL, utils.sha3(extension), owner);
+  const setSubnodeOwnerXYZ = await ENSWrapper.contract.setSubnodeOwner(BYTES32_NULL, utils.sha3(extension), owner, { gasPrice });
   await ENSWrapper.verboseWaitForTransaction(setSubnodeOwnerXYZ, `Setting Subnode Owner for ${extension}`);
 
   // Create the 'argentx.xyz' wallet ENS namespace
-  const setSubnodeOwnerArgent = await ENSWrapper.contract.setSubnodeOwner(utils.namehash(extension), utils.sha3(domainName), owner);
+  const setSubnodeOwnerArgent = await ENSWrapper.contract.setSubnodeOwner(utils.namehash(extension), utils.sha3(domainName), owner, { gasPrice });
   await ENSWrapper.verboseWaitForTransaction(setSubnodeOwnerArgent, `Setting Subnode Owner for ${domainName}.${extension}`);
 
   return ENSWrapper.contractAddress;
 }
 
 // For development purpose
 async function deployKyber(deployer) {
+  const { gasPrice } = deployer.defaultOverrides;
   const KyberWrapper = await deployer.deploy(Kyber);
   const ERC20Wrapper = await deployer.deploy(ERC20, {}, [KyberWrapper.contractAddress], TEST_ERC20_SUPPLY, TEST_ERC20_DECIMALS);
 
-  const addToken = await KyberWrapper.contract.addToken(ERC20Wrapper.contractAddress, TEST_ERC20_RATE, TEST_ERC20_DECIMALS);
+  const addToken = await KyberWrapper.contract.addToken(ERC20Wrapper.contractAddress, TEST_ERC20_RATE, TEST_ERC20_DECIMALS, { gasPrice });
   await KyberWrapper.verboseWaitForTransaction(addToken, "Add test token to Kyber");
 
   return KyberWrapper.contractAddress;
@@ -54,6 +56,7 @@ const deploy = async (network) => {
 
   const { configurator } = manager;
   const { deployer } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
 
   const { config } = configurator;
 
@@ -75,7 +78,7 @@ const deploy = async (network) => {
     const UniswapFactoryWrapper = await deployer.deploy(UniswapFactory);
     configurator.updateUniswapFactory(UniswapFactoryWrapper.contractAddress);
     const UniswapExchangeTemplateWrapper = await deployer.deploy(UniswapExchange);
-    const initializeFactoryTx = await UniswapFactoryWrapper.initializeFactory(UniswapExchangeTemplateWrapper.contractAddress);
+    const initializeFactoryTx = await UniswapFactoryWrapper.contract.initializeFactory(UniswapExchangeTemplateWrapper.contractAddress, { gasPrice });
     await UniswapFactoryWrapper.verboseWaitForTransaction(initializeFactoryTx, "Initializing UniswapFactory");
   }
 

deployment/2_deploy_contracts.js

@@ -24,6 +24,7 @@ const deploy = async (network) => {
   const { configurator } = manager;
   const { deployer } = manager;
   const { abiUploader } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
 
   const newConfig = configurator.config;
   const prevConfig = configurator.copyConfig();
@@ -67,15 +68,16 @@ const deploy = async (network) => {
 
   if (previousWalletEnsOwner.toLowerCase() === deploymentAccount.toLowerCase()) {
     // newly registered name -> change its owner from deploymentAccount to ENSManager address
-    const setOwnerTransaction = await ENSRegistryWrapper.contract.setOwner(utils.namehash(walletRootEns), ENSManagerWrapper.contractAddress);
+    const setOwnerTransaction = await ENSRegistryWrapper.contract.setOwner(utils.namehash(walletRootEns), ENSManagerWrapper.contractAddress,
+      { gasPrice });
     await ENSRegistryWrapper.verboseWaitForTransaction(setOwnerTransaction, "Replace deployment account by ENSManager as new owner of walletENS");
   } else if (previousWalletEnsOwner.toLowerCase() === prevConfig.contracts.ENSManager.toLowerCase()) {
     // change the owner from the previous ENSManager.address to the new one
     console.log("change the owner from the previous ENSManager to the new one");
     const previousMultiSigWrapper = deployer.wrapDeployedContract(MultiSig, prevConfig.contracts.MultiSigWallet);
     const previousENSManagerWrapper = deployer.wrapDeployedContract(ENSManager, prevConfig.contracts.ENSManager);
 
-    const multisigExecutor = new MultisigExecutor(previousMultiSigWrapper, deploymentWallet, prevConfig.multisig.autosign);
+    const multisigExecutor = new MultisigExecutor(previousMultiSigWrapper, deploymentWallet, prevConfig.multisig.autosign, { gasPrice });
     console.log(`Owner of ${walletRootEns} changed from old ENSManager to new ENSManager...`);
     await multisigExecutor.executeCall(previousENSManagerWrapper, "changeRootnodeOwner", [ENSManagerWrapper.contractAddress]);
   } else {
@@ -88,7 +90,7 @@ const deploy = async (network) => {
 
   for (const underlying in newConfig.defi.compound.markets) {
     const cToken = newConfig.defi.compound.markets[underlying];
-    const addUnderlyingTransaction = await CompoundRegistryWrapper.addCToken(underlying, cToken);
+    const addUnderlyingTransaction = await CompoundRegistryWrapper.contract.addCToken(underlying, cToken, { gasPrice });
     await CompoundRegistryWrapper.verboseWaitForTransaction(addUnderlyingTransaction,
       `Adding unerlying ${underlying} with cToken ${cToken} to the registry`);
   }

deployment/3_setup_contracts.js

@@ -17,6 +17,7 @@ const deploy = async (network) => {
 
   const { configurator } = manager;
   const { deployer } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
 
   const { config } = configurator;
   console.log("Config:", config);
@@ -32,21 +33,21 @@ const deploy = async (network) => {
   // Set contracts' managers
   // //////////////////////////////////
 
-  const ENSResolverAddManagerTx1 = await ENSResolverWrapper.contract.addManager(config.contracts.ENSManager);
+  const ENSResolverAddManagerTx1 = await ENSResolverWrapper.contract.addManager(config.contracts.ENSManager, { gasPrice });
   await ENSResolverWrapper.verboseWaitForTransaction(ENSResolverAddManagerTx1, "Set the ENS Manager as the manager of the ENS Resolver");
 
-  const ENSResolverAddManagerTx2 = await ENSResolverWrapper.contract.addManager(config.contracts.MultiSigWallet);
+  const ENSResolverAddManagerTx2 = await ENSResolverWrapper.contract.addManager(config.contracts.MultiSigWallet, { gasPrice });
   await ENSResolverWrapper.verboseWaitForTransaction(ENSResolverAddManagerTx2, "Set the Multisig as the manager of the ENS Resolver");
 
-  const ENSManagerAddManagerTx = await ENSManagerWrapper.contract.addManager(config.contracts.WalletFactory);
+  const ENSManagerAddManagerTx = await ENSManagerWrapper.contract.addManager(config.contracts.WalletFactory, { gasPrice });
   await ENSManagerWrapper.verboseWaitForTransaction(ENSManagerAddManagerTx, "Set the WalletFactory as the manager of the ENS Manager");
 
   for (const idx in config.backend.accounts) {
     const account = config.backend.accounts[idx];
-    const WalletFactoryAddManagerTx = await WalletFactoryWrapper.contract.addManager(account);
+    const WalletFactoryAddManagerTx = await WalletFactoryWrapper.contract.addManager(account, { gasPrice });
     await WalletFactoryWrapper.verboseWaitForTransaction(WalletFactoryAddManagerTx, `Set ${account} as the manager of the WalletFactory`);
 
-    const TokenPriceProviderAddManagerTx = await TokenPriceProviderWrapper.contract.addManager(account);
+    const TokenPriceProviderAddManagerTx = await TokenPriceProviderWrapper.contract.addManager(account, { gasPrice });
     await TokenPriceProviderWrapper.verboseWaitForTransaction(TokenPriceProviderAddManagerTx,
       `Set ${account} as the manager of the TokenPriceProvider`);
   }
@@ -58,7 +59,7 @@ const deploy = async (network) => {
   const wrappers = [ENSResolverWrapper, ENSManagerWrapper, WalletFactoryWrapper, ModuleRegistryWrapper, CompoundRegistryWrapper];
   for (let idx = 0; idx < wrappers.length; idx += 1) {
     const wrapper = wrappers[idx];
-    const changeOwnerTx = await wrapper.contract.changeOwner(config.contracts.MultiSigWallet);
+    const changeOwnerTx = await wrapper.contract.changeOwner(config.contracts.MultiSigWallet, { gasPrice });
     await wrapper.verboseWaitForTransaction(changeOwnerTx, `Set the MultiSig as the owner of ${wrapper._contract.contractName}`);
   }
 };

deployment/4_finalise_test_environment.js

@@ -6,15 +6,18 @@ const DeployManager = require("../utils/deploy-manager.js");
 
 const BYTES32_NULL = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
-async function deployENSReverseRegistrar(deployer, config, owner) {
+async function deployENSReverseRegistrar(deployer, config, owner, overrides) {
   const ENSRegistryWrapper = deployer.wrapDeployedContract(ENS, config.ENS.ensRegistry);
   const ENSReverseRegistrarWrapper = await deployer.deploy(ENSReverseRegistrar, {}, config.ENS.ensRegistry, config.contracts.ENSResolver);
 
-  const setSubnodeOwnerTx1 = await ENSRegistryWrapper.contract.setSubnodeOwner(BYTES32_NULL, utils.sha3("reverse"), owner);
+  const setSubnodeOwnerTx1 = await ENSRegistryWrapper.contract.setSubnodeOwner(BYTES32_NULL, utils.sha3("reverse"), owner, overrides);
   await ENSRegistryWrapper.verboseWaitForTransaction(setSubnodeOwnerTx1, "Create the reverse namespace");
 
   const setSubnodeOwnerTx2 = await ENSRegistryWrapper.contract.setSubnodeOwner(
-    utils.namehash("reverse"), utils.sha3("addr"), ENSReverseRegistrarWrapper.contractAddress,
+    utils.namehash("reverse"),
+    utils.sha3("addr"),
+    ENSReverseRegistrarWrapper.contractAddress,
+    overrides,
   );
   await ENSRegistryWrapper.verboseWaitForTransaction(setSubnodeOwnerTx2,
     "Create the addr.reverse namespace and make the ENS reverse registrar the owner");
@@ -26,13 +29,14 @@ const deploy = async (network) => {
 
   const { configurator } = manager;
   const { deployer } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
 
   const { config } = configurator;
 
   const deploymentAccount = await deployer.signer.getAddress();
 
   if (config.ENS.deployOwnRegistry) {
-    await deployENSReverseRegistrar(deployer, config, deploymentAccount);
+    await deployENSReverseRegistrar(deployer, config, deploymentAccount, { gasPrice });
   }
 };
 

deployment/6_register_modules.js

@@ -28,6 +28,7 @@ const deploy = async (network) => {
   const { configurator } = manager;
   const { deployer } = manager;
   const { versionUploader } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
 
   const deploymentWallet = deployer.signer;
 
@@ -65,7 +66,7 @@ const deploy = async (network) => {
   // Register modules
   // //////////////////////////////////
 
-  const multisigExecutor = new MultisigExecutor(MultiSigWrapper, deploymentWallet, config.multisig.autosign);
+  const multisigExecutor = new MultisigExecutor(MultiSigWrapper, deploymentWallet, config.multisig.autosign, { gasPrice });
 
   for (let idx = 0; idx < wrappers.length; idx += 1) {
     const wrapper = wrappers[idx];

deployment/7_upgrade_1_6.js

@@ -42,13 +42,14 @@ const deploy = async (network) => {
   const { deployer } = manager;
   const { abiUploader } = manager;
   const { versionUploader } = manager;
+  const { gasPrice } = deployer.defaultOverrides;
   const deploymentWallet = deployer.signer;
   const { config } = configurator;
 
   const TokenPriceProviderWrapper = await deployer.wrapDeployedContract(TokenPriceProvider, config.contracts.TokenPriceProvider);
   const ModuleRegistryWrapper = await deployer.wrapDeployedContract(ModuleRegistry, config.contracts.ModuleRegistry);
   const MultiSigWrapper = await deployer.wrapDeployedContract(MultiSig, config.contracts.MultiSigWallet);
-  const multisigExecutor = new MultisigExecutor(MultiSigWrapper, deploymentWallet, config.multisig.autosign);
+  const multisigExecutor = new MultisigExecutor(MultiSigWrapper, deploymentWallet, config.multisig.autosign, { gasPrice });
 
   // //////////////////////////////////
   // Deploy infrastructure contracts
@@ -58,9 +59,9 @@ const deploy = async (network) => {
   const MakerRegistryWrapper = await deployer.deploy(MakerRegistry);
   const ScdMcdMigrationWrapper = await deployer.wrapDeployedContract(ScdMcdMigration, config.defi.maker.migration);
   const wethJoinAddress = await ScdMcdMigrationWrapper.wethJoin();
-  const addCollateralTransaction = await MakerRegistryWrapper.addCollateral(wethJoinAddress);
+  const addCollateralTransaction = await MakerRegistryWrapper.contract.addCollateral(wethJoinAddress, { gasPrice });
   await MakerRegistryWrapper.verboseWaitForTransaction(addCollateralTransaction, `Adding join adapter ${wethJoinAddress} to the MakerRegistry`);
-  const changeMakerRegistryOwnerTx = await MakerRegistryWrapper.changeOwner(config.contracts.MultiSigWallet);
+  const changeMakerRegistryOwnerTx = await MakerRegistryWrapper.contract.changeOwner(config.contracts.MultiSigWallet, { gasPrice });
   await MakerRegistryWrapper.verboseWaitForTransaction(changeMakerRegistryOwnerTx, "Set the MultiSig as the owner of the MakerRegistry");
 
   // //////////////////////////////////
@@ -140,22 +141,24 @@ const deploy = async (network) => {
   // ////////////////////////////////////////////////////
 
   if (!await TokenPriceProviderWrapper.contract.managers(deploymentWallet.address)) {
-    const TokenPriceProviderAddManagerTx = await TokenPriceProviderWrapper.contract.addManager(deploymentWallet.address);
+    const TokenPriceProviderAddManagerTx = await TokenPriceProviderWrapper.contract.addManager(deploymentWallet.address, { gasPrice });
     await TokenPriceProviderWrapper.verboseWaitForTransaction(TokenPriceProviderAddManagerTx,
       `Set ${deploymentWallet.address} as the manager of the TokenPriceProvider`);
   }
-  const TokenPriceProviderSetKyberNetworkTx = await TokenPriceProviderWrapper.contract.setKyberNetwork("0x0000000000000000000000000000000000000000");
+
+  const TokenPriceProviderSetKyberNetworkTx = await TokenPriceProviderWrapper.contract.setKyberNetwork("0x0000000000000000000000000000000000000000",
+    { gasPrice });
   await TokenPriceProviderWrapper.verboseWaitForTransaction(TokenPriceProviderSetKyberNetworkTx,
     "Disable the KyberNetwork on the TokenPriceProvider");
 
   // ////////////////////////////////////////////////////
   // Change the owner of TokenPriceProvider
   // ////////////////////////////////////////////////////
 
-  const TokenPriceProviderRevokeManagerTx = await TokenPriceProviderWrapper.contract.revokeManager(deploymentWallet.address);
+  const TokenPriceProviderRevokeManagerTx = await TokenPriceProviderWrapper.contract.revokeManager(deploymentWallet.address, { gasPrice });
   await TokenPriceProviderWrapper.verboseWaitForTransaction(TokenPriceProviderRevokeManagerTx,
     `Revoke ${deploymentWallet.address} as the manager of the TokenPriceProvider`);
-  const changeOwnerTx = await TokenPriceProviderWrapper.contract.changeOwner(config.contracts.MultiSigWallet);
+  const changeOwnerTx = await TokenPriceProviderWrapper.contract.changeOwner(config.contracts.MultiSigWallet, { gasPrice });
   await TokenPriceProviderWrapper.verboseWaitForTransaction(changeOwnerTx, "Set the MultiSig as the owner of TokenPriceProvider");
 
   // //////////////////////////////////