ethereum.rb 1.6.0

data/lib/ethereum/contract_event.rb

@@ -0,0 +1,25 @@
+module Ethereum
+  class ContractEvent
+
+    attr_accessor :name, :signature, :input_types, :inputs, :event_string, :address, :client
+
+    def initialize(data)
+      @name = data["name"]
+      @input_types = data["inputs"].collect {|x| x["type"]}
+      @inputs = data["inputs"].collect {|x| x["name"]}
+      @event_string = "#{@name}(#{@input_types.join(",")})"
+      @signature = SHA3::Digest::SHA256.hexdigest(@event_string)
+      # @signature = Digest::SHA3.hexdigest @event_string, 256
+    end
+
+    def set_address(address)
+      @address = address
+    end
+
+    def set_client(client)
+      @client = client
+    end
+
+  end
+end
+

data/lib/ethereum/contract_initializer.rb

@@ -0,0 +1,54 @@
+module Ethereum
+
+  class ContractInitializer
+
+    attr_accessor :abi, :binary, :name, :libraries, :needs_linking, :project_initializer, :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 = @binary.scan(/_+[a-zA-Z]+_+/).uniq
+      @needs_linking = matchdata.present?
+      if @needs_linking
+        @libraries = matchdata.collect do |libname|
+          {name: libname.gsub(/_+/,''), sigil: libname}
+        end
+      end
+    end
+
+    def link_libraries
+      if @needs_linking
+        @libraries.each do |library|
+          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
+
+    def build(connection)
+      @contract = Ethereum::Contract.new(@name, @binary, @abi) 
+      @contract.build(connection)
+    end
+
+    def generate_javascripts(path)
+      data = {name: @name, abi: @abi, binary: @binary}
+      File.open(File.join(path, "#{@name}.json"), 'w') {|f| f.puts data.to_json}
+    end
+
+  end
+
+end

data/lib/ethereum/deployment.rb

@@ -0,0 +1,49 @@
+module Ethereum
+
+  class Deployment
+
+    DEFAULT_TIMEOUT = 300.seconds
+    DEFAULT_STEP = 5.seconds
+
+    attr_accessor :id, :contract_address, :connection, :deployed, :mined
+    attr_reader :valid_deployment
+
+    def initialize(txid, connection)
+      @id = txid
+      @connection = connection
+      @deployed = false
+      @contract_address = nil
+      @valid_deployment = false
+    end
+
+    def mined?
+      return true if @mined
+      @mined = @connection.get_transaction_by_hash(@id)["result"]["blockNumber"].present? rescue nil
+      @mined ||= false
+    end
+
+    def check_deployed
+      return false unless @id
+      contract_receipt = @connection.eth_get_transaction_receipt(@id)
+      result = contract_receipt["result"]
+      has_contract_address = result && result["contractAddress"]
+      @contract_address ||= result["contractAddress"] if has_contract_address
+      has_contract_address && result["blockNumber"]
+    end
+
+    def deployed?
+      @valid_deployment ||= check_deployed
+    end
+
+    def wait_for_deployment(timeout = DEFAULT_TIMEOUT, step: DEFAULT_STEP, &block)
+      start_time = Time.now
+      while true
+        raise "Transaction #{@id} timed out." if ((Time.now - start_time) > timeout) 
+        sleep step
+        yield if block_given?
+        return true if deployed?
+      end
+    end
+
+  end
+end

data/lib/ethereum/formatter.rb

