ethereum.rb 1.6.0

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/ethereum.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ethereum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ethereum.rb"
+  spec.version       = Ethereum::VERSION
+  spec.authors       = ["Marek Kirejczyk"]
+  spec.email         = ["marek.kirejczyk@gmail.com"]
+
+  spec.summary       = %q{Ruby Ethereum client using the JSON-RPC interface}
+  spec.description   = %q{Ethereum.rb is Ruby Ethereum client using the JSON-RPC interface. Provides interface for sending transactions, creating and interacting with contracts as well as usefull toolkit to work with Ethereum node.}
+  spec.homepage      = "https://github.com/marekkirejczyk/ethereum.rb"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib", "bin"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+
+  spec.add_dependency "activesupport", "~> 5.0.1"
+  spec.add_dependency "digest-sha3", "~> 1.1.0"
+end

data/lib/ethereum.rb

@@ -0,0 +1,24 @@
+require "ethereum/version"
+require 'active_support'
+require 'active_support/core_ext'
+require 'digest/sha3'
+
+module Ethereum
+  require 'ethereum/client'
+  require 'ethereum/ipc_client'
+  require 'ethereum/http_client'
+  require 'ethereum/singleton'
+  require 'ethereum/solidity'
+  require 'ethereum/initializer'
+  require 'ethereum/contract'
+  require 'ethereum/function'
+  require 'ethereum/function_input'
+  require 'ethereum/function_output'
+  require 'ethereum/contract_event'
+  require 'ethereum/formatter'
+  require 'ethereum/transaction'
+  require 'ethereum/deployment'
+  require 'ethereum/project_initializer'
+  require 'ethereum/contract_initializer'
+  require 'ethereum/railtie' if defined?(Rails)
+end

data/lib/ethereum/client.rb

