ethereum 0.4.45 → 0.4.50

data/contracts/classic/ParticipantRegistry.sol

@@ -0,0 +1,94 @@
+contract ParticipantRegistry {
+
+  enum ParticipantTypes { Admin, Vendor, Custodian, Auditor }
+  struct ParticipantDatabase {
+    mapping (address => bool) auditors;
+    mapping (address => bool) vendors;
+    mapping (address => bool) custodians;
+    mapping (address => bool) registrars;
+  }
+
+  address owner;
+  ParticipantDatabase participantdb;
+
+  event AddParticipant(address indexed participant, uint indexed participanttype);
+  event RemoveParticipant(address indexed participant, uint indexed participanttype);
+
+  modifier ifowner { if (msg.sender == owner) _ }
+  modifier ifregistrar { if ((participantdb.registrars[tx.origin]) || (tx.origin == owner)) _ }
+  modifier onlyvendor { if (isVendor(tx.origin) == true) _ }
+  modifier onlycustodian { if (isCustodian(tx.origin) == true) _ }
+  modifier onlyauditor { if (isAuditor(tx.origin) == true) _ }
+
+  function ParticipantRegistry() {
+    owner = msg.sender;
+  }
+
+  function getOwner() returns (address oa) {
+    oa = owner;
+  }
+
+  function setOwner(address nown) ifowner {
+    owner = nown;
+  }
+
+  function registerAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = true;
+    AddParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function unregisterAdmin(address regraddr) ifowner {
+    participantdb.registrars[regraddr] = false;
+    RemoveParticipant(regraddr, uint(ParticipantTypes.Admin));
+  }
+
+  function registerVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = true;
+    AddParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function unregisterVendor(address vendoraddress) ifregistrar {
+    participantdb.vendors[vendoraddress] = false;
+    RemoveParticipant(vendoraddress, uint(ParticipantTypes.Vendor));
+  }
+
+  function registerCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = true;
+    AddParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function unregisterCustodian(address custodianaddress) ifregistrar {
+    participantdb.custodians[custodianaddress] = false;
+    RemoveParticipant(custodianaddress, uint(ParticipantTypes.Custodian));
+  }
+
+  function registerAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = true;
+    AddParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function unregisterAuditor(address auditoraddress) ifregistrar {
+    participantdb.auditors[auditoraddress] = false;
+    RemoveParticipant(auditoraddress, uint(ParticipantTypes.Auditor));
+  }
+
+  function isVendor(address vendoraddress) returns (bool) {
+    return participantdb.vendors[vendoraddress];
+  }
+
+  function isCustodian(address custodianaddress) returns (bool) {
+    return participantdb.custodians[custodianaddress];
+  }
+
+  function isAuditor(address auditoraddress) returns (bool) {
+    return participantdb.auditors[auditoraddress];
+  }
+
+  function isRegistrar(address regraddr) returns (bool) {
+    return participantdb.registrars[regraddr];
+  }
+}
+
+
+
+//#include [ParticipantRegistry]

data/contracts/classic/QueueSample.sol

@@ -0,0 +1,54 @@
+////////////////////////////////////////////////////////////
+// This is an example contract hacked together at a meetup.
+// It is by far not complete and only used to show some
+// features of Solidity.
+////////////////////////////////////////////////////////////
+contract QueueContract
+{
+    struct Queue {
+        uint[] data;
+        uint front;
+        uint back;
+    }
+    /// @dev the number of elements stored in the queue.
+    function length(Queue storage q) constant internal returns (uint) {
+        return q.back - q.front;
+    }
+    /// @dev the number of elements this queue can hold
+    function capacity(Queue storage q) constant internal returns (uint) {
+        return q.data.length - 1;
+    }
+    /// @dev push a new element to the back of the queue
+    function push(Queue storage q, uint data) internal
+    {
+        if ((q.back + 1) % q.data.length == q.front)
+            return; // throw;
+        q.data[q.back] = data;
+        q.back = (q.back + 1) % q.data.length;
+    }
+    /// @dev remove and return the element at the front of the queue
+    function pop(Queue storage q) internal returns (uint r)
+    {
+        if (q.back == q.front)
+            return; // throw;
+        r = q.data[q.front];
+        delete q.data[q.front];
+        q.front = (q.front + 1) % q.data.length;
+    }
+}
+
+contract QueueUserMayBeDeliveryDroneCotnrol is QueueContract {
+    Queue requests;
+    function QueueUserMayBeDeliveryDroneCotnrol() {
+        requests.data.length = 200;
+    }
+    function addRequest(uint d) {
+        push(requests, d);
+    }
+    function popRequest() returns (uint) {
+        return pop(requests);
+    }
+    function queueLength() returns (uint) {
+        return length(requests);
+    }
+}

