init

Author: Radek Ostrowski

.gitignore

@@ -0,0 +1,5 @@
+build
+node_modules
+.DS_Store
+*.sublime-project
+*.sublime-workspace

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Radek Ostrowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,76 @@
+# Time Locked Wallet
+
+
+
+## Setup Environment
+Firstly, install [Node](https://nodejs.org/en/) and [Git](https://git-scm.com/) on your machine.
+Once it's done install Truffle with:
+```
+npm install -g truffle
+```
+
+Now, get the code:
+```
+git clone https://github.com/radek1st/time-locked-wallets 
+cd time-locked-wallet-contract
+```
+
+## Contract Development
+
+Start Truffle Console and Compile/Deploy/Test
+
+To get started quickly run Truffle with inbuilt blockchain:
+```
+truffle develop
+```
+Alternatively, install and start [Ganache](http://truffleframework.com/ganache/) 
+which comes with a nice UI to the local blockchain and then connect to it with:
+```
+truffle --network ganache console
+```
+
+To compile the contracts run:
+```
+> compile
+```
+To deploy the contracts run:
+```
+> migrate
+```
+To run the tests:
+```
+> test
+```
+
+## Contract Interaction with ÐApp 
+
+### Install and Configure MetaMask extension
+
+Install [MetaMask](https://metamask.io/) in your Chrome browser.
+
+
+Import the wallet seed from the testnet (should be something like):
+```
+candy maple cake sugar pudding cream honey rich smooth crumble sweet treat
+```
+
+Select Network: 
+* for default use `http://localhost:9545`
+* for Ganache use `http://localhost:7545`
+
+### Run ÐApp
+To see the Time Locked Wallet in action, start the web server locally:
+```
+npm run dev
+```
+It should automatically open the browser at `http://localhost:XXXX`
+
+
+You can then interact with the contract form the web UI and switch the accounts in MetaMask.
+
+
+
+### Other ideas
+
+* multisig wallet/will -- children&partner must agree,
+* give a signed message to withdraw the money, doesn't have to be address, could be just the signed message

blog/screenshots/MetaMask-accounts.png

@@ -0,0 +1,5 @@
+{
+  "server": {
+    "baseDir": ["./src", "./build/contracts"]
+  }
+}

blog/screenshots/MetaMask-bob-has-more-ether.png

@@ -0,0 +1,19 @@
+pragma solidity ^0.4.18;
+
+
+/**
+ * @title ERC20
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+contract ERC20 {
+  uint256 public totalSupply;
+
+  function balanceOf(address who) public view returns (uint256);
+  function transfer(address to, uint256 value) public returns (bool);
+  function allowance(address owner, address spender) public view returns (uint256);
+  function transferFrom(address from, address to, uint256 value) public returns (bool);
+  function approve(address spender, uint256 value) public returns (bool);
+
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+  event Transfer(address indexed from, address indexed to, uint256 value);
+}

blog/screenshots/MetaMask-custom-network.png

@@ -0,0 +1,23 @@
+pragma solidity ^0.4.2;
+
+contract Migrations {
+    address public owner;
+    uint public last_completed_migration;
+
+    modifier restricted() {
+        if (msg.sender == owner) _;
+    }
+
+    function Migrations() public {
+        owner = msg.sender;
+    }
+
+    function setCompleted(uint completed) restricted public {
+        last_completed_migration = completed;
+    }
+
+    function upgrade(address new_address) restricted public {
+        Migrations upgraded = Migrations(new_address);
+        upgraded.setCompleted(last_completed_migration);
+    }
+}

blog/screenshots/MetaMask-import-seed.png

@@ -0,0 +1,35 @@
+pragma solidity ^0.4.18;
+
+
+/**
+ * @title SafeMath
+ * @dev Math operations with safety checks that throw on error
+ */
+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) {
+    // assert(b > 0); // Solidity automatically throws when dividing by 0
+    uint256 c = a / b;
+    // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+    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;
+  }
+}

blog/screenshots/created-locked-wallet.png

@@ -0,0 +1,58 @@
+pragma solidity ^0.4.18;
+
+import "./ERC20.sol";
+
+contract TimeLockedWallet {
+
+    address public creator;
+    address public owner;
+    uint public unlockDate;
+    uint public createdAt;
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+        _;
+    }
+
+    function TimeLockedWallet(
+        address _creator,
+        address _owner,
+        uint _unlockDate
+    ) public {
+        creator = _creator;
+        owner = _owner;
+        unlockDate = _unlockDate;
+        createdAt = now;
+    }
+
+    // keep all the ether sent to this address
+    function() payable public { 
+        Received(msg.sender, msg.value);
+    }
+
+    // callable by owner only, after specified time
+    function withdraw() onlyOwner public {
+       require(now >= unlockDate);
+       //now send all the balance
+       msg.sender.transfer(this.balance);
+       Withdrew(msg.sender, this.balance);
+    }
+
+    // callable by owner only, after specified time, only for Tokens implementing ERC20
+    function withdrawTokens(address _tokenContract) onlyOwner public {
+       require(now >= unlockDate);
+       ERC20 token = ERC20(_tokenContract);
+       //now send all the token balance
+       uint tokenBalance = token.balanceOf(this);
+       token.transfer(owner, tokenBalance);
+       WithdrewTokens(_tokenContract, msg.sender, tokenBalance);
+    }
+
+    function info() public view returns(address, address, uint, uint, uint) {
+        return (creator, owner, unlockDate, createdAt, this.balance);
+    }
+
+    event Received(address from, uint amount);
+    event Withdrew(address to, uint amount);
+    event WithdrewTokens(address tokenContract, address to, uint amount);
+}

