ethereum 0.4.75 → 0.4.80

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6bb10ccfec4471254525b2538450d6492044de6
-  data.tar.gz: b6fef10e3dc5e5d9c17cf26159564fe958c573fd
+  metadata.gz: befea2e8d4a0984de8d00db21e1d3e8069ae444b
+  data.tar.gz: 224ac503b98fe2c838538648b7034d7cd78b69eb
 SHA512:
-  metadata.gz: ae2359b73d4d98165c24a8fedf46ada020fea6d052163359963f3b778ae6508401ee6314a308ebdbee6b33274a7a609ee6fd8fe2e7e5970f9153b2e4be56593a
-  data.tar.gz: 1a80d14ae38d9d835c9d77aa5669bc25d8aa4767570c1fbf3e23a0cc9f1f680e53190fc7c844cd5c3487aa36eb788d6a1d5b5b30e812ac45afd4fd1e55ada99e
+  metadata.gz: 213fec4859c390068a7d6e0f9dd0cb262f6e05f23bb61cc02d0236e1475f3fabc01c28c6976731ee83440ed4e86761d9378ecb8a4ff4080279e7f9233f66eda5
+  data.tar.gz: 689c5d782fca556d657d24a49d4e06edad39c2cca80e12889517cf9543ccd0bd05bb440482fbeb13aefff9044b22716f698fbc61cc89d5479cc0114106b01d18

data/contracts/AuditorRegistry.sol

