evm_client 0.1.0

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+import "./lib/tasks/ethereum_test.rake"
+import "./lib/tasks/ethereum_node.rake"
+import "./lib/tasks/ethereum_contract.rake"
+import "./lib/tasks/ethereum_transaction.rake"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'evm_client'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/install_parity

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+echo "Installing parity..."
+sudo add-apt-repository ppa:ethereum/ethereum -y
+sudo apt-get update
+sudo apt-get -y install dpkg
+sudo apt-get -y install libssl-dev
+curl -o /usr/bin/solc -fL https://github.com/ethereum/solidity/releases/download/v0.5.16/solc-static-linux \
+     && chmod 775 /usr/bin/solc \
+     && chown travis:travis /usr/bin/solc
+echo "Solc version"
+solc --version
+
+wget https://releases.parity.io/ethereum/v$PARITY\/x86_64-unknown-linux-gnu/parity
+chmod u+x parity
+chown travis:travis parity
+
+echo "Setuping parity..."
+mkdir -p ~/.local/share/io.parity.ethereum/keys/DevelopmentChain
+chown -R travis:travis ~/.local/share/io.parity.ethereum
+echo $devwallet > ~/.local/share/io.parity.ethereum/keys/DevelopmentChain/UTC--2017-03-31T14-19-47Z--c05e3b8b-18aa-ab4f-c5ec-09f555bf5357
+echo $devpassword > ~/.devpass

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/contracts/AccountingLib.sol

@@ -0,0 +1,112 @@
+// Accounting v0.1
+
+/// @title Accounting Lib - Accounting utilities
+/// @author Piper Merriam - <pipermerriam@gmail.com>
+library AccountingLib {
+        struct Bank {
+            mapping (address => uint) accountBalances;
+        }
+
+        /// @dev Low level method for adding funds to an account.  Protects against overflow.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be added to.
+        /// @param value The amount that should be added to the account.
+        function addFunds(Bank storage self, address accountAddress, uint value) public {
+                /*
+                 *  Helper function that should be used for any addition of
+                 *  account funds.  It has error checking to prevent
+                 *  overflowing the account balance.
+                 */
+                if (self.accountBalances[accountAddress] + value < self.accountBalances[accountAddress]) {
+                        // Prevent Overflow.
+                        throw;
+                }
+                self.accountBalances[accountAddress] += value;
+        }
+
+        event _Deposit(address indexed _from, address indexed accountAddress, uint value);
+
+        /// @dev Function wrapper around the _Deposit event so that it can be used by contracts.  Can be used to log a deposit to an account.
+        /// @param _from The address that deposited the funds.
+        /// @param accountAddress The address of the account the funds were added to.
+        /// @param value The amount that was added to the account.
+        function Deposit(address _from, address accountAddress, uint value) public {
+            _Deposit(_from, accountAddress, value);
+        }
+
+        /// @dev Safe function for depositing funds.  Returns boolean for whether the deposit was successful
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be added to.
+        /// @param value The amount that should be added to the account.
+        function deposit(Bank storage self, address accountAddress, uint value) public returns (bool) {
+                /*
+                 *  Public API for depositing funds in a specified account.
+                 */
+                if (self.accountBalances[accountAddress] + value < self.accountBalances[accountAddress]) {
+                        return false;
+                }
+                addFunds(self, accountAddress, value);
+                return true;
+        }
+
+        event _Withdrawal(address indexed accountAddress, uint value);
+
+        /// @dev Function wrapper around the _Withdrawal event so that it can be used by contracts.  Can be used to log a withdrawl from an account.
+        /// @param accountAddress The address of the account the funds were withdrawn from.
+        /// @param value The amount that was withdrawn to the account.
+        function Withdrawal(address accountAddress, uint value) public {
+            _Withdrawal(accountAddress, value);
+        }
+
+        event _InsufficientFunds(address indexed accountAddress, uint value, uint balance);
+
+        /// @dev Function wrapper around the _InsufficientFunds event so that it can be used by contracts.  Can be used to log a failed withdrawl from an account.
+        /// @param accountAddress The address of the account the funds were to be withdrawn from.
+        /// @param value The amount that was attempted to be withdrawn from the account.
+        /// @param balance The current balance of the account.
+        function InsufficientFunds(address accountAddress, uint value, uint balance) public {
+            _InsufficientFunds(accountAddress, value, balance);
+        }
+
+        /// @dev Low level method for removing funds from an account.  Protects against underflow.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be deducted from.
+        /// @param value The amount that should be deducted from the account.
+        function deductFunds(Bank storage self, address accountAddress, uint value) public {
+                /*
+                 *  Helper function that should be used for any reduction of
+                 *  account funds.  It has error checking to prevent
+                 *  underflowing the account balance which would be REALLY bad.
+                 */
+                if (value > self.accountBalances[accountAddress]) {
+                        // Prevent Underflow.
+                        throw;
+                }
+                self.accountBalances[accountAddress] -= value;
+        }
+
+        /// @dev Safe function for withdrawing funds.  Returns boolean for whether the deposit was successful as well as sending the amount in ether to the account address.
+        /// @param self The Bank instance to operate on.
+        /// @param accountAddress The address of the account the funds should be withdrawn from.
+        /// @param value The amount that should be withdrawn from the account.
+        function withdraw(Bank storage self, address accountAddress, uint value) public returns (bool) {
+                /*
+                 *  Public API for withdrawing funds.
+                 */
+                if (self.accountBalances[accountAddress] >= value) {
+                        deductFunds(self, accountAddress, value);
+                        if (!accountAddress.send(value)) {
+                                // Potentially sending money to a contract that
+                                // has a fallback function.  So instead, try
+                                // tranferring the funds with the call api.
+                                if (!accountAddress.call.value(value)()) {
+                                        // Revert the entire transaction.  No
+                                        // need to destroy the funds.
+                                        //throw;
+                                }
+                        }
+                        return true;
+                }
+                return false;
+        }
+}

data/contracts/AuditorInterface.sol

@@ -0,0 +1,4 @@
+contract AuditorInterface {
+  // publish audit on asset 
+  // publish audit on holdings 
+}

data/contracts/AuditorRegistry.sol

@@ -0,0 +1,14 @@
+contract AuditorRegistry {
+
+  address config;
+  Directory.AddressBoolMap auditors;
+
+  function CustodianRegistry(address _conf) {
+    config = _conf;
+  }
+
+  function isAuditor(address _audt) public returns (bool) {
+    return Directory.contains(auditors, _audt);
+  }
+}
+

data/contracts/CustodianInterface.sol

@@ -0,0 +1,27 @@
+import "contracts/Interface.sol";
+import "contracts/Gold.sol";
+import "contracts/GoldRegistry.sol";
+
+contract CustodianInterface is Interface {
+
+  function CustodianInterface(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+
+  function receiveFromVendor(address _gold, bytes32 _doc) ifemployee {
+    GoldRegistry(goldRegistry()).receiveFromVendor(_gold, _doc);
+  }
+
+  function transferCustodian(address _gold, address _cstdn) ifemployee {
+  }
+  
+  function isRedeemable(address _gold) public returns (bool) {
+    return true;
+  }
+
+}
+
+
+
+

data/contracts/CustodianRegistry.sol

@@ -0,0 +1,40 @@
+import "contracts/Directory.sol";
+import "contracts/GenericRegistry.sol";
+
+contract CustodianRegistry is GenericRegistry {
+
+  Directory.AddressBoolMap custodians;
+
+  struct Custodian {
+    bytes32 name;
+  }
+
+  mapping (address => Custodian) custodianNames;
+
+  function CustodianRegistry(address _conf) {
+    config = _conf;
+  }
+  
+  function register(address _acct) ifadmin {
+    if (!Directory.insert(custodians, _acct))
+      throw;
+  }
+
+  function unregister(address _acct) ifadmin {
+    if (!Directory.remove(custodians, _acct))
+      throw;
+  }
+
+  function setCustodianName(address _cstdn, bytes32 _name) ifadmin {
+    custodianNames[_cstdn].name = _name;
+  }
+
+  function getCustodianName(address _cstdn) public returns (bytes32) {
+    return custodianNames[_cstdn].name;
+  }
+
+  function isCustodian(address _cust) public returns (bool) {
+    return Directory.contains(custodians, _cust);
+  }
+
+}

data/contracts/DigixConfiguration.sol

@@ -0,0 +1,68 @@
+contract DigixConfiguration {
+  
+  address owner;
+  Directory.AddressBoolMap admins;
+
+  mapping (bytes32 => address) configaddr;
+  mapping (bytes32 => uint256) configint;
+
+  event SetOwner(address indexed owner, address indexed by);
+  event AddConfigEntryA(bytes32 indexed key, address indexed val, address indexed by);
+  event AddConfigEntryI(bytes32 indexed key, uint256 indexed val, address indexed by);
+  event RegisterAdmin(address indexed account, address indexed by);
+  event UnregisterAdmin(address indexed account, address indexed by);
+
+  function DigixConfiguration() {
+    owner = msg.sender;
+  }
+
+  modifier ifowner { if(msg.sender == owner) _ }
+  modifier ifadmin { if((msg.sender == owner) || isAdmin(msg.sender)) _ }
+
+  function getOwner() public constant returns (address) {
+    return owner;
+  }
+
+  function setOwner(address _newowner) ifowner {
+    address _oldaddress = owner;
+    owner = _newowner;
+    SetOwner(_newowner, msg.sender);
+  }
+
+  function addConfigEntryAddr(bytes32 _key, address _val) ifowner {
+    address _oldaddress = configaddr[_key];
+    configaddr[_key] = _val;
+    AddConfigEntryA(_key, _val, msg.sender);
+  }
+
+  function getConfigEntryAddr(bytes32 _key) public constant returns (address) {
+    return configaddr[_key];
+  }
+
+  function addConfigEntryInt(bytes32 _key, uint256 _val) ifowner {
+    uint256 _oldaddress = configint[_key];
+    configint[_key] = _val;
+    AddConfigEntryI(_key, _val, msg.sender);
+  }
+
+  function getConfigEntryInt(bytes32 _key) public constant returns (uint256) {
+    return configint[_key];
+  }
+  
+  function registerAdmin(address _acct) ifowner {
+    if (!Directory.insert(admins, _acct))
+      throw;
+    RegisterAdmin(_acct, msg.sender);
+  }
+
+  function unregisterAdmin(address _acct) ifowner {
+    if (!Directory.remove(admins, _acct))
+      throw;
+    UnregisterAdmin(_acct, msg.sender);
+  }
+
+  function isAdmin(address _acct) public returns (bool) {
+    return Directory.contains(admins, _acct);
+  }
+
+}

data/contracts/Directory.sol

@@ -0,0 +1,67 @@
+library Directory {
+
+  struct AddressBytesMap { mapping(address => bytes32) bytesentries; }
+
+  struct AddressAddressMap { mapping(address => address) addrentries; }
+
+  struct AddressBoolMap { mapping(address => bool) boolentries; }
+
+  function insert(AddressBytesMap storage self, address key, bytes32 val) returns (bool) {
+    if (self.bytesentries[key] == val) return false;
+    self.bytesentries[key] = val;
+    return true;
+  }
+
+  function insert(AddressBoolMap storage self, address key) returns (bool) {
+    if (self.boolentries[key]) return false; 
+    self.boolentries[key] = true;
+    return true;
+  }
+
+  function insert(AddressAddressMap storage self, address key, address val) returns (bool) {
+    if (self.addrentries[key] == val) return false;
+    self.addrentries[key] = val;
+    return true;
+  }
+
+  function remove(AddressBytesMap storage self, address key) returns (bool) {
+    if (self.bytesentries[key] == 0x0) return false;
+    self.bytesentries[key] = 0x0;
+    return true;
+  }
+
+  function remove(AddressBoolMap storage self, address key) returns (bool) {
+    if (!self.boolentries[key]) return false;
+    self.boolentries[key] = false;
+    return true;
+  }
+
+  function remove(AddressAddressMap storage self, address key) returns (bool) {
+    if (self.addrentries[key] == 0x0000000000000000000000000000000000000000) return false;
+    self.addrentries[key] = 0x0000000000000000000000000000000000000000;
+    return true;
+  }
+  
+  function contains(AddressBytesMap storage self, address key) returns (bool) {
+    if (self.bytesentries[key] != 0x0) return true;
+  }
+
+  function contains(AddressBoolMap storage self, address key) returns (bool) {
+    return self.boolentries[key];
+  }
+
+  function contains(AddressAddressMap storage self, address key) returns (bool) {
+    if (self.addrentries[key] != 0x0000000000000000000000000000000000000000) return true;
+  }
+  
+  function containsAndMatches(AddressBytesMap storage self, address key, bytes32 val) returns (bool) {
+    return (self.bytesentries[key] == val);
+  }
+
+  function containsAndMatches(AddressAddressMap storage self, address key, address val) returns (bool) {
+    return (self.addrentries[key] == val);
+  }
+
+}
+
+

data/contracts/DoublyLinked.sol

@@ -0,0 +1,54 @@
+library DoublyLinked {
+
+    struct List {
+        uint80 first;
+        uint80 last;
+        uint80 count;
+        Item[] items;
+    }
+
+    uint80 constant None = uint80(-1);
+
+    struct Item {
+        uint80 prev;
+        uint80 next;
+        bytes32 data;
+    }
+    
+    function append(List storage self, bytes32 _data) {
+        var index = self.items.push(Item({prev: self.last, next: None, data: _data}));
+        if (self.last == None)
+        {
+            if (self.first != None || self.count != 0) throw;
+            self.first = self.last = uint80(index - 1);
+            self.count = 1;
+        }
+        else
+        {
+            self.items[self.last].next = uint80(index - 1);
+            self.last = uint80(index - 1);
+            self.count ++;
+        }
+    }
+
+    function remove(List storage self, uint80 _index) {
+        Item item = self.items[_index];
+        if (item.prev == None)
+            self.first = item.next;
+        if (item.next == None)
+            self.last = item.prev;
+        if (item.prev != None)
+            self.items[item.prev].next = item.next;
+        if (item.next != None)
+            self.items[item.next].prev = item.prev;
+        delete self.items[_index];
+        self.count++;
+    }
+
+    // Iterator interface
+    function iterate_start(List storage self) returns (uint80) { return self.first; }
+    function iterate_valid(List storage self, uint80 _index) returns (bool) { return _index < self.items.length; }
+    function iterate_prev(List storage self, uint80 _index) returns (uint80) { return self.items[_index].prev; }
+    function iterate_next(List storage self, uint80 _index) returns (uint80) { return self.items[_index].next; }
+    function iterate_get(List storage self, uint80 _index) returns (bytes32) { return self.items[_index].data; }
+}