evm_client 0.1.0

data/contracts/GenericInterface.sol

@@ -0,0 +1,56 @@
+import "contracts/Directory.sol";
+import "contracts/DoublyLinked.sol";
+import "contracts/DigixConfiguration.sol";
+import "contracts/VendorRegistry.sol";
+import "contracts/CustodianRegistry.sol";
+import "contracts/AuditorRegistry.sol";
+
+contract GenericInterface {
+
+  address config;
+  address owner;
+
+  function getConfigAddress() public returns (address) {
+    return config;
+  }
+
+  function goldRegistry() public returns (address) {
+    return DigixConfiguration(config).getConfigEntryAddr("registry/gold");
+  }
+  
+  function vendorRegistry() public returns (address) {
+    return DigixConfiguration(config).getConfigEntryAddr("registry/vendor");
+  }
+  
+  function custodianRegistry() public returns (address) {
+    return DigixConfiguration(config).getConfigEntryAddr("registry/custodian");
+  }
+  
+  function auditorRegistry() public returns (address) {
+    return DigixConfiguration(config).getConfigEntryAddr("registry/auditor");
+  }
+
+  function isGoldRegistry(address _greg) public returns (bool) {
+    return (goldRegistry() == _greg);
+  }
+
+  function isCustodian(address _cust) public returns (bool) {
+    return CustodianRegistry(custodianRegistry()).isCustodian(_cust);
+  }
+
+  function isAuditor(address _adtr) public returns (bool) {
+    return AuditorRegistry(auditorRegistry()).isAuditor(_adtr);
+  }
+
+  function isVendor(address _vndr) public returns (bool) {
+    return VendorRegistry(vendorRegistry()).isVendor(_vndr);
+  }
+
+
+  modifier ifvendor { if(isVendor(msg.sender)) _ }
+  modifier ifowner { if(msg.sender == owner) _ }
+  modifier ifcustodian { if(isCustodian(msg.sender)) _ }
+  modifier ifauditor { if(isAuditor(msg.sender)) _ }
+  modifier ifgoldregistry { if(isGoldRegistry(msg.sender)) _ }
+
+}

data/contracts/GenericRegistry.sol

@@ -0,0 +1,15 @@
+contract GenericRegistry {
+
+  address config;
+
+  function isAdmin(address _acct) public returns (bool) {
+    return DigixConfiguration(config).isAdmin(_acct);
+  }
+
+  function getConfigAddress() public returns (address) {
+    return config;
+  }
+
+  modifier ifadmin { if(isAdmin(msg.sender)) _ }
+
+}

data/contracts/Gold.sol

@@ -0,0 +1,105 @@
+import "contracts/GenericInterface.sol";
+import "contracts/GoldRegistry.sol";
+
+contract Gold is GenericInterface {
+
+  uint256 weight;
+  uint256 serial;
+  uint256 lastStoragePayment;
+  uint256 base;
+  uint256 auditCount;
+  bool registered;
+  bool active;
+
+  modifier ifowner { if(owner == msg.sender) _ }
+  modifier ifcansend { if(canSend()) _ }
+  modifier ifunregistered { if(registered == false) _ }
+
+  event GoldAuditReport(bool indexed passed, address indexed document, address indexed auditor);
+
+  function Gold(address _conf, uint256 _wt) {
+    base = 1000000000;
+    owner = msg.sender;
+    config = _conf;
+    auditCount = 0;
+    weight = base * _wt;
+    registered = false;
+    active = false;
+    lastStoragePayment = block.timestamp;
+  }
+
+  function register(address _owner) ifgoldregistry  {
+    owner = _owner;
+  }
+
+  function activate() ifgoldregistry {
+    active = true;
+  }
+
+  function getCalculatedFees() public returns (uint256) {
+    uint256 _totalfee = 0;
+    uint256 _dayseconds = 60; // 86400 seconds buy for testing we set to one minute
+    uint256 _lp = lastStoragePayment;
+    uint256 _wt = weight;
+    uint256 _dailyRatePpb = getStorageRate();
+    uint256 _startRun = block.timestamp;
+    while ((_startRun - _lp) > _dayseconds) {
+      uint256 _calculatedFee = ((_wt * _dailyRatePpb) / base);
+      _wt -= _calculatedFee;
+      _totalfee += _calculatedFee;
+      _lp += _dayseconds;
+    }
+    return _totalfee;
+  }
+
+  function mint() ifowner ifcansend {
+     
+  }
+
+  function transferOwner(address _recipient) ifowner ifcansend {
+    owner = _recipient;
+  }
+
+  function getOwner() public returns (address) {
+    return owner;
+  }
+
+  function getLastStoragePayDate() public returns (uint256) {
+    return lastStoragePayment;
+  }
+
+  function getStorageRate() public returns (uint256) {
+    return DigixConfiguration(config).getConfigEntryInt("rates/storage");
+  }
+
+  function getWeightMinusFees() public returns (uint256) {
+    return (weight - getCalculatedFees());
+  }
+
+  function hasFees() public returns (bool) {
+    return (getCalculatedFees() > 0);
+  }
+
+  function isActive() public returns (bool) {
+    return active;
+  }
+
+  function isYellow() public returns (bool) {
+    uint256 daylength = 60;
+    return ((block.timestamp - lastStoragePayment) > (daylength * 30));
+  }
+  
+  function isRed() public returns (bool) {
+    uint256 daylength = 60;
+    return ((block.timestamp - lastStoragePayment) > (daylength * 90));
+  }
+
+  function canSend() public returns (bool) {
+    return (!isRed());
+  }
+  
+  function getWeight() public returns (uint256) {
+    return weight;
+  }
+
+}

data/contracts/GoldRegistry.sol

@@ -0,0 +1,82 @@
+import "contracts/DigixConfiguration.sol";
+import "contracts/GenericInterface.sol";
+import "contracts/Gold.sol";
+
+contract GoldRegistry is GenericInterface {
+ 
+  address config;
+
+  Directory.AddressBoolMap entries;
+  Directory.AddressAddressMap custodianPending;
+
+  struct Asset {
+    address vendor;
+    address custodian;
+    bytes32 vendorDoc;
+    bytes32 custodianDoc;
+  }
+
+  mapping (address => Directory.AddressBoolMap) vendorAssets;
+  mapping (address => Directory.AddressBoolMap) custodianAssets;
+  mapping (address => Asset) registeredAssets;
+
+  function GoldRegistry(address _conf) {
+    config = _conf;
+  }
+
+  event AddGold(address indexed gold, address indexed vendor);
+  event CustodianAssignment(address indexed gold, address indexed custodian, address indexed vendor);
+  event RemoveGold(address indexed gold, address indexed custodian);
+
+  function registerGold(address _gold, address _owner, bytes32 _doc) ifvendor {
+    if (!Directory.insert(entries, _gold)) throw;
+    if (!Directory.insert(vendorAssets[msg.sender], _gold)) throw;
+    Asset _asset = registeredAssets[_gold];
+    _asset.vendor = msg.sender;
+    _asset.vendorDoc = _doc;
+    Gold(_gold).register(_owner);
+  }
+
+  function isRegistered(address _gold) public returns (bool) {
+    return Directory.contains(entries, _gold);
+  }
+
+  function isVendorOf(address _gold, address _vndr) public returns (bool) {
+    return Directory.contains(vendorAssets[_vndr], _gold);
+  }
+
+  function isCustodianOf(address _gold, address _cstdn) public returns (bool) {
+    return Directory.contains(custodianAssets[_cstdn], _gold);
+  }
+
+  function delegateCustodian(address _gold, address _cstdn) ifvendor {
+    if (isVendorOf(_gold, msg.sender)) {
+      if (!Directory.insert(custodianPending, _gold, _cstdn)) throw;
+      CustodianAssignment(_gold, _cstdn, msg.sender);
+    }
+  }
+
+  function receiveFromVendor(address _gold, bytes32 _doc) ifcustodian {
+    if (Directory.containsAndMatches(custodianPending, _gold, msg.sender)) {
+      if (!Directory.remove(custodianPending, _gold)) throw;
+      if (!Directory.insert(custodianAssets[msg.sender], _gold)) throw; 
+      Asset _asset = registeredAssets[_gold];
+      _asset.custodian = msg.sender;
+      _asset.custodianDoc = _doc;
+      Gold(_gold).activate(); 
+    }
+  }
+
+  function submitAudit(address _gold, bytes32 _doc, bool _passed) ifauditor {
+
+  }
+
+  function requestRedemption(address _gold) ifowner {
+
+  }
+
+  function markRedeemed(address _gold) ifcustodian {
+
+  }
+
+}

data/contracts/GoldTokenLedger.sol

@@ -0,0 +1,3 @@
+contract GoldTokenLedger {
+
+}

data/contracts/Interface.sol

@@ -0,0 +1,27 @@
+import "contracts/GenericInterface.sol";
+
+contract Interface is GenericInterface {
+
+  address owner;
+
+  Directory.AddressBoolMap employees;
+
+  modifier ifowner { if(owner == msg.sender) _ }
+  modifier ifemployee { if(isEmployee(msg.sender)) _ }
+  modifier ifemployeeorigin { if(isEmployee(tx.origin)) _ }
+
+  function registerEmployee(address _acct) ifowner {
+    if (!Directory.insert(employees, _acct))
+      throw;
+  }
+
+  function unregisterEmployee(address _acct) ifowner {
+    if (!Directory.remove(employees, _acct))
+      throw;
+  }
+
+  function isEmployee(address _acct) public returns (bool) {
+    return Directory.contains(employees, _acct);
+  }
+
+}

data/contracts/Minter.sol

@@ -0,0 +1,3 @@
+contract Minter {
+
+}

data/contracts/Recaster.sol

@@ -0,0 +1,3 @@
+contract Recaster {
+
+}

data/contracts/Testing.sol

@@ -0,0 +1,59 @@
+import "contracts/AccountingLib.sol";
+
+contract TestAccounting {
+        AccountingLib.Bank bank;
+        /*
+         *  Account Management API
+         */
+        function getAccountBalance(address accountAddress) constant public returns (uint) {
+                return bank.accountBalances[accountAddress];
+        }
+
+        function deposit() public {
+                deposit(msg.sender);
+        }
+
+        function deposit(address accountAddress) public {
+                /*
+                 *  Public API for depositing funds in a specified account.
+                 */
+                AccountingLib.deposit(bank, accountAddress, msg.value);
+                AccountingLib.Deposit(msg.sender, accountAddress, msg.value);
+        }
+
+        function addFunds(uint value) public {
+                addFunds(msg.sender, value);
+        }
+
+        function addFunds(address accountAddress, uint value) public {
+                AccountingLib.addFunds(bank, accountAddress, value);
+        }
+
+        function withdraw(uint value) public {
+                /*
+                 *  Public API for withdrawing funds.
+                 */
+                if (AccountingLib.withdraw(bank, msg.sender, value)) {
+                        AccountingLib.Withdrawal(msg.sender, value);
+                }
+                else {
+                        AccountingLib.InsufficientFunds(msg.sender, value, bank.accountBalances[msg.sender]);
+                }
+        }
+
+        function deductFunds(uint value) public {
+                deductFunds(msg.sender, value);
+        }
+
+        function deductFunds(address accountAddress, uint value) public {
+                AccountingLib.deductFunds(bank, accountAddress, value);
+        }
+
+        function setAccountBalance(uint value) public {
+                setAccountBalance(msg.sender, value);
+        }
+
+        function setAccountBalance(address accountAddress, uint value) public {
+                bank.accountBalances[accountAddress] = value;
+        }
+}

data/contracts/VendorInterface.sol

@@ -0,0 +1,82 @@
+import "contracts/Interface.sol";
+import "contracts/Gold.sol";
+import "contracts/GoldRegistry.sol";
+import "contracts/DoublyLinked.sol";
+
+contract VendorInterface is Interface {
+
+  DoublyLinked.List openOrders;
+
+  enum OrderStatus { Open, Cancelled, Completed }
+
+  struct Order {
+    bytes32 sku;
+    address buyer;
+    uint status;
+  }
+
+  mapping (bytes32 => Order) orders;
+
+  function VendorInterface(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+  
+  function registerGold(address _asset, address _owner, bytes32 _doc) ifemployee {
+    GoldRegistry(goldRegistry()).registerGold(_asset, _owner, _doc);
+  }
+
+  function delegateCustodian(address _asset, address _cstdn) ifemployee {
+    GoldRegistry(goldRegistry()).delegateCustodian(_asset, _cstdn);
+  }
+
+  function append(bytes32 _data) {
+    DoublyLinked.append(openOrders, _data);
+  }
+
+  function createOrder(bytes32 _orderId, bytes32 _sku, address _buyer) {
+    Order _order = orders[_orderId];
+    _order.sku = _sku;
+    _order.buyer = _buyer;
+    _order.status = uint(OrderStatus.Open);
+    DoublyLinked.append(openOrders, _orderId);
+  }
+
+  function start() returns (uint80) {
+    return DoublyLinked.iterate_start(openOrders);
+  }
+
+  function getOrder(uint80 _idx) returns (bytes32 _orderId, bytes32 _sku, address _buyer) {
+    _orderId = DoublyLinked.iterate_get(openOrders, _idx);
+    _sku = orders[_orderId].sku;
+    _buyer = orders[_orderId].buyer;
+  }
+
+  function next(uint80 _idx) returns(uint80) {
+    return DoublyLinked.iterate_next(openOrders, _idx);
+  }
+    
+  function valid(uint80 _idx) returns(bool) {
+    return DoublyLinked.iterate_valid(openOrders, _idx);
+  }
+
+  function prev(uint80 _idx) returns(uint80) {
+    return DoublyLinked.iterate_prev(openOrders, _idx);
+  }
+
+  function processOrder(bytes32 _orderId) returns (bool success) {
+    var it = DoublyLinked.iterate_start(openOrders);
+    while (DoublyLinked.iterate_valid(openOrders, it)) {
+      if (DoublyLinked.iterate_get(openOrders, it) == _orderId) {
+        DoublyLinked.remove(openOrders, it);
+        orders[_orderId].status = uint(OrderStatus.Completed);
+        return true;
+      }
+      it = DoublyLinked.iterate_next(openOrders, it);
+    }
+    return false;
+  }
+
+}
+
+