@@ -0,0 +1,172 @@
+module Ethereum
+  class Formatter
+
+    UNITS = {
+      wei:        1,
+      kwei:       1000,
+      ada:        1000,
+      femtoether: 1000,
+      mwei:       1000000,
+      babbage:    1000000,
+      picoether:  1000000,
+      gwei:       1000000000,
+      shannon:    1000000000,
+      nanoether:  1000000000,
+      nano:       1000000000,
+      szabo:      1000000000000,
+      microether: 1000000000000,
+      micro:      1000000000000,
+      finney:     1000000000000000,
+      milliether: 1000000000000000,
+      milli:      1000000000000000,
+      ether:      1000000000000000000,
+      eth:        1000000000000000000,
+      kether:     1000000000000000000000,
+      grand:      1000000000000000000000,
+      einstein:   1000000000000000000000,
+      mether:     1000000000000000000000000,
+      gether:     1000000000000000000000000000,
+      tether:     1000000000000000000000000000000
+    }
+
+    def valid_address?(address_string)
+      address = address_string.gsub(/^0x/,'')
+      return false if address == "0000000000000000000000000000000000000000"
+      return false if address.length != 40
+      return !(address.match(/[0-9a-fA-F]+/).nil?)
+    end
+
+    def from_bool(boolval)
+      return nil if boolval.nil?
+      boolval ? "1" : "0"
+    end
+
+    def to_bool(hexstring)
+      return nil if hexstring.nil?
+      (hexstring == "0000000000000000000000000000000000000000000000000000000000000001")
+    end
+
+    def to_ascii(hexstring)
+      return nil if hexstring.nil?
+      hexstring.gsub(/^0x/,'').scan(/.{2}/).collect {|x| x.hex}.pack("c*")
+    end
+    
+    def to_utf8(hexstring)
+      return nil if hexstring.nil?
+      hexstring.gsub(/^0x/,'').scan(/.{2}/).collect {|x| x.hex}.pack("U*").delete("\u0000")
+    end
+
+    def from_ascii(ascii_string)
+      return nil if ascii_string.nil?
+      ascii_string.unpack('H*')[0]
+    end
+
+    def from_utf8(utf8_string)
+      return nil if utf8_string.nil?
+      utf8_string.force_encoding('UTF-8').split("").collect {|x| x.ord.to_s(16)}.join("")
+    end
+
+    def to_address(hexstring)
+      return "0x0000000000000000000000000000000000000000" if hexstring.nil?
+      "0x" + hexstring[-40..-1]
+    end
+
+    def to_wei(amount, unit = "ether")
+      return nil if amount.nil?
+      BigDecimal.new(UNITS[unit.to_sym] * amount, 16).to_s.to_i rescue nil
+    end
+
+    def from_wei(amount, unit = "ether")
+      return nil if amount.nil?
+      (BigDecimal.new(amount, 16) / BigDecimal.new(UNITS[unit.to_sym], 16)).to_s rescue nil
+    end
+
+    def from_address(address)
+      return "0x0000000000000000000000000000000000000000" if address.nil?
+      address.gsub(/^0x/,'').rjust(64, "0")
+    end
+
+    def to_param(string)
+      string.ljust(64, '0')
+    end
+
+    def from_input(string)
+      string[10..-1].scan(/.{64}/)
+    end
+
+    def to_twos_complement(number)
+      (number & ((1 << 256) - 1)).to_s(16)
+    end
+
+    def to_int(hexstring)
+      return nil if hexstring.nil?
+      (hexstring.gsub(/^0x/,'')[0..1] == "ff") ? (hexstring.hex - (2 ** 256)) : hexstring.hex
+    end
+
+    def address_to_payload(address)
+      from_address(address)
+    end
+
+    def uint_to_payload(uint)
+      self.to_twos_complement(uint).rjust(64, '0')
+    end
+
+    def int_to_payload(int)
+      self.to_twos_complement(uint).rjust(64, '0')
+    end
+
+    def bytes_to_payload(bytes)
+      self.from_utf8(bytes).ljust(64, '0')
+    end
+
+    def string_to_payload(bytes)
+      self.bytes_to_payload(bytes)
+    end
+
+    def get_base_type(typename)
+      typename.gsub(/\d+/,'')
+    end
+
+    def to_payload(args)
+      converter = "#{self.get_base_type(args[0])}_to_payload".to_sym
+      self.send(converter, args[1]) 
+    end
+
+    def from_payload(args)
+      converter = "output_to_#{self.get_base_type(args[0])}".to_sym
+      self.send(converter, args[1])
+    end
+
+    def output_to_address(bytes)
+      self.to_address(bytes)
+    end
+
+    def output_to_bytes(bytes)
+      self.to_utf8(bytes)
+    end
+
+    def output_to_string(bytes)
+      self.to_utf8(bytes)
+    end
+
+    def output_to_uint(bytes)
+      self.to_int(bytes)
+    end
+
+    def output_to_int(bytes)
+      self.to_int(bytes)
+    end
+
+    def output_to_bool(bytes)
+      self.to_bool(bytes.gsub(/^0x/,''))
+    end
+
+    def to_output(args)
+      converter = "output_to_#{self.get_base_type(args[0])}".to_sym
+      self.send(converter, args[1])
+    end
+
+  end
+
+end
+

data/lib/ethereum/function.rb

