eth 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e66df112e63648f3f2d9c0aaeda96f69d0d080e
+  data.tar.gz: 592b07bd1c4de2d7d0ca45fcdd9af89dcd016352
+SHA512:
+  metadata.gz: 79b7fde0612955430559fdb38087ebd04bb9eab172250ea90a20d00e927b8b3ade6b1f34c8dff979564a72db5f2532ec96e427ba6e9c116d0d7c6d9e6ee9ee4e
+  data.tar.gz: ba31aabf2af13fb361eaeae8c145954f8a7fe45587ca823ab8fafb3ea9779fd05b2ab7defdc847cd1960c028d4f97115f04b01f3111ea749bc0925df47706778

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,4 @@
+--require pry
+--require spec_helper
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ethereum-tx.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Steve Ellis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# Ethereum::Tx
+
+A simple, light weight, library to build and sign Ethereum transactions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ethereum-tx'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ethereum-tx
+
+## Usage
+
+### Keys
+Create a new key:
+```
+key = Ethereum::Key.new
+```
+Or import and existing one:
+```
+old_key = Ethereum::Key.new private_key
+```
+
+### Transactions
+
+Build a transaction from scratch:
+```
+tx = Ethereum::Tx.new to: key.address, gas_price: 25_000, gas_limit: 25_000
+tx.data = 'abcdef' #optional
+tx.value = 1_000_000_000_000 #optional
+```
+Or decode an encoded raw transaction:
+```
+tx = Ethereum::Tx.decode hex
+```
+
+Then sign the transaction:
+```
+tx.sign key
+```
+Finally you can broadcast the raw transaction, `tx.encoded`, to your Ethereum node.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/se3000/ethereum-tx.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## TODO
+- Better test suite.
+- Expose API for HD keys.
+- Separate out code pulled from [bitcoin-ruby](https://github.com/lian/bitcoin-ruby) and [ruby-ethereum](github.com/janx/ruby-ethereum) into their own gems to eliminate duplication.
+- Support signing with [libsecp256k1](https://github.com/bitcoin-core/secp256k1).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ethereum-tx"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/eth.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eth/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eth"
+  spec.version       = Eth::VERSION
+  spec.authors       = ["Steve Ellis"]
+  spec.email         = ["email@steveell.is"]
+
+  spec.summary       = %q{Simple API to sign Ethereum transactions.}
+  spec.description   = %q{Library to build, parse, and sign Ethereum transactions.}
+  spec.homepage      = "https://github.com/se3000/ruby-eth"
+  spec.license       = "MIT"
+
+  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"]
+
+  spec.add_dependency "digest-sha3", "~> 1.1"
+  spec.add_dependency "ethereum-base", "0.1.2"
+  spec.add_dependency "ffi", "~> 1.0"
+  spec.add_dependency "money-tree", "~> 0.9"
+  spec.add_dependency "rlp", "~> 0.7"
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "pry", "~> 0.1"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/eth.rb

@@ -0,0 +1,25 @@
+require 'digest/sha3'
+require 'ethereum/base'
+require 'ffi'
+require 'money-tree'
+require 'rlp'
+
+module Eth
+
+  BYTE_ZERO = "\x00".freeze
+  GTXCOST = 21000       # TX BASE GAS COST
+  GTXDATANONZERO = 68   # TX DATA NON ZERO BYTE GAS COST
+  GTXDATAZERO = 4       # TX DATA ZERO BYTE GAS COST
+  SECP256K1_N = 115792089237316195423570985008687907852837564279074904382605163141518161494337
+  UINT_MAX = 2**256 - 1
+
+  autoload :Key, 'eth/key'
+  autoload :OpenSsl, 'eth/open_ssl'
+  autoload :Sedes, 'eth/sedes'
+  autoload :Tx, 'eth/tx'
+  autoload :Utils, 'eth/utils'
+
+  class ValidationError < StandardError; end
+  class InvalidTransaction < ValidationError; end
+
+end

data/lib/eth/key.rb

@@ -0,0 +1,53 @@
+module Eth
+  class Key
+
+    attr_reader :private_key, :public_key
+
+    def initialize(priv: nil)
+      @private_key = MoneyTree::PrivateKey.new key: priv
+      @public_key = MoneyTree::PublicKey.new private_key, compressed: false
+    end
+
+    def private_hex
+      private_key.to_hex
+    end
+
+    def public_bytes
+      public_key.to_bytes
+    end
+
+    def public_hex
+      public_key.to_hex
+    end
+
+    def to_address
+      Utils.bin_to_hex(Utils.keccak256(public_bytes[1..-1])[-20..-1])
+    end
+
+    def sign(message)
+      hash = message_hash(message)
+      loop do
+        signature = OpenSsl.sign_compact hash, private_hex, public_hex
+        return signature if valid_s? signature
+      end
+    end
+
+    def verify_signature(message, signature)
+      hash = message_hash(message)
+      public_hex == OpenSsl.recover_compact(hash, signature)
+    end
+
+
+    private
+
+    def message_hash(message)
+      Utils.keccak256 message
+    end
+
+    def valid_s?(signature)
+      s_value = Utils.v_r_s_for(signature).last
+      s_value <= SECP256K1_N/2 && s_value != 0
+    end
+
+  end
+end

data/lib/eth/open_ssl.rb

@@ -0,0 +1,191 @@
+# lifted from https://github.com/lian/bitcoin-ruby
+# thanks to everyone there for figuring this out
+# TODO: Pull shared code out into a separate library
+
+module Eth
+  class OpenSsl
+    extend FFI::Library
+
+    if FFI::Platform.windows?
+      ffi_lib 'libeay32', 'ssleay32'
+    else
+      ffi_lib 'ssl'
+    end
+
+    NID_secp256k1 = 714
+    POINT_CONVERSION_COMPRESSED = 2
+    POINT_CONVERSION_UNCOMPRESSED = 4
+
+    attach_function :SSL_library_init, [], :int
+    attach_function :ERR_load_crypto_strings, [], :void
+    attach_function :SSL_load_error_strings, [], :void
+    attach_function :RAND_poll, [], :int
+
+    attach_function :BN_CTX_free, [:pointer], :int
+    attach_function :BN_CTX_new, [], :pointer
+    attach_function :BN_add, [:pointer, :pointer, :pointer], :int
+    attach_function :BN_bin2bn, [:pointer, :int, :pointer], :pointer
+    attach_function :BN_bn2bin, [:pointer, :pointer], :int
+    attach_function :BN_cmp, [:pointer, :pointer], :int
+    attach_function :BN_dup, [:pointer], :pointer
+    attach_function :BN_free, [:pointer], :int
+    attach_function :BN_mod_inverse, [:pointer, :pointer, :pointer, :pointer], :pointer
+    attach_function :BN_mod_mul, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :BN_mod_sub, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :BN_mul_word, [:pointer, :int], :int
+    attach_function :BN_new, [], :pointer
+    attach_function :BN_num_bits, [:pointer], :int
+    attach_function :BN_rshift, [:pointer, :pointer, :int], :int
+    attach_function :BN_set_word, [:pointer, :int], :int
+    attach_function :ECDSA_SIG_free, [:pointer], :void
+    attach_function :ECDSA_do_sign, [:pointer, :uint, :pointer], :pointer
+    attach_function :EC_GROUP_get_curve_GFp, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :EC_GROUP_get_degree, [:pointer], :int
+    attach_function :EC_GROUP_get_order, [:pointer, :pointer, :pointer], :int
+    attach_function :EC_KEY_free, [:pointer], :int
+    attach_function :EC_KEY_get0_group, [:pointer], :pointer
+    attach_function :EC_KEY_new_by_curve_name, [:int], :pointer
+    attach_function :EC_KEY_set_conv_form, [:pointer, :int], :void
+    attach_function :EC_KEY_set_private_key, [:pointer, :pointer], :int
+    attach_function :EC_KEY_set_public_key,  [:pointer, :pointer], :int
+    attach_function :EC_POINT_free, [:pointer], :int
+    attach_function :EC_POINT_mul, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int
+    attach_function :EC_POINT_new, [:pointer], :pointer
+    attach_function :EC_POINT_set_compressed_coordinates_GFp, [:pointer, :pointer, :pointer, :int, :pointer], :int
+    attach_function :i2o_ECPublicKey, [:pointer, :pointer], :uint
+
+    def self.BN_num_bytes(ptr); (BN_num_bits(ptr) + 7) / 8; end
+
+    # def self.sign_compact(hash, private_key, public_key_hex = nil, pubkey_compressed = nil)
+    def self.sign_compact(hash, private_key, public_key_hex)
+      private_key = [private_key].pack("H*") if private_key.bytesize >= 64
+      private_key_hex = private_key.unpack("H*")[0]
+
+      # public_key_hex = regenerate_key(private_key_hex).last unless public_key_hex
+      # pubkey_compressed = (public_key_hex[0..1] == "04" ? false : true) unless pubkey_compressed
+      pubkey_compressed = false
+
+      init_ffi_ssl
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+      priv_key = BN_bin2bn(private_key, private_key.bytesize, BN_new())
+
+      group, order, ctx = EC_KEY_get0_group(eckey), BN_new(), BN_CTX_new()
+      EC_GROUP_get_order(group, order, ctx)
+
+      pub_key = EC_POINT_new(group)
+      EC_POINT_mul(group, pub_key, priv_key, nil, nil, ctx)
+      EC_KEY_set_private_key(eckey, priv_key)
+      EC_KEY_set_public_key(eckey, pub_key)
+
+      signature = ECDSA_do_sign(hash, hash.bytesize, eckey)
+
+      BN_free(order)
+      BN_CTX_free(ctx)
+      EC_POINT_free(pub_key)
+      BN_free(priv_key)
+      EC_KEY_free(eckey)
+
+      buf, rec_id, head = FFI::MemoryPointer.new(:uint8, 32), nil, nil
+      r, s = signature.get_array_of_pointer(0, 2).map{|i| BN_bn2bin(i, buf); buf.read_string(BN_num_bytes(i)).rjust(32, "\x00") }
+
+      if signature.get_array_of_pointer(0, 2).all?{|i| BN_num_bits(i) <= 256 }
+        4.times{|i|
+          head = [ 27 + i + (pubkey_compressed ? 4 : 0) ].pack("C")
+          if public_key_hex == recover_public_key_from_signature(hash, [head, r, s].join, i, pubkey_compressed)
+            rec_id = i; break
+          end
+        }
+      end
+
+      ECDSA_SIG_free(signature)
+
+      [ head, [r,s] ].join if rec_id
+    end
+
+    def self.recover_public_key_from_signature(message_hash, signature, rec_id, is_compressed)
+      return nil if rec_id < 0 or signature.bytesize != 65
+      init_ffi_ssl
+
+      signature = FFI::MemoryPointer.from_string(signature)
+      #signature_bn = BN_bin2bn(signature, 65, BN_new())
+      r = BN_bin2bn(signature[1], 32, BN_new())
+      s = BN_bin2bn(signature[33], 32, BN_new())
+
+      n, i = 0, rec_id / 2
+      eckey = EC_KEY_new_by_curve_name(NID_secp256k1)
+
+      EC_KEY_set_conv_form(eckey, POINT_CONVERSION_COMPRESSED) if is_compressed
+
+      group = EC_KEY_get0_group(eckey)
+      order = BN_new()
+      EC_GROUP_get_order(group, order, nil)
+      x = BN_dup(order)
+      BN_mul_word(x, i)
+      BN_add(x, x, r)
+
+      field = BN_new()
+      EC_GROUP_get_curve_GFp(group, field, nil, nil, nil)
+
+      if BN_cmp(x, field) >= 0
+        [r, s, order, x, field].each{|i| BN_free(i) }
+        EC_KEY_free(eckey)
+        return nil
+      end
+
+      big_r = EC_POINT_new(group)
+      EC_POINT_set_compressed_coordinates_GFp(group, big_r, x, rec_id % 2, nil)
+
+      big_q = EC_POINT_new(group)
+      n = EC_GROUP_get_degree(group)
+      e = BN_bin2bn(message_hash, message_hash.bytesize, BN_new())
+      BN_rshift(e, e, 8 - (n & 7)) if 8 * message_hash.bytesize > n
+
+      ctx = BN_CTX_new()
+      zero, rr, sor, eor = BN_new(), BN_new(), BN_new(), BN_new()
+      BN_set_word(zero, 0)
+      BN_mod_sub(e, zero, e, order, ctx)
+      BN_mod_inverse(rr, r, order, ctx)
+      BN_mod_mul(sor, s, rr, order, ctx)
+      BN_mod_mul(eor, e, rr, order, ctx)
+      EC_POINT_mul(group, big_q, eor, big_r, sor, ctx)
+      EC_KEY_set_public_key(eckey, big_q)
+      BN_CTX_free(ctx)
+
+      [r, s, order, x, field, e, zero, rr, sor, eor].each{|i| BN_free(i) }
+      [big_r, big_q].each{|i| EC_POINT_free(i) }
+
+      length = i2o_ECPublicKey(eckey, nil)
+      buf = FFI::MemoryPointer.new(:uint8, length)
+      ptr = FFI::MemoryPointer.new(:pointer).put_pointer(0, buf)
+      pub_hex = if i2o_ECPublicKey(eckey, ptr) == length
+        buf.read_string(length).unpack("H*")[0]
+      end
+
+      EC_KEY_free(eckey)
+
+      pub_hex
+    end
+
+    def self.recover_compact(hash, signature)
+      return false if signature.bytesize != 65
+      #i = signature.unpack("C")[0] - 27
+      #pubkey = recover_public_key_from_signature(hash, signature, (i & ~4), i >= 4)
+
+      version = signature.unpack('C')[0]
+      return false if version < 27 or version > 34
+
+      compressed = (version >= 31) ? (version -= 4; true) : false
+      pubkey = recover_public_key_from_signature(hash, signature, version-27, compressed)
+    end
+
+    def self.init_ffi_ssl
+      return if @ssl_loaded
+      SSL_library_init()
+      ERR_load_crypto_strings()
+      SSL_load_error_strings()
+      RAND_poll()
+      @ssl_loaded = true
+    end
+
+  end
+end

data/lib/eth/sedes.rb

@@ -0,0 +1,40 @@
+module Eth
+  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/eth/tx.rb

@@ -0,0 +1,103 @@
+module Eth
+  class Tx
+
+    include RLP::Sedes::Serializable
+    extend Sedes
+
+    set_serializable_fields({
+      nonce: big_endian_int,
+      gas_price: big_endian_int,
+      gas_limit: big_endian_int,
+      to: address,
+      value: big_endian_int,
+      data: binary,
+      v: big_endian_int,
+      r: big_endian_int,
+      s: big_endian_int
+    })
+
+    attr_writer :signature
+
+    def self.decode(data)
+      data = Utils.hex_to_bin(data) if data.match(/\A\h+\Z/)
+      deserialize(RLP.decode data)
+    end
+
+    def initialize(*args)
+      fields = {v: 0, r: 0, s: 0}.merge parse_field_args(args)
+      fields[:to] = Utils.normalize_address(fields[:to])
+
+      serializable_initialize fields
+
+      check_transaction_validity
+    end
+
+    def unsigned_encoded
+      RLP.encode self, sedes: Tx.exclude([:v, :r, :s])
+    end
+
+    def encoded
+      RLP.encode self
+    end
+
+    def hex
+      bin_to_hex encoded
+    end
+
+    def sign(key)
+      self.signature = key.sign(unsigned_encoded)
+      self.vrs = Utils.v_r_s_for signature
+
+      self
+    end
+
+    def to_h
+      self.class.serializable_fields.keys.inject({}) do |hash, field|
+        hash[field] = send field
+        hash
+      end
+    end
+
+    def from
+      return @from if @from
+      @from ||= OpenSsl.recover_compact(signature_hash, signature) if signature
+    end
+
+    def signature
+      return @signature if @signature
+      self.signature = [v, r, s].map do |integer|
+        Utils.int_to_base256 integer
+      end.join if [v, r, s].all?
+    end
+
+
+    private
+
+    def check_transaction_validity
+      if [gas_price, gas_limit, value, nonce].max > UINT_MAX
+        raise InvalidTransaction, "Values way too high!"
+      elsif gas_limit < intrinsic_gas_used
+        raise InvalidTransaction, "Gas limit too low"
+      end
+    end
+
+    def vrs=(vrs)
+      self.v = vrs[0]
+      self.r = vrs[1]
+      self.s = vrs[2]
+    end
+
+    def intrinsic_gas_used
+      num_zero_bytes = data.count(BYTE_ZERO)
+      num_non_zero_bytes = data.size - num_zero_bytes
+
+      GTXCOST + GTXDATAZERO * num_zero_bytes +
+        GTXDATANONZERO * num_non_zero_bytes
+    end
+
+    def signature_hash
+      Utils.keccak256 unsigned_encoded
+    end
+
+  end
+end

data/lib/eth/utils.rb

@@ -0,0 +1,56 @@
+module Eth
+
+  module Utils
+
+    extend self
+
+    def keccak256(message)
+      Digest::SHA3.new(256).digest(message)
+    end
+
+    def normalize_address(address)
+      if address.nil? || address == ''
+        ''
+      elsif address.size == 40
+        hex_to_bin address
+      elsif address.size == 42 && address[0..1] == '0x'
+        hex_to_bin address[2..-1]
+      else
+        address
+      end
+    end
+
+    def bin_to_hex(string)
+      string.unpack("H*")[0]
+    end
+
+    def hex_to_bin(string)
+      [string].pack("H*")
+    end
+
+    def base256_to_int(string)
+      string.bytes.inject do |result, byte|
+        result *= 256
+        result + byte
+      end
+    end
+
+    def int_to_base256(int)
+      bytes = []
+      while int > 0 do
+        bytes.unshift(int % 256)
+        int /= 256
+      end
+      bytes.pack('C*')
+    end
+
+    def v_r_s_for(signature)
+      [
+        signature[0].bytes[0],
+        Utils.base256_to_int(signature[1..32]),
+        Utils.base256_to_int(signature[33..65]),
+      ]
+    end
+
+  end
+end

data/lib/eth/version.rb

@@ -0,0 +1,3 @@
+module Eth
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: eth
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Steve Ellis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digest-sha3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: ethereum-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: money-tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Library to build, parse, and sign Ethereum transactions.
+email:
+- email@steveell.is
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- eth.gemspec
+- lib/eth.rb
+- lib/eth/key.rb
+- lib/eth/open_ssl.rb
+- lib/eth/sedes.rb
+- lib/eth/tx.rb
+- lib/eth/utils.rb
+- lib/eth/version.rb
+homepage: https://github.com/se3000/ruby-eth
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Simple API to sign Ethereum transactions.
+test_files: []
+has_rdoc: