ethereum.rb 1.6.0

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

data/contracts/VendorRegistry.sol

@@ -0,0 +1,39 @@
+import "contracts/GenericRegistry.sol";
+
+contract VendorRegistry is GenericRegistry {
+
+  Directory.AddressBoolMap vendors;
+
+  struct Vendor {
+    bytes32 name;
+  }
+
+  mapping (address => Vendor) vendorNames;
+  
+  function VendorRegistry(address _conf) {
+    config = _conf;
+  }
+
+  function register(address _acct) ifadmin {
+    if (!Directory.insert(vendors, _acct))
+      throw;
+  }
+
+  function unregister(address _acct) ifadmin {
+    if (!Directory.remove(vendors, _acct))
+      throw;
+  }
+
+  function isVendor(address _acct) public returns (bool) {
+    return Directory.contains(vendors, _acct);
+  }
+
+  function setVendorName(address _vendor, bytes32 _name) ifadmin {
+    vendorNames[_vendor].name = _name;
+  }
+
+  function getVendorName(address _vendor) public returns (bytes32) {
+    return vendorNames[_vendor].name;
+  }
+
+}

data/contracts/classic/Digixbot.sol

@@ -0,0 +1,106 @@
+import "contracts/DigixbotUsers.sol";
+import "contracts/DigixbotConfiguration.sol";
+
+contract Coin {
+  function getBotContract() returns(address );
+  function getUserId(address _address) returns(bytes32 );
+  function withdrawCoin(bytes32 _user,uint256 _amount);
+  function depositCoin(bytes32 _uid,uint256 _amt);
+  function getBalance(bytes32 _uid) returns(uint256 );
+  function totalBalance() returns(uint256 );
+  function getConfig() returns(address );
+  function getUsersContract() returns(address );
+  function sendCoin(bytes32 _sender,bytes32 _recipient,uint256 _amt);
+}
+
+contract Digixbot {
+  address owner;
+  address config;
+
+  function Digixbot(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+
+  modifier ifowner { if(msg.sender == owner) _ }
+
+  function getConfig() public returns (address) {
+    return config;
+  }
+
+  function addUser(bytes32 _userid) ifowner {
+    DigixbotUsers(getUsersContract()).addUser(_userid); 
+  }
+
+  function setUserAccount(bytes32 _userid, address _account) ifowner {
+    bool _acctlock = accountLockCheck(_userid);
+    if (_acctlock == false) {
+      DigixbotUsers(getUsersContract()).setUserAccount(_userid, _account);
+    }
+  }
+
+  function getUserAccount(bytes32 _userid) public returns (address) {
+    return DigixbotUsers(getUsersContract()).getUserAccount(_userid);
+  }
+
+  function getUsersContract() public returns (address) {
+    return DigixbotConfiguration(config).getUsersContract();
+  }
+
+  function getCoinWallet(bytes4 _coin) public returns(address) {
+    return DigixbotConfiguration(config).getCoinWallet(_coin);
+  }
+
+  function userCheck(bytes32 _id) public returns(bool) {
+    return DigixbotUsers(getUsersContract()).userCheck(_id);
+  }
+
+  function sendCoin(bytes4 _coin, bytes32 _from, bytes32 _to, uint _amount) ifowner {
+    bool _tiplock = tipLockCheck(_from);
+    if (_tiplock == false) {
+      Coin(getCoinWallet(_coin)).sendCoin(_from, _to, _amount); 
+    }
+  }
+    
+  function withdrawCoin(bytes4 _coin, bytes32 _userid, uint _amount) ifowner {
+    Coin(getCoinWallet(_coin)).withdrawCoin(_userid, _amount);
+  }
+
+  function getCoinBalance(bytes4 _coin, bytes32 _userid) public returns(uint) {
+    return Coin(getCoinWallet(_coin)).getBalance(_userid);
+  }
+
+  function getTotalBalance(bytes4 _coin) public returns(uint) {
+    return Coin(getCoinWallet(_coin)).totalBalance();
+  }
+
+  function accountLockCheck(bytes32 _id) public returns (bool) {
+    return DigixbotUsers(getUsersContract()).accountLockCheck(_id);
+  }
+  
+  function tipLockCheck(bytes32 _id) public returns (bool) {
+    return DigixbotUsers(getUsersContract()).tipLockCheck(_id);
+  }
+
+  function lockAccount(bytes32 _id) ifowner {
+    DigixbotUsers(getUsersContract()).lockAccount(_id);
+  }
+
+  function lockTip(bytes32 _id) ifowner {
+    DigixbotUsers(getUsersContract()).lockTip(_id);
+  }
+
+  function unlockAccount() {
+    address _userscontract = getUsersContract();
+    bytes32 _userid = DigixbotUsers(_userscontract).getUserId(msg.sender);
+    DigixbotUsers(_userscontract).unlockAccount(_userid);
+  }
+
+  function unlockTip() {
+    address _userscontract = getUsersContract();
+    bytes32 _userid = DigixbotUsers(_userscontract).getUserId(msg.sender);
+    DigixbotUsers(_userscontract).unlockTip(_userid);
+  }
+  
+
+}

data/contracts/classic/DigixbotConfiguration.sol

@@ -0,0 +1,62 @@
+contract DigixbotConfiguration {
+
+  struct Coin {
+    bytes4 name;
+    address wallet;
+    bool locked;
+  }
+
+  address owner;
+  address botcontract;
+  address userscontract;
+  bool locked;
+
+  mapping(bytes4 => Coin) coins;
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier unlesslocked { if (locked == false) _ }
+
+  function DigixbotConfiguration() {
+    owner = msg.sender;
+    locked = false;
+  }
+
+  function getOwner() public constant returns (address) {
+    return owner;
+  }
+
+  function setBotContract(address _botcontract) ifowner unlesslocked {
+    botcontract = _botcontract;
+  }
+  
+  function getBotContract() public returns (address) {
+    return botcontract;
+  }
+
+  function setUsersContract(address _userscontract) ifowner unlesslocked {
+    userscontract = _userscontract;
+  }
+
+  function getUsersContract() public returns (address) {
+    return userscontract;
+  }
+
+  function lockConfiguration() ifowner {
+    locked = true;
+  }
+
+  function addCoin(bytes4 _name, address _wallet) ifowner {
+    Coin _cta = coins[_name];
+    if (_cta.locked == false) {
+      _cta.name = _name;
+      _cta.wallet = _wallet;
+      _cta.locked = true;
+    }
+  }
+
+  function getCoinWallet(bytes4 _coin) public constant returns (address) {
+    return coins[_coin].wallet;
+  }
+
+} 
+