@@ -0,0 +1,97 @@
+module Ethereum
+  class Client
+    # https://github.com/ethereum/wiki/wiki/JSON-RPC
+    RPC_COMMANDS = %w(web3_clientVersion web3_sha3 net_version net_peerCount net_listening eth_protocolVersion eth_syncing eth_coinbase eth_mining eth_hashrate eth_gasPrice eth_accounts eth_blockNumber eth_getBalance eth_getStorageAt eth_getTransactionCount eth_getBlockTransactionCountByHash eth_getBlockTransactionCountByNumber eth_getUncleCountByBlockHash eth_getUncleCountByBlockNumber eth_getCode eth_sign eth_sendTransaction eth_sendRawTransaction eth_call eth_estimateGas eth_getBlockByHash eth_getBlockByNumber eth_getTransactionByHash eth_getTransactionByBlockHashAndIndex eth_getTransactionByBlockNumberAndIndex eth_getTransactionReceipt eth_getUncleByBlockHashAndIndex eth_getUncleByBlockNumberAndIndex eth_getCompilers eth_compileLLL eth_compileSolidity eth_compileSerpent eth_newFilter eth_newBlockFilter eth_newPendingTransactionFilter eth_uninstallFilter eth_getFilterChanges eth_getFilterLogs eth_getLogs eth_getWork eth_submitWork eth_submitHashrate db_putString db_getString db_putHex db_getHex shh_post shh_version shh_newIdentity shh_hasIdentity shh_newGroup shh_addToGroup shh_newFilter shh_uninstallFilter shh_getFilterChanges shh_getMessages)
+    # https://github.com/ethereum/go-ethereum/wiki/Management-APIs
+    RPC_MANAGEMENT_COMMANDS = %w(admin_addPeer admin_datadir admin_nodeInfo admin_peers admin_setSolc admin_startRPC admin_startWS admin_stopRPC admin_stopWS debug_backtraceAt debug_blockProfile debug_cpuProfile debug_dumpBlock debug_gcStats debug_getBlockRlp debug_goTrace debug_memStats debug_seedHash debug_setHead debug_setBlockProfileRate debug_stacks debug_startCPUProfile debug_startGoTrace debug_stopCPUProfile debug_stopGoTrace debug_traceBlock debug_traceBlockByNumber debug_traceBlockByHash debug_traceBlockFromFile debug_traceTransaction debug_verbosity debug_vmodule debug_writeBlockProfile debug_writeMemProfile miner_hashrate miner_makeDAG miner_setExtra miner_setGasPrice miner_start miner_startAutoDAG miner_stop miner_stopAutoDAG personal_importRawKey personal_listAccounts personal_lockAccount personal_newAccount personal_unlockAccount personal_sendTransaction txpool_content txpool_inspect txpool_status)
+
+    attr_accessor :command, :id, :log, :logger, :default_account
+
+    def initialize(log = false)
+      @id = 0
+      @log = log
+      @batch = nil
+
+      if @log == true
+        @logger = Logger.new("/tmp/ethereum_ruby_http.log")
+      end
+    end
+
+    def self.create(host_or_ipcpath, log = false)
+      return IpcClient.new(host_or_ipcpath, log) if host_or_ipcpath.end_with? '.ipc'
+      return HttpClient.new(host_or_ipcpath, log) if host_or_ipcpath.start_with? 'http'
+      raise ArgumentError.new('Unable to detect client type')
+    end
+
+    def batch
+      @batch = []
+
+      yield
+      result = send_batch(@batch)
+
+      @batch = nil
+      reset_id
+
+      return result
+    end
+
+    def get_id
+      @id += 1
+      return @id
+    end
+
+    def reset_id
+      @id = 0
+    end
+
+    def default_account
+      @default_account || eth_accounts["result"][0]
+    end
+
+    def int_to_hex(n)
+      return "0x#{n.to_s(16)}"
+    end
+
+    # https://github.com/ethereum/wiki/wiki/JSON-RPC#output-hex-values
+    def encode_params(params)
+      return params.map do |p|
+        if p.is_a?(Integer)
+          int_to_hex(p)
+        else
+          p
+        end
+      end
+    end
+
+    (RPC_COMMANDS + RPC_MANAGEMENT_COMMANDS).each do |rpc_command|
+      method_name = rpc_command.underscore
+      define_method method_name do |*args|
+        command = rpc_command
+        if ["eth_getBalance", "eth_call"].include?(command)
+          args << "latest"
+        end
+        payload = {jsonrpc: "2.0", method: command, params: encode_params(args), id: get_id}
+
+        if @log == true
+          @logger.info("Sending #{payload.to_json}")
+        end
+
+        if @batch
+          @batch << payload
+          return true
+        else
+          read = send_single(payload.to_json)
+          output = JSON.parse(read)
+          if @log == true
+            @logger.info("Received #{output.to_json}")
+          end
+          reset_id
+          return output
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/ethereum/contract.rb