@@ -0,0 +1,20 @@
+module Ethereum
+  class Function
+
+    attr_accessor :name, :inputs, :outputs, :signature, :constant, :function_string 
+
+    def initialize(data)
+      @name = data["name"]
+      @constant = data["constant"]
+      @inputs = data["inputs"].collect do |input|
+        Ethereum::FunctionInput.new(input)
+      end
+      @outputs = data["outputs"].collect do |output|
+        Ethereum::FunctionOutput.new(output)
+      end
+      @function_string = "#{@name}(#{@inputs.collect {|x| x.type }.join(",")})"
+      @signature = Digest::SHA3.hexdigest(@function_string, 256)[0..7]
+    end
+
+  end
+end

data/lib/ethereum/function_input.rb

@@ -0,0 +1,13 @@
+module Ethereum
+  class FunctionInput
+
+    attr_accessor :type, :name
+
+    def initialize(data)
+      @type = data["type"]
+      @name = data["name"]
+    end
+
+  end
+
+end

data/lib/ethereum/function_output.rb

@@ -0,0 +1,14 @@
+module Ethereum
+  
+  class FunctionOutput
+
+    attr_accessor :type, :name
+
+    def initialize(data)
+      @type = data["type"]
+      @name = data["name"]
+    end
+
+  end
+
+end

data/lib/ethereum/http_client.rb

@@ -0,0 +1,38 @@
+require 'net/http'
+module Ethereum
+  class HttpClient < Client
+    attr_accessor :host, :port, :uri, :ssl
+
+    def initialize(host, log = false)
+      super(log)
+      uri = URI.parse(host)
+      raise ArgumentError unless ['http', 'https'].include? uri.scheme
+      @host = uri.host
+      @port = uri.port
+      
+      @ssl = uri.scheme == 'https'
+      if ssl
+        @uri = URI("https://#{@host}:#{@port}")
+      else
+        @uri = URI("http://#{@host}:#{@port}")
+      end
+    end
+
+    def send_single(payload)
+      http = ::Net::HTTP.new(@host, @port)
+      if @ssl
+        http.use_ssl = true
+      end
+      header = {'Content-Type' => 'application/json'}
+      request = ::Net::HTTP::Post.new(uri, header)
+      request.body = payload
+      response = http.request(request)
+      return response.body
+    end
+
+    def send_batch(batch)
+      raise NotImplementedError
+    end
+  end
+
+end

data/lib/ethereum/initializer.rb

@@ -0,0 +1,27 @@
+module Ethereum
+
+  class Initializer
+    attr_accessor :contracts, :file, :client
+
+    def initialize(file, client = Ethereum::Singleton.instance)
+      @client = client
+      sol_output = Solidity.new.compile(file)
+      contracts = sol_output.keys
+
+      @contracts = []
+      contracts.each do |contract|
+        abi = JSON.parse(sol_output[contract]["abi"] )
+        name = contract
+        code = sol_output[contract]["bin"]
+        @contracts << Contract.new(name, code, abi)
+      end
+    end
+
+    def build_all
+      @contracts.each do |contract|
+        contract.build(@client)
+      end
+    end
+
+  end
+end

data/lib/ethereum/ipc_client.rb

@@ -0,0 +1,46 @@
+require 'socket'
+module Ethereum
+  class IpcClient < Client
+    attr_accessor :ipcpath
+
+    IPC_PATHS = [
+      "#{ENV['HOME']}/.parity/jsonrpc.ipc",
+      "#{ENV['HOME']}/Library/Ethereum/geth.ipc",
+      "#{ENV['HOME']}/Library/Ethereum/testnet/geth.ipc"
+    ]
+
+    def initialize(ipcpath = nil, log = true)
+      super(log)
+      ipcpath ||= IpcClient.default_path
+      @ipcpath = ipcpath
+    end
+
+    def self.default_path(paths = IPC_PATHS)
+      paths.select { |path| File.exist?(path) }.first || ""
+    end
+
+    def send_single(payload)
+      socket = UNIXSocket.new(@ipcpath)
+      socket.puts(payload)
+      read = socket.recvmsg(nil)[0]
+      socket.close
+      return read
+    end
+
+    # TODO: Not sure if multithread safe
+    # Note: Guarantees the results are in the same order as defined in batch call.
+    # client.batch do
+    #   client.eth_block_number
+    #   client.eth_mining
+    # end
+    # => [{"jsonrpc"=>"2.0", "id"=>1, "result"=>"0x26"}, {"jsonrpc"=>"2.0", "id"=>2, "result"=>false}] 
+    def send_batch(batch)
+      result = send_single(batch.to_json)
+      result = JSON.parse(result)
+
+      # Make sure the order is the same as it was when batching calls
+      # See 6 Batch here http://www.jsonrpc.org/specification
+      return result.sort_by! { |c| c['id'] }
+    end
+  end
+end