@@ -1,7 +1,7 @@
 contract AuditorRegistry {
 
   address config;
-  Directory.Data auditors;
+  Directory.AddressBoolMap auditors;
 
   function CustodianRegistry(address _conf) {
     config = _conf;

data/contracts/CustodianInterface.sol

@@ -1,4 +1,6 @@
 import "contracts/Interface.sol";
+import "contracts/Gold.sol";
+import "contracts/GoldRegistry.sol";
 
 contract CustodianInterface is Interface {
 
@@ -6,11 +8,14 @@ contract CustodianInterface is Interface {
     owner = msg.sender;
     config = _config;
   }
-  
-  function publishReceipt(address _gold, bytes32 _file) ifemployee {
-    
+
+  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

@@ -1,11 +1,37 @@
-contract CustodianRegistry {
+import "contracts/Directory.sol";
+import "contracts/GenericRegistry.sol";
 
-  address config;
-  Directory.Data custodians;
+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

@@ -1,12 +1,14 @@
 contract DigixConfiguration {
   
   address owner;
-  Directory.Data admins;
+  Directory.AddressBoolMap admins;
 
-  mapping (bytes32 => address) configurations;
+  mapping (bytes32 => address) configaddr;
+  mapping (bytes32 => uint256) configint;
 
   event SetOwner(address indexed owner, address indexed by);
-  event AddConfigEntry(bytes32 indexed key, address indexed val, 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);
 
@@ -27,14 +29,24 @@ contract DigixConfiguration {
     SetOwner(_newowner, msg.sender);
   }
 
-  function addConfigEntry(bytes32 _key, address _val) ifowner {
-    address _oldaddress = configurations[_key];
-    configurations[_key] = _val;
-    AddConfigEntry(_key, _val, msg.sender);
+  function addConfigEntryAddr(bytes32 _key, address _val) ifowner {
+    address _oldaddress = configaddr[_key];
+    configaddr[_key] = _val;
+    AddConfigEntryA(_key, _val, msg.sender);
   }
 
-  function getConfigEntry(bytes32 _key) public constant returns (address) {
-    return configurations[_key];
+  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 {

data/contracts/Directory.sol

@@ -1,23 +1,65 @@
 library Directory {
 
-  struct Data { mapping(address => bool) entries; }
+  struct AddressBytesMap { mapping(address => bytes32) bytesentries; }
 
-  function insert(Data storage self, address acct) returns (bool) {
-    if (self.entries[acct])
-      return false; 
-    self.entries[acct] = true;
+  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(Data storage self, address acct) returns (bool) {
-    if (!self.entries[acct])
-      return false;
-    self.entries[acct] = false;
+  function remove(AddressBoolMap storage self, address key) returns (bool) {
+    if (!self.boolentries[key]) return false;
+    self.boolentries[key] = false;
     return true;
   }
 
-  function contains(Data storage self, address acct) returns (bool) {
-    return self.entries[acct];
+  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

@@ -1,67 +1,105 @@
-contract Gold {
+import "contracts/GenericInterface.sol";
+import "contracts/GoldRegistry.sol";
 
-  address config;
-  address owner;
-  uint lastfeecalc;
-  bool locked;
+contract Gold is GenericInterface {
 
-  struct Detail {
-    address vendor;
-    address custodian;
-    uint status;
-    uint auditCount;
+  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;
   }
 
-  struct Info {
-    uint weight;
-    bytes32 serialNumber;
-    bytes32 vendorReceipt;
-    bytes32 custodianReceipt;
+  function register(address _owner) ifgoldregistry  {
+    owner = _owner;
   }
 
-  struct StorageFee {
-    uint due;
-    uint lastPayment;
+  function activate() ifgoldregistry {
+    active = true;
   }
 
-  Detail detail;
-  Info info;
-  StorageFee storagefee;
+  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;
+  }
 
-  modifier ifowner { if(owner == msg.sender) _ }
+  function mint() ifowner ifcansend {
+     
+  }
 
-  event GoldAuditReport(bool indexed passed, address indexed document, address indexed auditor);
+  function transferOwner(address _recipient) ifowner ifcansend {
+    owner = _recipient;
+  }
 
-  function Gold(uint _wt) {
-    owner = msg.sender;
-    detail.auditCount = 0;
-    detail.vendor = msg.sender;
-    info.weight = _wt;
-    storagefee.lastPayment = block.timestamp;
+  function getOwner() public returns (address) {
+    return owner;
+  }
+
+  function getLastStoragePayDate() public returns (uint256) {
+    return lastStoragePayment;
   }
 
-  function lastCalculation() public returns (uint) {
-    return storagefee.lastPayment;
+  function getStorageRate() public returns (uint256) {
+    return DigixConfiguration(config).getConfigEntryInt("rates/storage");
   }
 
-  function timeSinceLastCalc() public returns (uint) {
-    return (block.timestamp - storagefee.lastPayment);
+  function getWeightMinusFees() public returns (uint256) {
+    return (weight - getCalculatedFees());
   }
 
-  function mathTestDiv(uint _a, uint _b) public returns (uint) {
-    return (_a / _b);
+  function hasFees() public returns (bool) {
+    return (getCalculatedFees() > 0);
   }
 
-  function calculateFee(uint _days) public returns (uint) {
-    uint base = 1000000000000;
-    uint dailyRate = 10277777777;
-    var rate = dailyRate * _days;
-    var fee = (rate * info.weight);
-    return ((info.weight * base) - fee);
+  function isActive() public returns (bool) {
+    return active;
   }
 
-  function mathTestMul(uint _a, uint _b) public returns (uint) {
-    return (_a * _b);
+  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

@@ -1,48 +1,81 @@
 import "contracts/DigixConfiguration.sol";
-import "contracts/Directory.sol";
-import "contracts/VendorRegistry.sol";
-import "contracts/CustodianRegistry.sol";
-import "contracts/AuditorRegistry.sol";
+import "contracts/GenericInterface.sol";
+import "contracts/Gold.sol";
 
-contract GoldRegistry {
+contract GoldRegistry is GenericInterface {
  
   address config;
 
-  Directory.Data active;
+  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;
   }
 
-  modifier ifvendor { if(isVendor(msg.sender)) _ }
-  modifier ifcustodian { if(isCustodian(msg.sender)) _ }
-  modifier ifauditor { if(isAuditor(msg.sender)) _ }
+  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 vendorRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/vendor");
+  function isVendorOf(address _gold, address _vndr) public returns (bool) {
+    return Directory.contains(vendorAssets[_vndr], _gold);
   }
 
-  function custodianRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/custodian");
+  function isCustodianOf(address _gold, address _cstdn) public returns (bool) {
+    return Directory.contains(custodianAssets[_cstdn], _gold);
   }
-  
-  function auditorRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/auditor");
+
+  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 isVendor(address _vend) public returns (bool) {
-    return VendorRegistry(vendorRegistry()).isVendor(_vend);
+  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 isCustodian(address _cust) public returns (bool) {
-    return CustodianRegistry(custodianRegistry()).isCustodian(_cust);
+
+  function submitAudit(address _gold, bytes32 _doc, bool _passed) ifauditor {
+
   }
-  
-  function isAuditor(address _audt) public returns (bool) {
-    return AuditorRegistry(custodianRegistry()).isAuditor(_audt);
+
+  function requestRedemption(address _gold) ifowner {
+
   }
 
-  function registerGold(address _gold) {
+  function markRedeemed(address _gold) ifcustodian {
 
   }
 

data/contracts/Interface.sol

@@ -1,16 +1,14 @@
-import "contracts/VendorRegistry.sol";
-import "contracts/CustodianRegistry.sol";
-import "contracts/AuditorRegistry.sol";
+import "contracts/GenericInterface.sol";
 
-contract Interface {
+contract Interface is GenericInterface {
 
   address owner;
-  address config;
 
-  Directory.Data employees;
+  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))
@@ -26,32 +24,4 @@ contract Interface {
     return Directory.contains(employees, _acct);
   }
 
-  function goldRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/gold");
-  }
-  
-  function vendorRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/vendor");
-  }
-  
-  function custodianRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/custodian");
-  }
-  
-  function auditorRegistry() public returns (address) {
-    return DigixConfiguration(config).getConfigEntry("registry/auditor");
-  }
-
-  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);
-  }
-
 }

data/contracts/VendorInterface.sol

@@ -1,23 +1,80 @@
 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) ifemployee {
-    var b = _asset;
+  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 uploadReceipt(address _asset, bytes32 _ipfsHash) ifemployee {
+  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 assignCustodian(address _asset, address _custodian) ifemployee {
+  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;
   }
 
 }

data/contracts/VendorRegistry.sol

@@ -1,10 +1,8 @@
-import "contracts/DigixConfiguration.sol";
-import "contracts/Directory.sol";
+import "contracts/GenericRegistry.sol";
 
-contract VendorRegistry {
+contract VendorRegistry is GenericRegistry {
 
-  address config;
-  Directory.Data vendors;
+  Directory.AddressBoolMap vendors;
 
   struct Vendor {
     bytes32 name;
@@ -12,20 +10,10 @@ contract VendorRegistry {
 
   mapping (address => Vendor) vendorNames;
   
-  modifier ifadmin { if(isAdmin(msg.sender)) _ }
-
   function VendorRegistry(address _conf) {
     config = _conf;
   }
 
-  function isAdmin(address _acct) public returns (bool) {
-    return DigixConfiguration(config).isAdmin(_acct);
-  }
-
-  function getConfigAddress() public returns (address) {
-    return config;
-  }
-
   function register(address _acct) ifadmin {
     if (!Directory.insert(vendors, _acct))
       throw;

data/lib/ethereum/contract_initializer.rb

@@ -9,10 +9,10 @@ module Ethereum
       @binary = contract["bin"] unless contract.nil?
       @name = contract_name
       @project_initializer = project_initializer
-      matchdata = /_+[a-zA-Z]+_+/.match(@binary)
+      matchdata = @binary.scan(/_+[a-zA-Z]+_+/).uniq
       @needs_linking = matchdata.present?
       if @needs_linking
-        @libraries = matchdata.to_a.collect do |libname|
+        @libraries = matchdata.collect do |libname|
           {name: libname.gsub(/_+/,''), sigil: libname}
         end
       end

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "0.4.75"
+  VERSION = "0.4.80"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum
 version: !ruby/object:Gem::Version
-  version: 0.4.75
+  version: 0.4.80
 platform: ruby
 authors:
 - DigixGlobal Pte Ltd (https://dgx.io)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -121,6 +121,9 @@ files:
 - contracts/CustodianRegistry.sol
 - contracts/DigixConfiguration.sol
 - contracts/Directory.sol
+- contracts/DoublyLinked.sol
+- contracts/GenericInterface.sol
+- contracts/GenericRegistry.sol
 - contracts/Gold.sol
 - contracts/GoldRegistry.sol
 - contracts/GoldTokenLedger.sol