ethereum 0.4.45 → 0.4.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce81f0ccd33fa2df00f5fba597d86078e2741ad9
-  data.tar.gz: 172e0bc070a39588a23e2eca4297f50bebc49cfc
+  metadata.gz: f6f8651276b158f5f3357d1f6d735a464b9b9a82
+  data.tar.gz: 683902765b1b505cd1ccb0fa5edc930fb3bcf1c2
 SHA512:
-  metadata.gz: 63056e204033d1a0606a685ea5097200527fddb3529c592626e2cd2bf70c050d1cc4619c7cf55988783d8fe50d7dea97ff2b55d329eb6ea47c1f50decf6726f4
-  data.tar.gz: 77646073740221587848ba6ea950bb651c1a6c0f847bf3901a26e2548813e323a97093b7e2862403f27c21a00535c754177cbfde129c19c91f7ee6ecbd4dc35c
+  metadata.gz: 4ca471c406b9ff5e43f662e11a55522310a65b6b782cc27fcadf822ad80a314b39d4fba0990e6e72e5f85c63be8e14ce280012ba6ed0453f6cd0adc453933d95
+  data.tar.gz: bb7cc47cddc28c6bdcfdb074570bd93ee46dcaa134b6450755a0c5e1fc68c318b68afa5ebc5ce5e504d99a66f9b4945468cd370747f9ab94d0f48191e94e2a56

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.Data 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,22 @@
+import "contracts/Interface.sol";
+
+contract CustodianInterface is Interface {
+
+  function CustodianInterface(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+  
+  function publishReceipt(address _gold, bytes32 _file) ifemployee {
+    
+  }
+
+  function isRedeemable(address _gold) public returns (bool) {
+    return true;
+  }
+
+}
+
+
+
+

data/contracts/CustodianRegistry.sol

@@ -0,0 +1,14 @@
+contract CustodianRegistry {
+
+  address config;
+  Directory.Data custodians;
+
+  function CustodianRegistry(address _conf) {
+    config = _conf;
+  }
+
+  function isCustodian(address _cust) public returns (bool) {
+    return Directory.contains(custodians, _cust);
+  }
+
+}

data/contracts/DigixConfiguration.sol

@@ -0,0 +1,56 @@
+contract DigixConfiguration {
+  
+  address owner;
+  Directory.Data admins;
+
+  mapping (bytes32 => address) configurations;
+
+  event SetOwner(address indexed owner, address indexed by);
+  event AddConfigEntry(bytes32 indexed key, address 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 addConfigEntry(bytes32 _key, address _val) ifowner {
+    address _oldaddress = configurations[_key];
+    configurations[_key] = _val;
+    AddConfigEntry(_key, _val, msg.sender);
+  }
+
+  function getConfigEntry(bytes32 _key) public constant returns (address) {
+    return configurations[_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,25 @@
+library Directory {
+
+  struct Data { mapping(address => bool) entries; }
+
+  function insert(Data storage self, address acct) returns (bool) {
+    if (self.entries[acct])
+      return false; 
+    self.entries[acct] = true;
+    return true;
+  }
+
+  function remove(Data storage self, address acct) returns (bool) {
+    if (!self.entries[acct])
+      return false;
+    self.entries[acct] = false;
+    return true;
+  }
+
+  function contains(Data storage self, address acct) returns (bool) {
+    return self.entries[acct];
+  }
+
+}
+
+

data/contracts/Gold.sol

@@ -0,0 +1,67 @@
+contract Gold {
+
+  address config;
+  address owner;
+  uint lastfeecalc;
+  bool locked;
+
+  struct Detail {
+    address vendor;
+    address custodian;
+    uint status;
+    uint auditCount;
+  }
+
+  struct Info {
+    uint weight;
+    bytes32 serialNumber;
+    bytes32 vendorReceipt;
+    bytes32 custodianReceipt;
+  }
+
+  struct StorageFee {
+    uint due;
+    uint lastPayment;
+  }
+
+  Detail detail;
+  Info info;
+  StorageFee storagefee;
+
+  modifier ifowner { if(owner == msg.sender) _ }
+
+  event GoldAuditReport(bool indexed passed, address indexed document, address indexed auditor);
+
+  function Gold(uint _wt) {
+    owner = msg.sender;
+    detail.auditCount = 0;
+    detail.vendor = msg.sender;
+    info.weight = _wt;
+    storagefee.lastPayment = block.timestamp;
+  }
+
+  function lastCalculation() public returns (uint) {
+    return storagefee.lastPayment;
+  }
+
+  function timeSinceLastCalc() public returns (uint) {
+    return (block.timestamp - storagefee.lastPayment);
+  }
+
+  function mathTestDiv(uint _a, uint _b) public returns (uint) {
+    return (_a / _b);
+  }
+
+  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 mathTestMul(uint _a, uint _b) public returns (uint) {
+    return (_a * _b);
+  }
+
+}

data/contracts/GoldRegistry.sol

@@ -0,0 +1,49 @@
+import "contracts/DigixConfiguration.sol";
+import "contracts/Directory.sol";
+import "contracts/VendorRegistry.sol";
+import "contracts/CustodianRegistry.sol";
+import "contracts/AuditorRegistry.sol";
+
+contract GoldRegistry {
+ 
+  address config;
+
+  Directory.Data active;
+
+  function GoldRegistry(address _conf) {
+    config = _conf;
+  }
+
+  modifier ifvendor { if(isVendor(msg.sender)) _ }
+  modifier ifcustodian { if(isCustodian(msg.sender)) _ }
+  modifier ifauditor { if(isAuditor(msg.sender)) _ }
+
+  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 isVendor(address _vend) public returns (bool) {
+    return VendorRegistry(vendorRegistry()).isVendor(_vend);
+  }
+  
+  function isCustodian(address _cust) public returns (bool) {
+    return CustodianRegistry(custodianRegistry()).isCustodian(_cust);
+  }
+  
+  function isAuditor(address _audt) public returns (bool) {
+    return AuditorRegistry(custodianRegistry()).isAuditor(_audt);
+  }
+
+  function registerGold(address _gold) {
+
+  }
+
+}

data/contracts/GoldTokenLedger.sol

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

data/contracts/Interface.sol

@@ -0,0 +1,57 @@
+import "contracts/VendorRegistry.sol";
+import "contracts/CustodianRegistry.sol";
+import "contracts/AuditorRegistry.sol";
+
+contract Interface {
+
+  address owner;
+  address config;
+
+  Directory.Data employees;
+
+  modifier ifowner { if(owner == msg.sender) _ }
+  modifier ifemployee { if(isEmployee(msg.sender)) _ }
+
+  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);
+  }
+
+  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/Minter.sol

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

data/contracts/Recaster.sol

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

data/contracts/VendorInterface.sol

@@ -0,0 +1,25 @@
+import "contracts/Interface.sol";
+import "contracts/Gold.sol";
+
+contract VendorInterface is Interface {
+
+  function VendorInterface(address _config) {
+    owner = msg.sender;
+    config = _config;
+  }
+  
+  function registerGold(address _asset) ifemployee {
+    var b = _asset;
+  }
+
+  function uploadReceipt(address _asset, bytes32 _ipfsHash) ifemployee {
+
+  }
+
+  function assignCustodian(address _asset, address _custodian) ifemployee {
+
+  }
+
+}
+
+

data/contracts/VendorRegistry.sol

@@ -0,0 +1,51 @@
+import "contracts/DigixConfiguration.sol";
+import "contracts/Directory.sol";
+
+contract VendorRegistry {
+
+  address config;
+  Directory.Data vendors;
+
+  struct Vendor {
+    bytes32 name;
+  }
+
+  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;
+  }
+
+  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);
+  }
+  
+
+}