blog/screenshots/wallet-balance-after-topup-alice.png

@@ -0,0 +1,46 @@
+pragma solidity ^0.4.18;
+
+import "./TimeLockedWallet.sol";
+
+contract TimeLockedWalletFactory {
+ 
+    mapping(address => address[]) wallets;
+
+    function getWallets(address _user) 
+        public
+        view
+        returns(address[])
+    {
+        return wallets[_user];
+    }
+
+    function newTimeLockedWallet(address _owner, uint _unlockDate)
+        payable
+        public
+        returns(address wallet)
+    {
+        // Create new wallet.
+        wallet = new TimeLockedWallet(msg.sender, _owner, _unlockDate);
+        
+        // Add wallet to sender's wallets.
+        wallets[msg.sender].push(wallet);
+
+        // If owner is the same as sender then add wallet to sender's wallets too.
+        if(msg.sender != _owner){
+            wallets[_owner].push(wallet);
+        }
+
+        // Send ether from this transaction to the created contract.
+        wallet.transfer(msg.value);
+
+        // Emit event.
+        Created(wallet, msg.sender, _owner, now, _unlockDate, msg.value);
+    }
+
+    // Prevents accidental sending of ether to the factory
+    function () public {
+        revert();
+    }
+
+    event Created(address wallet, address from, address to, uint createdAt, uint unlockDate, uint amount);
+}

blog/screenshots/wallet-balance-after-topup-bob-locked.png

@@ -0,0 +1,97 @@
+pragma solidity ^0.4.18;
+
+import './SafeMath.sol';
+import './ERC20.sol';
+
+/**
+ * @title Toptal token
+ */
+
+contract ToptalToken is ERC20 {
+  using SafeMath for uint256;
+
+  mapping(address => uint256) balances;
+  mapping (address => mapping (address => uint256)) internal allowed;
+
+  string public name = "Toptal Token";
+  string public symbol = "TTT";
+  uint8 public decimals = 6;
+  uint256 public totalSupply = 1000000000000;
+
+  function ToptalToken() public {
+    balances[msg.sender] = totalSupply;
+  }
+
+  /**
+  * @dev Gets the balance of the specified address.
+  * @param _owner The address to query the the balance of.
+  * @return An uint256 representing the amount owned by the passed address.
+  */
+  function balanceOf(address _owner) public view returns (uint256 balance) {
+    return balances[_owner];
+  }
+
+  /**
+  * @dev transfer token for a specified address
+  * @param _to The address to transfer to.
+  * @param _value The amount to be transferred.
+  */
+  function transfer(address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[msg.sender]);
+
+    // SafeMath.sub will throw if there is not enough balance.
+    balances[msg.sender] = balances[msg.sender].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    Transfer(msg.sender, _to, _value);
+    return true;
+  }
+
+  /**
+   * @dev Transfer tokens from one address to another
+   * @param _from address The address which you want to send tokens from
+   * @param _to address The address which you want to transfer to
+   * @param _value uint256 the amount of tokens to be transferred
+   */
+  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
+    require(_to != address(0));
+    require(_value <= balances[_from]);
+    require(_value <= allowed[_from][msg.sender]);
+
+    balances[_from] = balances[_from].sub(_value);
+    balances[_to] = balances[_to].add(_value);
+    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
+    Transfer(_from, _to, _value);
+    return true;
+  }
+
+  /**
+   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
+   *
+   * Beware that changing an allowance with this method brings the risk that someone may use both the old
+   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
+   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
+   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+   * @param _spender The address which will spend the funds.
+   * @param _value The amount of tokens to be spent.
+   */
+  function approve(address _spender, uint256 _value) public returns (bool) {
+    allowed[msg.sender][_spender] = _value;
+    Approval(msg.sender, _spender, _value);
+    return true;
+  }
+
+  /**
+   * @dev Function to check the amount of tokens that an owner allowed to a spender.
+   * @param _owner address The address which owns the funds.
+   * @param _spender address The address which will spend the funds.
+   * @return A uint256 specifying the amount of tokens still available for the spender.
+   */
+  function allowance(address _owner, address _spender) public view returns (uint256) {
+    return allowed[_owner][_spender];
+  }
+
+  event Transfer(address indexed from, address indexed to, uint256 value);
+  event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+