Meta Txs: Adding support for meta transactions in aragon apps (Part 2)

contracts/test/mocks/relayer/RelayerMock.sol

@@ -5,11 +5,22 @@ import "../../../test/mocks/common/TimeHelpersMock.sol";
 
 
 contract RelayerMock is Relayer, TimeHelpersMock {
+    uint256 public chainId;
+
+    function initializeWithChainId(uint256 _monthlyRefundQuota, uint256 _chainId) external onlyInit {
+        initialized();
+        startDate = getTimestamp();
+        monthlyRefundQuota = _monthlyRefundQuota;
+        setDepositable(true);
+
+        chainId = _chainId;
+    }
+
     function messageHash(address to, uint256 nonce, bytes data, uint256 gasRefund, uint256 gasPrice) public view returns (bytes32) {
         return _messageHash(to, nonce, data, gasRefund, gasPrice);
     }
 
-    function domainSeparator() public view returns (bytes32) {
-        return _domainSeparator();
+    function _domainChainId() internal view returns (uint256) {
+        return chainId == 0 ? 1 : chainId;
     }
 }

lib/relayer/GasPriceOracle.js

@@ -0,0 +1,25 @@
+const GAS_STATION_API_URL = 'https://ethgasstation.info/json/ethgasAPI.json'
+
+const DEFAULT_DEVNET_GAS_PRICE = 1e5
+const DEFAULT_TESTNET_GAS_PRICE = 1e6
+
+const MAINNET_ID = 1
+const TESTNET_IDS = [2, 3, 42] // ropsten, rinkeby and kovan
+
+module.exports = {
+  async fetch(networkId) {
+    if (MAINNET_ID === networkId) return this._fetchMainnetGasPrice()
+    if (TESTNET_IDS.includes(networkId)) return DEFAULT_TESTNET_GAS_PRICE
+    return DEFAULT_DEVNET_GAS_PRICE
+  },
+
+  async _fetchMainnetGasPrice() {
+    try {
+      const axios = require('axios')
+      const { data: responseData } = await axios.get(GAS_STATION_API_URL)
+      return (responseData.average / 10) * 1e9
+    } catch (error) {
+      throw new Error(`Could not fetch gas price from ETH gas station: ${error}`)
+    }
+  }
+}

lib/relayer/RelayTransactionSigner.js

@@ -0,0 +1,118 @@
+const GasPriceOracle = require('./GasPriceOracle')
+
+const DEFAULT_DOMAIN_NAME = 'Aragon Relayer'
+const DEFAULT_DOMAIN_VERSION = '1'
+
+const GAS_MULTIPLIER = 1.18
+
+const FIRST_TX_GAS_OVERLOAD = 83500
+const NORMAL_TX_GAS_OVERLOAD = 53500
+
+const DATA_TYPES = {
+  EIP712Domain: [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+  ],
+  Transaction: [
+    { name: 'to', type: 'address' },
+    { name: 'nonce', type: 'uint256' },
+    { name: 'data', type: 'bytes' },
+    { name: 'gasRefund', type: 'uint256' },
+    { name: 'gasPrice', type: 'uint256' }
+  ],
+}
+
+module.exports = web3 => class RelayTransactionSigner {
+  constructor(relayer, domainName = DEFAULT_DOMAIN_NAME, domainVersion = DEFAULT_DOMAIN_VERSION) {
+    this.relayer = relayer
+    this.domainName = domainName
+    this.domainVersion = domainVersion
+  }
+
+  async signTransaction({ from, to, data, nonce = undefined, gasRefund = undefined, gasPrice = undefined }, service = undefined) {
+    if (!nonce) nonce = await this._fetchNextNonce(from)
+    if (!gasPrice) gasPrice = await this._estimateGasPrice()
+    if (!gasRefund) gasRefund = service
+      ? await this._estimateRelayGasWithService(service, { from, to, data, nonce, gasPrice })
+      : await this._estimateRelayGasConservatively({ from, to, data, nonce, gasPrice })
+
+    const message = { from, to, nonce, data, gasRefund, gasPrice }
+    const signature = await this.signMessage(message)
+    return { ...message, signature }
+  }
+
+  async signMessage({ from, to, nonce, data, gasRefund, gasPrice }) {
+    const message = { to, nonce, data, gasRefund, gasPrice }
+    const params = { method: 'eth_signTypedData', params: [from, this._typeData(message)], from }
+    return new Promise((resolve, reject) => {
+      web3.currentProvider.sendAsync(params, (error, tx) => {
+        return error ? reject(error) : resolve(tx.result)
+      })
+    })
+  }
+
+  async _fetchNextNonce(sender) {
+    const lastUsedNonce = (await this.relayer.getSender(sender))[1]
+    return parseInt(lastUsedNonce.toString()) + 1
+  }
+
+  async _estimateRelayGasWithService(service, { from, to, data, nonce, gasPrice }) {
+    // simulate signature using gas limit as worst case scenario
+    const gasLimit = await this._gasLimit()
+    const signature = await this.signMessage({ from, to, nonce, data, gasRefund: gasLimit, gasPrice })
+    const estimatedGas = await service.estimateGas({ from, to, nonce, data, gasRefund: gasLimit, gasPrice, signature })
+    return Math.ceil(estimatedGas * GAS_MULTIPLIER)
+  }
+
+  async _estimateRelayGasConservatively({ from, to, data, nonce }) {
+    const estimatedGas = await this._estimateCallGas({ from, to, data })
+    const relayOverload = nonce === 1 ? FIRST_TX_GAS_OVERLOAD : NORMAL_TX_GAS_OVERLOAD
+    return Math.ceil((estimatedGas + relayOverload) * GAS_MULTIPLIER)
+  }
+
+  async _estimateCallGas({ from, to, data }) {
+    const call = { from, to, data }
+    return new Promise((resolve, reject) => {
+      web3.eth.estimateGas(call, (error, response) => {
+        return error ? reject(error) : resolve(response)
+      })
+    })
+  }
+
+  async _estimateGasPrice() {
+    return GasPriceOracle.fetch(this._networkId())
+  }
+
+  async _gasLimit() {
+    const block = await this._latestBlock()
+    return block.gasLimit
+  }
+
+  async _latestBlock() {
+    return new Promise((resolve, reject) => {
+      web3.eth.getBlock('latest', (error, response) => {
+        return error ? reject(error) : resolve(response)
+      })
+    })
+  }
+
+  _networkId() {
+    return parseInt(this.relayer.constructor.network_id)
+  }
+
+  _typeData(message) {
+    return {
+      types: DATA_TYPES,
+      primaryType: 'Transaction',
+      domain: {
+        name: this.domainName,
+        version: this.domainVersion,
+        chainId: this._networkId(),
+        verifyingContract: this.relayer.address
+      },
+      message: message
+    }
+  }
+}

lib/relayer/RelayerService.js

@@ -0,0 +1,85 @@
+const GasPriceOracle = require('./GasPriceOracle')
+
+module.exports = (artifacts, web3) => class RelayerService {
+  constructor(wallet, relayer) {
+    this.wallet = wallet
+    this.relayer = relayer
+  }
+
+  async relay(transaction) {
+    await this._assertTargetIsAragonApp(transaction)
+    await this._assertTransactionWontRevert(transaction)
+    await this._assertTransactionGasCostIsCovered(transaction)
+    await this._assertTransactionReasonableGasPrice(transaction)
+
+    return this._relay(transaction)
+  }
+
+  async estimateGas(transaction) {
+    return this._estimateGas(transaction)
+  }
+
+  async _relay(transaction) {
+    const { from, to, nonce, data, gasRefund, gasPrice, signature } = transaction
+    const txParams = { from: this.wallet, gas: gasRefund, gasPrice }
+
+    // console.log(`\nRelaying transaction ${JSON.stringify(transaction)} with params ${JSON.stringify(txParams)}`)
+    return this.relayer.relay(from, to, nonce, data, gasRefund, gasPrice, signature, txParams)
+  }
+
+  async _assertTargetIsAragonApp({ to }) {
+    let relayerKernel, aragonAppKernel
+    try {
+      relayerKernel = await this.relayer.kernel()
+      aragonAppKernel = await artifacts.require('AragonApp').at(to).kernel()
+    } catch (error) {
+      throw Error(`Could not ensure target address is actually an AragonApp from the same Kernel: ${error}`)
+    }
+    if (relayerKernel === aragonAppKernel) return;
+    throw Error(`The Kernel of the target app ${aragonAppKernel} does not match with the Kernel of the current realyer ${relayerKernel}`)
+  }
+
+  async _assertTransactionWontRevert(transaction) {
+    const error = await this._transactionWillFail(transaction)
+    if (!error) return
+
+    throw Error(error.message.search(/(revert|invalid opcode|invalid jump)/) > -1
+      ? `Will not relay failing transaction: ${error.message}`
+      : `Could not estimate gas: ${error.message}`)
+  }
+
+  async _assertTransactionGasCostIsCovered(transaction) {
+    const { gasRefund } = transaction
+    const estimatedGas = await this._estimateGas(transaction)
+    if (gasRefund < estimatedGas) throw Error(`Given gas refund amount ${gasRefund} does not cover transaction gas cost ${estimatedGas}`)
+  }
+
+  async _assertTransactionReasonableGasPrice(transaction) {
+    const averageGasPrice = await GasPriceOracle.fetch(this._networkId())
+    if (transaction.gasPrice < averageGasPrice) throw Error(`Given gas price is below the average ${averageGasPrice}`)
+  }
+
+  async _transactionWillFail(transaction) {
+    try {
+      await this._estimateGas(transaction)
+      return false
+    } catch (error) {
+      return error
+    }
+  }
+
+  async _estimateGas({ from, to, nonce, data, gasRefund, gasPrice, signature }) {
+    const calldata = this.relayer.contract.relay.getData(from, to, nonce, data, gasRefund, gasPrice, signature)
+    const call = { from: this.wallet, to: this.relayer.address, data: calldata }
+
+    return new Promise((resolve, reject) => {
+      web3.eth.estimateGas(call, (error, response) => {
+        return error ? reject(error) : resolve(response)
+      })
+    })
+  }
+
+  _networkId() {
+    return this.relayer.constructor.network_id
+  }
+}

package.json

@@ -37,7 +37,7 @@
     "eth-ens-namehash": "^2.0.8",
     "eth-gas-reporter": "^0.1.1",
     "ethereumjs-abi": "^0.6.5",
-    "ganache-cli": "^6.4.2",
+    "ganache-cli": "~6.2.0",
     "mocha-lcov-reporter": "^1.3.0",
     "solidity-coverage": "0.5.8",
     "solium": "^1.2.3",