Merge pull request th4s#1 from PumpkinSeed/I7-development-env

Setup development environment

Author: PumpkinSeed

.github/workflows/main.yml

@@ -0,0 +1,45 @@
+on: [push, pull_request]
+
+name: Ethane Rust
+
+jobs:
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          # profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: check
+
+  test:
+    runs-on: ubuntu-latest
+    services:
+      ganache:
+        image: pumpkinseed/ganache-fix
+        ports:
+          - 8545:8545
+        env:
+          WEB3_FORK_URL: ${{ secrets.INFURA_LINK }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Setup Dependencies
+        run: |
+          sudo add-apt-repository ppa:ethereum/ethereum
+          sudo apt-get update
+          sudo apt-get install -y solc
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+      

.gitignore

@@ -2,4 +2,5 @@
 Cargo.lock
 .idea/
 /test-helper/target
-/test-helper/Cargo.lock
+/test-helper/Cargo.lock
+.env

src/lib.rs

@@ -17,7 +17,7 @@
 //! # Examples
 //!
 //! ## Request over http
-//! ```
+//! ```no_run
 //! use ethane::Connector;
 //! use ethane::rpc::eth_get_balance;
 //! use ethane::types::H160;
@@ -34,7 +34,7 @@
 //! ```
 //!
 //! ## Starting a subscription over websocket
-//! ```
+//! ```no_run
 //! use ethane::Connector;
 //! use ethane::rpc::sub::eth_subscribe_new_pending_transactions;
 //! # use test_helper::NodeProcess;

src/rpc/personal.rs

@@ -15,14 +15,16 @@ pub fn personal_list_accounts() -> Rpc<Vec<H160>> {
 pub fn personal_unlock_account(
     address: H160,
     password: String,
-    duration: Option<u32>,
+    wrapped_duration: Option<u32>,
 ) -> Rpc<bool> {
     let mut rpc = Rpc::new("personal_unlockAccount");
     rpc.add_param(address);
     rpc.add_param(password);
-    if let Some(duration) = duration {
-        rpc.add_param(duration);
-    }
+    let duration = match wrapped_duration {
+        Some(duration) => duration,
+        None => 0,
+    };
+    rpc.add_param(duration);
     rpc
 }
 

test-helper/infrastructure/README.md

@@ -0,0 +1,7 @@
+### Start ganache instance
+
+Create `.env` file and add this (replace the URL section with the infure url):
+
+```
+WEB3_FORK_URL=<YOUR URL HERE>
+```

test-helper/infrastructure/docker-compose.yml

@@ -0,0 +1,16 @@
+version: '3'
+
+services:
+  explorer:
+    image: alethio/ethereum-lite-explorer
+    environment:
+      - APP_NODE_URL=http://localhost:8545
+    ports:
+      - 8080:80
+  ganache:
+    build:
+      context: ./ganache-cli
+    environment:
+      - WEB3_FORK_URL=${WEB3_FORK_URL}
+    ports:
+      - "8545:8545"

test-helper/infrastructure/ganache-cli/Dockerfile

@@ -0,0 +1,20 @@
+# node:alpine will be our base image to create this image
+FROM node:alpine
+
+ARG WEB3_FORK_URL
+ENV WEB3_FORK_URL ${WEB3_FORK_URL}
+
+# Set the /app directory as working directory
+WORKDIR /app
+
+# Install ganache-cli globally
+RUN npm install -g ganache-cli
+
+EXPOSE 8545
+
+# Set the default command for the image
+# Add a fix private key and 1000 ETH on it.
+CMD ganache-cli -h 0.0.0.0 --fork ${WEB3_FORK_URL} \
+    --account "0x31c354f57fc542eba2c56699286723e94f7bd02a4891a0a7f68566c2a2df6795,100000000000000000000000" \
+    --account "0x31c354f57fc342eba2c56699286723e94f7bd12a4891a0a7f68566c2a2df6795,100000000000000000000000" \
+    --account "0x31c354f57fc342eba2c56699286723e94f7bd12a4891a0a7f68566c2a2d56795,100000000000000000000000"

test-helper/src/fixtures/TestERC20.sol

@@ -0,0 +1,211 @@
+//SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.1;
+
+contract Ownable {
+    address private _owner;
+
+    constructor() {
+        _owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(isOwner(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    function isOwner() public view returns (bool) {
+        return msg.sender == _owner;
+    }
+}
+
+library SafeMath {
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+
+        uint256 c = a * b;
+        assert(c / a == b);
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a / b;
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        assert(b <= a);
+        return a - b;
+    }
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        assert(c >= a);
+        return c;
+    }
+}
+
+contract Pausable is Ownable {
+    event Paused(address account);
+    event Unpaused(address account);
+
+    bool private _paused;
+
+    modifier whenNotPaused() {
+        require(!_paused, "Pausable: paused");
+        _;
+    }
+
+    modifier whenPaused() {
+        require(_paused, "Pausable: not paused");
+        _;
+    }
+
+    function paused() public view returns (bool)
+    {
+        return _paused;
+    }
+
+    function pause() public onlyOwner whenNotPaused {
+        _paused = true;
+        emit Paused(msg.sender);
+    }
+
+    function unpause() public onlyOwner whenPaused {
+        _paused = false;
+        emit Unpaused(msg.sender);
+    }
+}
+
+contract ERC20 is Ownable, Pausable {
+    using SafeMath for uint;
+
+    string internal _name;
+    string internal _symbol;
+    uint8 internal _decimals;
+    uint256 internal _totalSupply;
+
+    mapping (address => uint256) internal _balances;
+    mapping (address => mapping (address => uint256)) internal _allowed;
+
+    event Mint(address indexed minter, address indexed account, uint256 amount);
+    event Burn(address indexed burner, address indexed account, uint256 amount);
+
+    constructor (string memory nameC, string memory symbolC, uint8 decimalsC, uint256 totalSupplyC) {
+        _symbol = symbolC;
+        _name = nameC;
+        _decimals = decimalsC;
+        _totalSupply = totalSupplyC;
+        _balances[msg.sender] = totalSupplyC;
+    }
+
+    function name() public view returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public view returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public view returns (uint8) {
+        return _decimals;
+    }
+
+    function totalSupply() public view returns (uint256) {
+        return _totalSupply;
+    }
+
+    function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
+        require(_to != address(0), 'ERC20: to address is not valid');
+        require(_value <= _balances[msg.sender], 'ERC20: insufficient balance');
+
+        _balances[msg.sender] = SafeMath.sub(_balances[msg.sender], _value);
+        _balances[_to] = SafeMath.add(_balances[_to], _value);
+
+        emit Transfer(msg.sender, _to, _value);
+
+        return true;
+    }
+
+    function balanceOf(address _owner) public view returns (uint256 balance) {
+        return _balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
+        _allowed[msg.sender][_spender] = _value;
+
+        emit Approval(msg.sender, _spender, _value);
+
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
+        require(_from != address(0), 'ERC20: from address is not valid');
+        require(_to != address(0), 'ERC20: to address is not valid');
+        require(_value <= _balances[_from], 'ERC20: insufficient balance');
+        require(_value <= _allowed[_from][msg.sender], 'ERC20: from not allowed');
+
+        _balances[_from] = SafeMath.sub(_balances[_from], _value);
+        _balances[_to] = SafeMath.add(_balances[_to], _value);
+        _allowed[_from][msg.sender] = SafeMath.sub(_allowed[_from][msg.sender], _value);
+
+        emit Transfer(_from, _to, _value);
+
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) public view whenNotPaused returns (uint256) {
+        return _allowed[_owner][_spender];
+    }
+
+    function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool) {
+        _allowed[msg.sender][_spender] = SafeMath.add(_allowed[msg.sender][_spender], _addedValue);
+
+        emit Approval(msg.sender, _spender, _allowed[msg.sender][_spender]);
+
+        return true;
+    }
+
+    function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool) {
+        uint oldValue = _allowed[msg.sender][_spender];
+
+        if (_subtractedValue > oldValue) {
+            _allowed[msg.sender][_spender] = 0;
+        } else {
+            _allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue);
+        }
+
+        emit Approval(msg.sender, _spender, _allowed[msg.sender][_spender]);
+
+        return true;
+    }
+
+    function mintTo(address _to, uint _amount) public whenNotPaused onlyOwner {
+        require(_to != address(0), 'ERC20: to address is not valid');
+        require(_amount > 0, 'ERC20: amount is not valid');
+
+        _totalSupply = _totalSupply.add(_amount);
+        _balances[_to] = _balances[_to].add(_amount);
+
+        emit Mint(msg.sender, _to, _amount);
+    }
+
+    function burnFrom(address _from, uint _amount) public whenNotPaused onlyOwner {
+        require(_from != address(0), 'ERC20: from address is not valid');
+        require(_balances[_from] >= _amount, 'ERC20: insufficient balance');
+
+        _balances[_from] = _balances[_from].sub(_amount);
+        _totalSupply = _totalSupply.sub(_amount);
+
+        emit Burn(msg.sender, _from, _amount);
+    }
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}

test-helper/src/fixtures/mod.rs

@@ -1,5 +1,7 @@
 pub const TEST_CONTRACT_PATH: &str = "./test-helper/src/fixtures/TestContract.sol";
 pub const TEST_CONTRACT_NAME: &str = "TestContract";
+pub const TEST_ERC20_PATH: &str = "./test-helper/src/fixtures/TestERC20.sol";
+pub const TEST_ERC20_NAME: &str = "ERC20";
 pub const ACCOUNTS_PASSWORD: &str = "12345678";
 pub const FIX_SECRET: &str = "fdc861959d1768d936bf17eec56260d4de3a7473e58c349e31beba539e5fc88d";
 pub const FIX_ADDRESS: &str = "0xDc677f7C5060B0b441d30F361D0c8529Ac04E099";