evm_client 0.1.0

data/lib/evm_client/explorer_url_helper.rb

@@ -0,0 +1,25 @@
+module EvmClient
+  module ExplorerUrlHelper
+
+    CHAIN_PREFIX = {
+      17 => "no-explorer-for-devmode.",
+      42 => "kovan.",
+      3 => "ropsten.",
+      4 => "rinkeby.",
+      5 => "goerli."
+    }
+
+    def link_to_tx(label, txid, **opts)
+      link_to label, explorer_path("tx/#{txid}"), {target: "_blank"}.merge(opts)
+    end
+
+    def link_to_address(label, address, **opts)
+      link_to label, explorer_path("address/#{address}"), {target: "_blank"}.merge(opts)
+    end
+
+    def explorer_path(suffix, version = EvmClient::Singleton.instance.get_chain)
+      prefix = CHAIN_PREFIX.fetch(version, "")
+      "https://#{prefix}etherscan.io/#{suffix}"
+    end
+  end
+end

data/lib/evm_client/formatter.rb

@@ -0,0 +1,146 @@
+module EvmClient
+  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).rjust(2, '0')}.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(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(amount, 16) / BigDecimal(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 get_base_type(typename)
+      typename.gsub(/\d+/,'')
+    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/evm_client/function.rb

@@ -0,0 +1,40 @@
+module EvmClient
+  class Function
+
+    attr_accessor :name, :inputs, :outputs, :signature, :minified_signature, :constant, :function_string
+
+    def initialize(data)
+      @name     = data["name"]
+      @constant = data["constant"]
+
+      @inputs   = data["inputs"].map do |input|
+        EvmClient::FunctionInput.new(input)
+      end
+
+      @outputs = data["outputs"].collect do |output|
+        EvmClient::FunctionOutput.new(output)
+      end
+
+      @function_string    = self.class.calc_signature(@name, @inputs)
+      @signature          = self.class.calc_id(@function_string)
+      @minified_signature = signature[0..7]
+    end
+
+    def self.to_canonical_type(type)
+      type
+      .gsub(/(int)(\z|\D)/, '\1256\2')
+      .gsub(/(uint)(\z|\D)/, '\1256\2')
+      .gsub(/(fixed)(\z|\D)/, '\1128x128\2')
+      .gsub(/(ufixed)(\z|\D)/, '\1128x128\2')
+    end
+
+    def self.calc_signature(name, inputs)
+      "#{name}(#{inputs.collect {|x| self.to_canonical_type(x.type) }.join(",")})"
+    end
+
+    def self.calc_id(signature)
+      Digest::SHA3.hexdigest(signature, 256)
+    end
+
+  end
+end

data/lib/evm_client/function_input.rb

@@ -0,0 +1,14 @@
+module EvmClient
+  class FunctionInput
+
+    attr_accessor :type, :name, :indexed
+
+    def initialize(data)
+      @type    = data["type"]
+      @name    = data["name"]
+      @indexed = data["index"]
+    end
+
+  end
+
+end

data/lib/evm_client/function_output.rb

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

data/lib/evm_client/http_client.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+require 'json'
+module EvmClient
+  class HttpClient < Client
+    attr_accessor :host, :port, :uri, :ssl, :proxy
+
+    def initialize(host, proxy = nil, log = false)
+      super(log)
+      uri = URI.parse(host)
+      raise ArgumentError unless ['http', 'https'].include? uri.scheme
+      @host = uri.host
+      @port = uri.port
+      @proxy = proxy
+      
+      @ssl = uri.scheme == 'https'
+      @uri = URI("#{uri.scheme}://#{@host}:#{@port}#{uri.path}")
+    end
+
+    def send_single(payload)
+      if @proxy.present?
+        _, p_username, p_password, p_host, p_port = @proxy.gsub(/(:|\/|@)/,' ').squeeze(' ').split
+        http = ::Net::HTTP.new(@host, @port, p_host, p_port, p_username, p_password)
+      else
+        http = ::Net::HTTP.new(@host, @port)
+      end
+
+      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)
+      response.body
+    end
+
+    def send_batch(batch)
+      result = send_single(batch.to_json)
+      result = JSON.parse(result)
+      result.sort_by! { |c| c['id'] }
+    end
+  end
+
+end

data/lib/evm_client/initializer.rb

@@ -0,0 +1,27 @@
+module EvmClient
+
+  class Initializer
+    attr_accessor :contracts, :file, :client
+
+    def initialize(file, client = EvmClient::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, @client)
+      end
+    end
+
+    def build_all
+      @contracts.each do |contract|
+        contract.build
+      end
+    end
+
+  end
+end

data/lib/evm_client/ipc_client.rb

@@ -0,0 +1,57 @@
+require 'socket'
+module EvmClient
+  class IpcClient < Client
+    attr_accessor :ipcpath
+
+    IPC_PATHS = [
+      "#{ENV['HOME']}/.parity/jsonrpc.ipc",
+      "#{ENV['HOME']}/.openethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/Library/Ethereum/geth.ipc",
+      "#{ENV['HOME']}/Library/Ethereum/testnet/geth.ipc",
+      "#{ENV['HOME']}/Library/Application\ Support/io.parity.ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/Library/Application\ Support/io.openethereum.ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/.local/share/parity/jsonrpc.ipc",
+      "#{ENV['HOME']}/.local/share/io.parity.ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/AppData/Roaming/Parity/Ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/.local/share/openethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/.local/share/io.openethereum.ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/AppData/Roaming/openethereum/Ethereum/jsonrpc.ipc",
+      "#{ENV['HOME']}/.ethereum/geth.ipc",
+      "#{ENV['HOME']}/.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)
+      path = paths.find { |path| File.exist?(path) }
+      path || raise("Ipc file not found. Please pass in the file path explicitly to IpcClient initializer")
+    end
+
+    def send_single(payload)
+      socket = UNIXSocket.new(@ipcpath)
+      socket.puts(payload)
+      read = socket.recvmsg(nil)[0]
+      socket.close
+      return read
+    end
+
+    # 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

data/lib/evm_client/project_initializer.rb

@@ -0,0 +1,28 @@
+module EvmClient
+
+  class ProjectInitializer
+
+    attr_accessor :contract_names, :combined_output, :contracts, :libraries
+
+    def initialize(location, optimize = false)
+      ENV['ETHEREUM_SOLIDITY_BINARY'] ||= "/usr/local/bin/solc"
+      solidity = ENV['ETHEREUM_SOLIDITY_BINARY']
+      contract_dir = location
+      if optimize 
+        opt_flag = "--optimize"
+      else
+        opt_flag = ""
+      end
+      compile_command = "#{solidity} #{opt_flag} --combined-json abi,bin #{contract_dir}"
+      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], self)
+      end
+    end
+
+  end
+
+end

data/lib/evm_client/railtie.rb

@@ -0,0 +1,12 @@
+module EvmClient
+
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load('tasks/ethereum_test.rake')
+      load('tasks/ethereum_node.rake')
+      load('tasks/ethereum_contract.rake')
+      load('tasks/ethereum_transaction.rake')
+    end
+  end
+
+end

data/lib/evm_client/singleton.rb

@@ -0,0 +1,39 @@
+class EvmClient::Singleton
+  
+  class << self
+
+    attr_accessor :client, :ipcpath, :host, :log, :instance, :default_account
+  
+    def instance
+      @instance ||= configure_instance(create_instance)
+    end
+  
+    def setup
+      yield(self)
+    end
+    
+    def reset
+      @instance = nil
+      @client = nil
+      @host = nil
+      @log = nil
+      @ipcpath = nil
+      @default_account = nil
+    end
+    
+    private
+      def create_instance
+        return EvmClient::IpcClient.new(@ipcpath) if @client == :ipc 
+        return EvmClient::HttpClient.new(@host) if @client == :http
+        EvmClient::IpcClient.new
+      end
+      
+      def configure_instance(instance)
+        instance.tap do |i|
+          i.default_account = @default_account if @default_account.present?
+        end
+      end
+  end
+  
+  
+end