ethereum.rb 1.6.0

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; }
+}

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;
+  }
+
+}