@@ -0,0 +1,266 @@
+module Ethereum
+  class Contract
+
+    DEFAULT_GAS_PRICE = 60000000000
+
+    DEFAULT_GAS = 3000000
+
+    attr_accessor :code, :name, :functions, :abi, :constructor_inputs, :events, :class_object
+
+    def initialize(name, code, abi)
+      @name = name
+      @code = code
+      @abi = abi
+      @functions = []
+      @events = []
+      @constructor_inputs = @abi.detect {|x| x["type"] == "constructor"}["inputs"] rescue nil
+      @abi.select {|x| x["type"] == "function" }.each do |abifun|
+        @functions << Ethereum::Function.new(abifun) 
+      end
+      @abi.select {|x| x["type"] == "event" }.each do |abievt|
+        @events << Ethereum::ContractEvent.new(abievt)
+      end
+    end
+
+    def self.from_file(path, client = Ethereum::Singleton.instance)
+      @init = Ethereum::Initializer.new(path, client)
+      contracts = @init.build_all
+      raise "No contracts complied" if contracts.empty?
+      contracts.first.class_object.new
+    end
+
+    def self.from_blockchain(name, address, abi, client = Ethereum::Singleton.instance)
+      contract = Ethereum::Contract.new(name, nil, abi)
+      contract.build(client)
+      contract_instance = contract.class_object.new
+      contract_instance.at address
+      contract_instance
+    end
+
+    def build(connection)
+      class_name = @name.camelize
+      functions = @functions
+      constructor_inputs = @constructor_inputs
+      binary = @code
+      events = @events
+      abi = @abi
+
+      class_methods = Class.new do
+
+        define_method "connection".to_sym do
+          connection
+        end
+
+        define_method :deploy do |*params|
+          formatter = Ethereum::Formatter.new
+          deploy_code = binary
+          deploy_arguments = ""
+          if constructor_inputs.present?
+            raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
+            constructor_inputs.each_index do |i|
+              args = [constructor_inputs[i]["type"], params[i]]
+              deploy_arguments << formatter.to_payload(args)
+            end
+          end
+          deploy_payload = deploy_code + deploy_arguments
+          deploytx = connection.eth_send_transaction({from: self.sender, data: "0x" + deploy_payload})["result"]
+          raise "Failed to deploy, did you unlock #{self.sender} account? Transaction hash: #{deploytx}" if deploytx.nil? || deploytx == "0x0000000000000000000000000000000000000000000000000000000000000000"
+          instance_variable_set("@deployment", Ethereum::Deployment.new(deploytx, connection))
+        end
+
+        define_method :estimate do |*params|
+          formatter = Ethereum::Formatter.new
+          deploy_code = binary
+          deploy_arguments = ""
+          if constructor_inputs.present?
+            raise "Missing constructor parameter" and return if params.length != constructor_inputs.length
+            constructor_inputs.each_index do |i|
+              args = [constructor_inputs[i]["type"], params[i]]
+              deploy_arguments << formatter.to_payload(args)
+            end
+          end
+          deploy_payload = deploy_code + deploy_arguments
+          deploytx = connection.eth_estimate_gas({from: self.sender, data: "0x" + deploy_payload})["result"]
+        end
+
+        define_method :events do
+          return events
+        end
+
+        define_method :abi do
+          return abi
+        end
+
+        define_method :deployment do
+          instance_variable_get("@deployment")
+        end
+
+        define_method :deploy_and_wait do |time = 200.seconds, *params, **args, &block|
+          self.deploy(*params)
+          self.deployment.wait_for_deployment(time, **args, &block)
+          instance_variable_set("@address", self.deployment.contract_address)
+          self.events.each do |event|
+            event.set_address(self.deployment.contract_address)
+            event.set_client(connection)
+          end
+          self.deployment.contract_address
+        end
+
+        define_method :at do |addr|
+          instance_variable_set("@address", addr) 
+          self.events.each do |event|
+            event.set_address(addr)
+            event.set_client(connection)
+          end
+        end
+
+        define_method :address do
+          instance_variable_get("@address")
+        end
+
+        define_method :as do |addr|
+          instance_variable_set("@sender", addr)
+        end
+
+        define_method :sender do
+          instance_variable_get("@sender") || connection.default_account
+        end
+
+        define_method :set_gas_price do |gp|
+          instance_variable_set("@gas_price", gp)
+        end
+
+        define_method :gas_price do
+          instance_variable_get("@gas_price") || DEFAULT_GAS_PRICE
+        end
+
+        define_method :set_gas do |gas|
+          instance_variable_set("@gas", gas)
+        end
+
+        define_method :gas do 
+          instance_variable_get("@gas") || DEFAULT_GAS
+        end
+
+        events.each do |evt|
+          define_method "nf_#{evt.name.underscore}".to_sym do |params = {}|
+            params[:to_block] ||= "latest"
+            params[:from_block] ||= "0x0"
+            params[:address] ||=  instance_variable_get("@address")
+            params[:topics] = evt.signature
+            payload = {topics: [params[:topics]], fromBlock: params[:from_block], toBlock: params[:to_block], address: params[:address]}
+            filter_id = connection.new_filter(payload)
+            return filter_id["result"]
+          end
+
+          define_method "gfl_#{evt.name.underscore}".to_sym do |filter_id|
+            formatter = Ethereum::Formatter.new
+            logs = connection.get_filter_logs(filter_id)
+            collection = []
+            logs["result"].each do |result|
+              inputs = evt.input_types
+              outputs = inputs.zip(result["topics"][1..-1])
+              data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []} 
+              outputs.each do |output|
+                data[:topics] << formatter.from_payload(output)
+              end
+              collection << data 
+            end
+            return collection
+          end
+
+          define_method "gfc_#{evt.name.underscore}".to_sym do |filter_id|
+            formatter = Ethereum::Formatter.new
+            logs = connection.get_filter_changes(filter_id)
+            collection = []
+            logs["result"].each do |result|
+              inputs = evt.input_types
+              outputs = inputs.zip(result["topics"][1..-1])
+              data = {blockNumber: result["blockNumber"].hex, transactionHash: result["transactionHash"], blockHash: result["blockHash"], transactionIndex: result["transactionIndex"].hex, topics: []} 
+              outputs.each do |output|
+                data[:topics] << formatter.from_payload(output)
+              end
+              collection << data 
+            end
+            return collection
+          end
+
+        end
+
+        functions.each do |fun|
+
+          fun_count = functions.select {|x| x.name == fun.name }.count
+          derived_function_name = (fun_count == 1) ? "#{fun.name.underscore}" : "#{fun.name.underscore}__#{fun.inputs.collect {|x| x.type}.join("__")}"
+          call_function_name = "call_#{derived_function_name}".to_sym
+          call_function_name_alias = "c_#{derived_function_name}".to_sym
+          call_raw_function_name = "call_raw_#{derived_function_name}".to_sym
+          call_raw_function_name_alias = "cr_#{derived_function_name}".to_sym
+          transact_function_name = "transact_#{derived_function_name}".to_sym
+          transact_function_name_alias = "t_#{derived_function_name}".to_sym
+          transact_and_wait_function_name = "transact_and_wait_#{derived_function_name}".to_sym
+          transact_and_wait_function_name_alias = "tw_#{derived_function_name}".to_sym
+
+          define_method call_raw_function_name do |*args|
+            formatter = Ethereum::Formatter.new
+            arg_types = fun.inputs.collect(&:type)
+            connection = self.connection
+            return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
+            payload = []
+            payload << fun.signature
+            arg_types.zip(args).each do |arg|
+              payload << formatter.to_payload(arg)
+            end
+            raw_result = connection.eth_call({to: self.address, from: self.sender, data: "0x" + payload.join()})
+            raw_result = raw_result["result"]
+            formatted_result = fun.outputs.collect {|x| x.type }.zip(raw_result.gsub(/^0x/,'').scan(/.{64}/))
+            output = formatted_result.collect {|x| formatter.from_payload(x) }
+            return {data: "0x" + payload.join(), raw: raw_result, formatted: output}
+          end
+
+          define_method call_function_name do |*args|
+            data = self.send(call_raw_function_name, *args)
+            output = data[:formatted]
+            if output.length == 1 
+              return output[0]
+            else 
+              return output
+            end
+          end
+
+          define_method transact_function_name do |*args|
+            formatter = Ethereum::Formatter.new
+            arg_types = fun.inputs.collect(&:type)
+            connection = self.connection
+            return {result: :error, message: "missing parameters for #{fun.function_string}" } if arg_types.length != args.length
+            payload = []
+            payload << fun.signature
+            arg_types.zip(args).each do |arg|
+              payload << formatter.to_payload(arg)
+            end
+            txid = connection.eth_send_transaction({to: self.address, from: self.sender, data: "0x" + payload.join()})["result"]
+            return Ethereum::Transaction.new(txid, self.connection, payload.join(), args)
+          end
+
+          define_method transact_and_wait_function_name do |*args|
+            function_name = "transact_#{derived_function_name}".to_sym
+            tx = self.send(function_name, *args)
+            tx.wait_for_miner
+            return tx
+          end
+
+          alias_method call_function_name_alias, call_function_name
+          alias_method call_raw_function_name_alias, call_raw_function_name
+          alias_method transact_function_name_alias, transact_function_name
+          alias_method transact_and_wait_function_name_alias, transact_and_wait_function_name
+
+        end
+      end
+      if Object.const_defined?(class_name)
+        Object.send(:remove_const, class_name)
+      end
+      Object.const_set(class_name, class_methods)
+      @class_object = class_methods
+    end
+
+  end
+end