ruby-ethereum 0.9.0

data/lib/ethereum/pruning_trie.rb

@@ -0,0 +1,28 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class PruningTrie < Trie
+    # TODO: pruning trie implementation
+
+    def clear_all(node=nil)
+      if node.nil?
+        node = @root_node
+        delete_node_storage node
+      end
+
+      return if node == BLANK_NODE
+
+      node_type = get_node_type node
+      delete_node_storage node
+
+      if NODE_KV_TYPE.include?(node_type)
+        value_is_node = node_type == :extension
+        clear_all decode_to_node(node[1]) if value_is_node
+      elsif node_type == :branch
+        16.times do |i|
+          clear_all decode_to_node(node[i])
+        end
+      end
+    end
+  end
+end

data/lib/ethereum/public_key.rb

@@ -0,0 +1,88 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class PublicKey
+
+    attr :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def encode(fmt)
+      case fmt
+      when :decimal
+        value
+      when :bin
+        "\x04#{BaseConvert.encode(value[0], 256, 32)}#{BaseConvert.encode(value[1], 256, 32)}"
+      when :bin_compressed
+        "#{(2+(value[1]%2)).chr}#{BaseConvert.encode(value[0], 256, 32)}"
+      when :hex
+        "04#{BaseConvert.encode(value[0], 16, 64)}#{BaseConvert.encode(value[1], 16, 64)}"
+      when :hex_compressed
+        "0#{2+(value[1]%2)}#{BaseConvert.encode(value[0], 16, 64)}"
+      when :bin_electrum
+        "#{BaseConvert.encode(value[0], 256, 32)}#{BaseConvert.encode(value[1], 256, 32)}"
+      when :hex_electrum
+        "#{BaseConvert.encode(value[0], 16, 64)}#{BaseConvert.encode(value[1], 16, 64)}"
+      else
+        raise FormatError, "Invalid format!"
+      end
+    end
+
+    def decode(fmt=nil)
+      fmt ||= format
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        [BaseConvert.decode(raw[1,32], 256), BaseConvert.decode(raw[33,32], 256)]
+      when :bin_compressed
+        x = BaseConvert.decode raw[1,32], 256
+        m = x*x*x + Secp256k1::A*x + Secp256k1::B
+        n = Utils.mod_exp(m, (Secp256k1::P+1)/4, Secp256k1::P)
+        q = (n + raw[0].ord) % 2
+        y = q == 1 ? (Secp256k1::P - n) : n
+        [x, y]
+      when :hex
+        [BaseConvert.decode(raw[2,64], 16), BaseConvert.decode(raw[66,64], 16)]
+      when :hex_compressed
+        PublicKey.new(Utils.decode_hex(raw)).decode :bin_compressed
+      when :bin_electrum
+        [BaseConvert.decode(raw[0,32], 256), BaseConvert.decode(raw[32,32], 256)]
+      when :hex_electrum
+        [BaseConvert.decode(raw[0,64], 16), BaseConvert.decode(raw[64,128], 16)]
+      else
+        raise FormatError, "Invalid format!"
+      end
+    end
+
+    def value
+      @value ||= decode
+    end
+
+    def format
+      return :decimal if raw.is_a?(Array)
+      return :bin if raw.size == 65 && raw[0] == "\x04"
+      return :hex if raw.size == 130 && raw[0, 2] == '04'
+      return :bin_compressed if raw.size == 33 && "\x02\x03".include?(raw[0])
+      return :hex_compressed if raw.size == 66 && %w(02 03).include?(raw[0,2])
+      return :bin_electrum if raw.size == 64
+      return :hex_electrum if raw.size == 128
+
+      raise FormatError, "Pubkey is not in recognized format"
+    end
+
+    def to_bitcoin_address(magicbyte=0)
+      bytes = encode(:bin)
+      Utils.bytes_to_base58_check Utils.hash160(bytes), magicbyte
+    end
+
+    def to_address(extended=false)
+      bytes = Utils.keccak256(encode(:bin)[1..-1])[-20..-1]
+      Address.new(bytes).to_bytes(extended)
+    end
+
+  end
+end

data/lib/ethereum/receipt.rb