data/lib/ethereum/contract_initializer.rb

@@ -2,12 +2,13 @@ module Ethereum
 
   class ContractInitializer
 
-    attr_accessor :abi, :binary, :name, :libraries, :needs_linking
+    attr_accessor :abi, :binary, :name, :libraries, :needs_linking, :project_initializer
 
-    def initialize(contract_name, contract)
+    def initialize(contract_name, contract, project_initializer)
       @abi = JSON.parse(contract["abi"]) unless contract.nil?
       @binary = contract["bin"] unless contract.nil?
       @name = contract_name
+      @project_initializer = project_initializer
       matchdata = /_+[a-zA-Z]+_+/.match(@binary)
       @needs_linking = matchdata.present?
       if @needs_linking
@@ -20,11 +21,20 @@ module Ethereum
     def link_libraries
       if @needs_linking
         @libraries.each do |library|
-          ENV['ETHEREUM_DEPLOYER_WAIT_TIME'] ||= "120"
-          wait_time = ENV['ETHEREUM_DEPLOYER_WAIT_TIME'].to_i
-          library_instance = library[:name].constantize.new
-          library_instance.deploy_and_wait(wait_time)
-          @binary.gsub!(library[:sigil], library_instance.address.gsub(/^0x/,''))
+          name = library[:name]
+          if @project_initializer.libraries[name].nil?
+            ENV['ETHEREUM_DEPLOYER_WAIT_TIME'] ||= "120"
+            wait_time = ENV['ETHEREUM_DEPLOYER_WAIT_TIME'].to_i
+            library_instance = library[:name].constantize.new
+            puts "Deploying library #{name}"
+            library_instance.deploy_and_wait(wait_time)
+            puts "Library deployed at #{library_instance.address}"
+            @project_initializer.libraries[name] = library_instance.address
+            @binary.gsub!(library[:sigil], library_instance.address.gsub(/^0x/,''))
+          else
+            address = @project_initializer.libraries[name]
+            @binary.gsub!(library[:sigil], address.gsub(/^0x/,''))
+          end
         end
       end
     end

data/lib/ethereum/project_initializer.rb

@@ -2,7 +2,7 @@ module Ethereum
 
   class ProjectInitializer
 
-    attr_accessor :contract_names, :combined_output, :contracts
+    attr_accessor :contract_names, :combined_output, :contracts, :libraries
 
     def initialize(location)
       ENV['ETHEREUM_SOLIDITY_BINARY'] ||= "/usr/local/bin/solc"
@@ -12,8 +12,9 @@ module Ethereum
       raw_data = `#{compile_command}`
       data = JSON.parse(raw_data)
       @contract_names = data["contracts"].keys
+      @libraries = {} 
       @contracts = @contract_names.collect do |contract_name|
-        ContractInitializer.new(contract_name, data["contracts"][contract_name])
+        ContractInitializer.new(contract_name, data["contracts"][contract_name], self)
       end
     end
 

data/lib/ethereum/version.rb

@@ -1,3 +1,3 @@
 module Ethereum
-  VERSION = "0.4.45"
+  VERSION = "0.4.50"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethereum
 version: !ruby/object:Gem::Version
-  version: 0.4.45
+  version: 0.4.50
 platform: ruby
 authors:
 - DigixGlobal Pte Ltd (https://dgx.io)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-23 00:00:00.000000000 Z
+date: 2015-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,7 +115,31 @@ files:
 - bin/console
 - bin/setup
 - contracts/AccountingLib.sol
+- contracts/AuditorInterface.sol
+- contracts/AuditorRegistry.sol
+- contracts/CustodianInterface.sol
+- contracts/CustodianRegistry.sol
+- contracts/DigixConfiguration.sol
+- contracts/Directory.sol
+- contracts/Gold.sol
+- contracts/GoldRegistry.sol
+- contracts/GoldTokenLedger.sol
+- contracts/Interface.sol
+- contracts/Minter.sol
+- contracts/Recaster.sol
 - contracts/Testing.sol
+- contracts/VendorInterface.sol
+- contracts/VendorRegistry.sol
+- contracts/classic/Digixbot.sol
+- contracts/classic/DigixbotConfiguration.sol
+- contracts/classic/DigixbotEthereum.sol
+- contracts/classic/DigixbotUsers.sol
+- contracts/classic/Gold.sol
+- contracts/classic/GoldRegistry.sol
+- contracts/classic/GoldTokenLedger.sol
+- contracts/classic/GoldTokenMinter.sol
+- contracts/classic/ParticipantRegistry.sol
+- contracts/classic/QueueSample.sol
 - ethereum.gemspec
 - lib/ethereum.rb
 - lib/ethereum/client.rb