@@ -0,0 +1,53 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Receipt
+    include RLP::Sedes::Serializable
+
+    extend Sedes
+
+    set_serializable_fields(
+      state_root: trie_root,
+      gas_used: big_endian_int,
+      bloom: int256,
+      logs: RLP::Sedes::CountableList.new(Log)
+    )
+
+    # initialize(state_root, gas_used, logs, bloom: nil)
+    def initialize(*args)
+      h = normalize_args args
+      super(h)
+      raise ArgumentError, "Invalid bloom filter" if h[:bloom] && h[:bloom] != self.bloom
+    end
+
+    def bloom
+      bloomables = logs.map {|l| l.bloomables }
+      Bloom.from_array bloomables.flatten
+    end
+
+    private
+
+    def normalize_args(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      field_set = %i(state_root gas_used logs bloom) # different order than serializable fields
+
+      h = {}
+      fields = field_set[0,args.size]
+      fields.zip(args).each do |(field, arg)|
+        h[field] = arg
+        field_set.delete field
+      end
+
+      options.each do |field, value|
+        if field_set.include?(field)
+          h[field] = value
+          field_set.delete field
+        end
+      end
+
+      field_set.each {|field| h[field] = nil }
+      h
+    end
+
+  end
+end

data/lib/ethereum/secp256k1.rb

@@ -0,0 +1,58 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'base64'
+require 'secp256k1'
+
+module Ethereum
+  module Secp256k1
+
+    # Elliptic curve parameters
+    P  = 2**256 - 2**32 - 977
+    N  = 115792089237316195423570985008687907852837564279074904382605163141518161494337
+    A  = 0
+    B  = 7
+    Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240
+    Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424
+    G  = [Gx, Gy].freeze
+
+    class InvalidPrivateKey < StandardError; end
+
+    class <<self # extensions
+      def priv_to_pub(priv)
+        priv = PrivateKey.new(priv)
+        privkey = ::Secp256k1::PrivateKey.new privkey: priv.encode(:bin), raw: true
+        pubkey = privkey.pubkey
+        PublicKey.new(pubkey.serialize).encode(priv.format)
+      end
+
+      def recoverable_sign(msg, privkey)
+        pk = ::Secp256k1::PrivateKey.new privkey: privkey, raw: true
+        signature = pk.ecdsa_recoverable_serialize pk.ecdsa_sign_recoverable(msg, raw: true)
+
+        v = signature[1] + 27
+        r = Utils.big_endian_to_int signature[0][0,32]
+        s = Utils.big_endian_to_int signature[0][32,32]
+
+        [v,r,s]
+      end
+
+      def signature_verify(msg, vrs, pubkey)
+        pk = ::Secp256k1::PublicKey.new(pubkey: pubkey)
+        raw_sig = Utils.zpad_int(vrs[1]) + Utils.zpad_int(vrs[2])
+
+        sig = ::Secp256k1::C::ECDSASignature.new
+        sig[:data].to_ptr.write_bytes(raw_sig)
+
+        pk.ecdsa_verify(msg, sig)
+      end
+
+      def recover_pubkey(msg, vrs, compressed: false)
+        pk = ::Secp256k1::PublicKey.new(flags: ::Secp256k1::ALL_FLAGS)
+        sig = Utils.zpad_int(vrs[1]) + Utils.zpad_int(vrs[2])
+        recsig = pk.ecdsa_recoverable_deserialize(sig, vrs[0]-27)
+        pk.public_key = pk.ecdsa_recover msg, recsig, raw: true
+        pk.serialize compressed: compressed
+      end
+    end
+  end
+end

data/lib/ethereum/secure_trie.rb

@@ -0,0 +1,49 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'forwardable'
+
+module Ethereum
+  class SecureTrie
+
+    extend Forwardable
+    def_delegators :@trie, :root_hash, :set_root_hash, :root_hash_valid?, :process_epoch, :commit_death_row, :revert_epoch, :has_key?, :include?, :size, :to_h, :db
+
+    def initialize(trie)
+      @trie = trie
+      @db = trie.db
+    end
+
+    def [](k)
+      @trie[Utils.keccak256(k)]
+    end
+    alias :get :[]
+
+    def []=(k, v)
+      h = Utils.keccak256 k
+      @db.put h, k
+      @trie[h] = v
+    end
+    alias :set :[]=
+
+    def delete(k)
+      @trie.delete Utils.keccak256(k)
+    end
+
+    def to_h
+      o = {}
+      @trie.to_h.each do |h, v|
+        k = @db.get h
+        o[k] = v
+      end
+      o
+    end
+
+    def each(&block)
+      @trie.each do |h, v|
+        k = @db.get h
+        block.call k, v
+      end
+    end
+
+  end
+end

data/lib/ethereum/sedes.rb

@@ -0,0 +1,42 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Sedes
+    include RLP::Sedes
+
+    extend self
+
+    def address
+      Binary.fixed_length(20, allow_empty: true)
+    end
+
+    def int20
+      BigEndianInt.new(20)
+    end
+
+    def int32
+      BigEndianInt.new(32)
+    end
+
+    def int256
+      BigEndianInt.new(256)
+    end
+
+    def hash32
+      Binary.fixed_length(32)
+    end
+
+    def trie_root
+      Binary.fixed_length(32, allow_empty: true)
+    end
+
+    def big_endian_int
+      RLP::Sedes.big_endian_int
+    end
+
+    def binary
+      RLP::Sedes.binary
+    end
+
+  end
+end

data/lib/ethereum/special_contract.rb

@@ -0,0 +1,95 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class SpecialContract
+
+    class ECRecover
+      def call(ext, msg)
+        gas_cost = Opcodes::GECRECOVER
+        return 0, 0, [] if msg.gas < gas_cost
+
+        message_hash_ints = [0] * 32
+        msg.data.extract_copy(message_hash_ints, 0, 0, 32)
+        message_hash = Utils.int_array_to_bytes message_hash_ints
+
+        v = msg.data.extract32(32)
+        r = msg.data.extract32(64)
+        s = msg.data.extract32(96)
+
+        if r >= Secp256k1::N || s >= Secp256k1::N || v < 27 || v > 28
+          return 1, msg.gas - gas_cost, []
+        end
+
+        signature_ints = [0] * 64
+        msg.data.extract_copy signature_ints, 0, 64, 32  # r
+        msg.data.extract_copy signature_ints, 32, 96, 32 # s
+        signature = Utils.int_array_to_bytes signature_ints
+
+        pub = nil
+        begin
+          pub = Secp256k1.recover_pubkey(message_hash, [v,r,s])
+        rescue
+          return 1, msg.gas - gas_cost, []
+        end
+
+        pubhash = Utils.keccak256(pub[1..-1])[-20..-1]
+        o = Utils.bytes_to_int_array Utils.zpad(pubhash, 32)
+
+        return 1, msg.gas - gas_cost, o
+      end
+    end
+
+    class SHA256
+      def call(ext, msg)
+        gas_cost = Opcodes::GSHA256BASE +
+          (Utils.ceil32(msg.data.size) / 32) * Opcodes::GSHA256WORD
+        return 0, 0, [] if msg.gas < gas_cost
+
+        d = msg.data.extract_all
+        o = Utils.bytes_to_int_array Utils.sha256(d)
+
+        return 1, msg.gas - gas_cost, o
+      end
+    end
+
+    class RIPEMD160
+      def call(ext, msg)
+        gas_cost = Opcodes::GRIPEMD160BASE +
+          (Utils.ceil32(msg.data.size) / 32) * Opcodes::GRIPEMD160WORD
+        return 0, 0, [] if msg.gas < gas_cost
+
+        d = msg.data.extract_all
+        o = Utils.bytes_to_int_array Utils.zpad(Utils.ripemd160(d), 32)
+
+        return 1, msg.gas - gas_cost, o
+      end
+    end
+
+    class Identity
+      def call(ext, msg)
+        gas_cost = Opcodes::GIDENTITYBASE +
+          (Utils.ceil32(msg.data.size) / 32) * Opcodes::GIDENTITYWORD
+        return 0, 0, [] if msg.gas < gas_cost
+
+        o = []
+        msg.data.extract_copy(o, 0, 0, msg.data.size)
+
+        return 1, msg.gas - gas_cost, o
+      end
+    end
+
+    DEPLOY = {
+      '0000000000000000000000000000000000000001' => ECRecover.new,
+      '0000000000000000000000000000000000000002' => SHA256.new,
+      '0000000000000000000000000000000000000003' => RIPEMD160.new,
+      '0000000000000000000000000000000000000004' => Identity.new
+    }.map {|k,v| [Utils.decode_hex(k), v] }.to_h.freeze
+
+    class <<self
+      def [](address)
+        DEPLOY[address]
+      end
+    end
+
+  end
+end

data/lib/ethereum/spv.rb

@@ -0,0 +1,79 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethereum/spv/proof'
+require 'ethereum/spv/proof_constructor'
+require 'ethereum/spv/proof_verifier'
+
+module Ethereum
+  module SPV
+
+    class <<self
+
+      def proofs
+        @proofs ||= []
+      end
+
+      def proof
+        proofs.last
+      end
+
+      def grabbing(node)
+        proof.grabbing node if proof
+      end
+
+      def store(node)
+        proof.store node if proof
+      end
+
+      def record
+        proofs.push ProofConstructor.new
+        result = yield
+        nodes = proof.decoded_nodes
+        [result, nodes]
+      ensure
+        proofs.pop
+      end
+
+      def verify(nodes)
+        proofs.push ProofVerifier.new(nodes: nodes)
+        yield
+      ensure
+        proofs.pop
+      end
+
+      def mode
+        case proof
+        when ProofConstructor
+          :record
+        when ProofVerifier
+          :verify
+        else
+          nil
+        end
+      end
+
+      def make_transaction_proof(block, tx)
+        result, nodes = record do
+          block.apply_transaction(tx)
+        end
+
+        nodes
+          .map {|x| RLP.encode(x) }
+          .uniq
+          .map {|x| RLP.decode(x) }
+      end
+
+      def verify_transaction_proof(block, tx, nodes)
+        verify do
+          block.apply_transaction(tx)
+        end
+        true
+      rescue
+        puts $!
+        false
+      end
+
+    end
+
+  end
+end