ruby-ethereum 0.9.0

data/lib/ethereum/index.rb

@@ -0,0 +1,97 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+
+  ##
+  # Collection of indexes.
+  #
+  # * children - needed to get the uncles of a block
+  # * blocknumbers - needed to mark the longest chain (path to top)
+  # * transactions - optional to resolve txhash to block:tx
+  #
+  class Index
+
+    attr :db
+
+    def initialize(env, index_transactions=true)
+      @env = env
+      @db = env.db
+      @index_transactions = index_transactions
+    end
+
+    def add_block(blk)
+      add_child blk.prevhash, blk.full_hash
+      add_transactions blk if @index_transactions
+    end
+
+    def add_child(parent_hash, child_hash)
+      children = (get_children(parent_hash) + [child_hash]).uniq
+      @db.put_temporarily child_db_key(parent_hash), RLP.encode(children)
+    end
+
+    # start from head and update until the existing indices match the block
+    def update_blocknumbers(blk)
+      loop do
+        if blk.number > 0
+          @db.put_temporarily block_by_number_key(blk.number), blk.full_hash
+        else
+          @db.put block_by_number_key(blk.number), blk.full_hash
+        end
+        @db.commit_refcount_changes blk.number
+
+        break if blk.number == 0
+
+        blk = blk.get_parent()
+        break if has_block_by_number(blk.number) && get_block_by_number(blk.number) == blk.full_hash
+      end
+    end
+
+    def has_block_by_number(number)
+      @db.has_key? block_by_number_key(number)
+    end
+
+    def get_block_by_number(number)
+      @db.get block_by_number_key(number)
+    end
+
+    def get_children(blk_hash)
+      key = child_db_key blk_hash
+      @db.has_key?(key) ? RLP.decode(@db.get(key)) : []
+    end
+
+    ##
+    # @param txhash [String] transaction hash
+    #
+    # @return [[Transaction, Block, Integer]] transaction, block, and tx number
+    #
+    def get_transaction(txhash)
+      blockhash, tx_num_enc = RLP.decode @db.get(txhash)
+      blk = RLP.decode(@db.get(blockhash), sedes: Block, env: @env)
+
+      num = Utils.decode_int tx_num_enc
+      tx_data = blk.get_transaction num
+
+      [tx_data, blk, num]
+    end
+
+    private
+
+    def child_db_key(blk_hash)
+      "ci:#{blk_hash}"
+    end
+
+    def add_transactions(blk)
+      blk.get_transactions.each_with_index do |tx, i|
+        @db.put_temporarily tx.full_hash, RLP.encode([blk.full_hash, i])
+      end
+
+      @db.commit_refcount_changes blk.number
+    end
+
+    def block_by_number_key(number)
+      "blocknumber:#{number}"
+    end
+
+  end
+
+end

data/lib/ethereum/log.rb

@@ -0,0 +1,43 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Log
+    include RLP::Sedes::Serializable
+
+    set_serializable_fields(
+      address: Sedes.address,
+      topics: RLP::Sedes::CountableList.new(Sedes.int32),
+      data: Sedes.binary
+    )
+
+    def initialize(*args)
+      h = parse_field_args args
+
+      address = h[:address]
+      raise ArgumentError, "invalid address: #{address}" unless address.size == 20 || address.size == 40
+
+      address = Utils.decode_hex(address) if address.size == 40
+
+      h[:address] = address
+      super(h)
+    end
+
+    def bloomables
+      topics.map {|t| Sedes.int32.serialize(t) }.unshift(address)
+    end
+
+    def to_h
+      { bloom: Utils.encode_hex(Bloom.b256(Bloom.from_array(bloomables))),
+        address: Utils.encode_hex(address),
+        data: "0x#{Utils.encode_hex(data)}",
+        topics: topics.map {|t| Utils.encode_hex(Sedes.int32.serialize(t)) }
+      }
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{object_id} address=#{Utils.encode_hex(address)} topics=#{topics} data=#{data}>"
+    end
+    alias :inspect :to_s
+
+  end
+end

data/lib/ethereum/miner.rb

@@ -0,0 +1,84 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Miner
+
+    class <<self
+      def check_pow(block_number, header_hash, mixhash, nonce, difficulty)
+        Logger.new('eth.miner').debug "checking pow",  block_number: block_number
+
+        return false if mixhash.size != 32 || header_hash.size != 32 || nonce.size != 8
+
+        cache = Ethash.get_cache block_number
+        mining_output = hashimoto_light block_number, cache, header_hash, nonce
+
+        return false if mining_output[:mixhash] != mixhash
+        return Utils.big_endian_to_int(mining_output[:result]) <= (Constant::TT256 / difficulty)
+      end
+      lru_cache :check_pow, 32
+
+      def hashimoto_light(*args)
+        Ethash.hashimoto_light(*args)
+      end
+    end
+
+
+    ##
+    # Mines on the current head. Stores received transactions.
+    #
+    # The process of finalising a block involves four stages:
+    #
+    # 1. validate (or, if mining, determine) uncles;
+    # 2. validate (or, if mining, determine) transactions;
+    # 3. apply rewards;
+    # 4. verify (or, if mining, compute a valid) state and nonce.
+    #
+    def initialize(block)
+      @nonce = 0
+      @block = block
+
+      logger.debug "mining", block_number: @block.number, block_hash: Utils.encode_hex(@block.full_hash), block_difficulty: @block.difficulty
+    end
+
+    def mine(rounds=1000, start_nonce=0)
+      blk = @block
+      bin_nonce, mixhash = _mine(blk.number, blk.difficulty, blk.mining_hash, start_nonce, rounds)
+
+      if bin_nonce.true?
+        blk.mixhash = mixhash
+        blk.nonce = bin_nonce
+        return blk
+      end
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new 'eth.miner'
+    end
+
+    def _mine(block_number, difficulty, mining_hash, start_nonce=0, rounds=1000)
+      raise AssertError, "start nonce must be an integer" unless start_nonce.is_a?(Integer)
+
+      cache = Ethash.get_cache block_number
+      nonce = start_nonce
+      difficulty ||= 1
+      target = Utils.zpad Utils.int_to_big_endian(Constant::TT256 / difficulty), 32
+
+      (1..rounds).each do |i|
+        bin_nonce = Utils.zpad Utils.int_to_big_endian((nonce+i) & Constant::TT64M1), 8
+        o = Miner.hashimoto_light block_number, cache, mining_hash, bin_nonce
+
+        if o[:result] <= target
+          logger.debug "nonce found"
+          raise AssertError, "nonce must be 8 bytes long" unless bin_nonce.size == 8
+          raise AssertError, "mishash must be 32 bytes long" unless o[:mixhash].size == 32
+          return bin_nonce, o[:mixhash]
+        end
+      end
+
+      return nil, nil
+    end
+
+  end
+end

data/lib/ethereum/opcodes.rb

@@ -0,0 +1,131 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Opcodes
+
+    TABLE = {
+      # schema: [op, ins, outs, gas]
+      0x00 => [:STOP, 0, 0, 0],
+      0x01 => [:ADD, 2, 1, 3],
+      0x02 => [:MUL, 2, 1, 5],
+      0x03 => [:SUB, 2, 1, 3],
+      0x04 => [:DIV, 2, 1, 5],
+      0x05 => [:SDIV, 2, 1, 5],
+      0x06 => [:MOD, 2, 1, 5],
+      0x07 => [:SMOD, 2, 1, 5],
+      0x08 => [:ADDMOD, 3, 1, 8],
+      0x09 => [:MULMOD, 3, 1, 8],
+      0x0a => [:EXP, 2, 1, 10],
+      0x0b => [:SIGNEXTEND, 2, 1, 5],
+      0x10 => [:LT, 2, 1, 3],
+      0x11 => [:GT, 2, 1, 3],
+      0x12 => [:SLT, 2, 1, 3],
+      0x13 => [:SGT, 2, 1, 3],
+      0x14 => [:EQ, 2, 1, 3],
+      0x15 => [:ISZERO, 1, 1, 3],
+      0x16 => [:AND, 2, 1, 3],
+      0x17 => [:OR, 2, 1, 3],
+      0x18 => [:XOR, 2, 1, 3],
+      0x19 => [:NOT, 1, 1, 3],
+      0x1a => [:BYTE, 2, 1, 3],
+      0x20 => [:SHA3, 2, 1, 30],
+      0x30 => [:ADDRESS, 0, 1, 2],
+      0x31 => [:BALANCE, 1, 1, 20],
+      0x32 => [:ORIGIN, 0, 1, 2],
+      0x33 => [:CALLER, 0, 1, 2],
+      0x34 => [:CALLVALUE, 0, 1, 2],
+      0x35 => [:CALLDATALOAD, 1, 1, 3],
+      0x36 => [:CALLDATASIZE, 0, 1, 2],
+      0x37 => [:CALLDATACOPY, 3, 0, 3],
+      0x38 => [:CODESIZE, 0, 1, 2],
+      0x39 => [:CODECOPY, 3, 0, 3],
+      0x3a => [:GASPRICE, 0, 1, 2],
+      0x3b => [:EXTCODESIZE, 1, 1, 20],
+      0x3c => [:EXTCODECOPY, 4, 0, 20],
+      0x40 => [:BLOCKHASH, 1, 1, 20],
+      0x41 => [:COINBASE, 0, 1, 2],
+      0x42 => [:TIMESTAMP, 0, 1, 2],
+      0x43 => [:NUMBER, 0, 1, 2],
+      0x44 => [:DIFFICULTY, 0, 1, 2],
+      0x45 => [:GASLIMIT, 0, 1, 2],
+      0x50 => [:POP, 1, 0, 2],
+      0x51 => [:MLOAD, 1, 1, 3],
+      0x52 => [:MSTORE, 2, 0, 3],
+      0x53 => [:MSTORE8, 2, 0, 3],
+      0x54 => [:SLOAD, 1, 1, 50],
+      0x55 => [:SSTORE, 2, 0, 0],
+      0x56 => [:JUMP, 1, 0, 8],
+      0x57 => [:JUMPI, 2, 0, 10],
+      0x58 => [:PC, 0, 1, 2],
+      0x59 => [:MSIZE, 0, 1, 2],
+      0x5a => [:GAS, 0, 1, 2],
+      0x5b => [:JUMPDEST, 0, 0, 1],
+      0xa0 => [:LOG0, 2, 0, 375],
+      0xa1 => [:LOG1, 3, 0, 750],
+      0xa2 => [:LOG2, 4, 0, 1125],
+      0xa3 => [:LOG3, 5, 0, 1500],
+      0xa4 => [:LOG4, 6, 0, 1875],
+      0xf0 => [:CREATE, 3, 1, 32000],
+      0xf1 => [:CALL, 7, 1, 40],
+      0xf2 => [:CALLCODE, 7, 1, 40],
+      0xf3 => [:RETURN, 2, 0, 0],
+      0xf4 => [:DELEGATECALL, 6, 0, 40],
+      0xff => [:SUICIDE, 1, 0, 0],
+    }
+
+    PREFIX_LOG  = 'LOG'.freeze
+    PREFIX_PUSH = 'PUSH'.freeze
+    PREFIX_DUP  = 'DUP'.freeze
+    PREFIX_SWAP = 'SWAP'.freeze
+
+    32.times do |i|
+      TABLE[0x60+i] = [:"#{PREFIX_PUSH}#{i+1}", 0, 1, 3]
+    end
+
+    16.times do |i|
+      TABLE[0X80+i] = [:"#{PREFIX_DUP}#{i+1}", i+1, i+2, 3]
+      TABLE[0x90+i] = [:"#{PREFIX_SWAP}#{i+1}", i+2, i+2, 3]
+    end
+
+    REVERSE_TABLE = {}
+    TABLE.each do |code, defn|
+      const_set defn[0], defn
+      REVERSE_TABLE[defn[0]] = code
+    end
+
+    TABLE.freeze
+    REVERSE_TABLE.freeze
+
+    # Non-opcode gas prices
+    GDEFAULT = 1
+    GMEMORY = 3
+    GQUADRATICMEMDENOM = 512  # 1 gas per 512 quadwords
+    GSTORAGEREFUND = 15000
+    GSTORAGEKILL = 5000
+    GSTORAGEMOD = 5000
+    GSTORAGEADD = 20000
+    GEXPONENTBYTE = 10    # cost of EXP exponent per byte
+    GCOPY = 3             # cost to copy one 32 byte word
+    GCONTRACTBYTE = 200   # one byte of code in contract creation
+    GCALLVALUETRANSFER = 9000   # non-zero-valued call
+    GLOGBYTE = 8          # cost of a byte of logdata
+
+    GTXCOST = 21000       # TX BASE GAS COST
+    GTXDATAZERO = 4       # TX DATA ZERO BYTE GAS COST
+    GTXDATANONZERO = 68   # TX DATA NON ZERO BYTE GAS COST
+    GSHA3WORD = 6         # Cost of SHA3 per word
+    GSHA256BASE = 60      # Base c of SHA256
+    GSHA256WORD = 12      # Cost of SHA256 per word
+    GRIPEMD160BASE = 600  # Base cost of RIPEMD160
+    GRIPEMD160WORD = 120  # Cost of RIPEMD160 per word
+    GIDENTITYBASE = 15    # Base cost of indentity
+    GIDENTITYWORD = 3     # Cost of identity per word
+    GECRECOVER = 3000     # Cost of ecrecover op
+
+    GSTIPEND = 2300
+
+    GCALLNEWACCOUNT = 25000
+    GSUICIDEREFUND = 24000
+
+  end
+end

data/lib/ethereum/private_key.rb

@@ -0,0 +1,92 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class PrivateKey
+
+    attr :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def encode(fmt, vbyte=0)
+      return self.class.new(value).encode(fmt, vbyte) unless raw.is_a?(Numeric)
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        BaseConvert.encode(raw, 256, 32)
+      when :bin_compressed
+        "#{BaseConvert.encode(raw, 256, 32)}\x01"
+      when :hex
+        BaseConvert.encode(raw, 16, 64)
+      when :hex_compressed
+        "#{BaseConvert.encode(raw, 16, 64)}01"
+      when :wif
+        Utils.bytes_to_base58_check(encode(:bin), 128+vbyte)
+      when :wif_compressed
+        Utils.bytes_to_base58_check(encode(:bin_compressed), 128+vbyte)
+      else
+        raise ArgumentError, "invalid format: #{fmt}"
+      end
+    end
+
+    def decode(fmt=nil)
+      fmt ||= format
+
+      case fmt
+      when :decimal
+        raw
+      when :bin
+        BaseConvert.decode(raw, 256)
+      when :bin_compressed
+        BaseConvert.decode(raw[0,32], 256)
+      when :hex
+        BaseConvert.decode(raw, 16)
+      when :hex_compressed
+        BaseConvert.decode(raw[0,64], 16)
+      when :wif
+        BaseConvert.decode Utils.base58_check_to_bytes(raw), 256
+      when :wif_compressed
+        BaseConvert.decode Utils.base58_check_to_bytes(raw)[0,32], 256
+      else
+        raise ArgumentError, "WIF does not represent privkey"
+      end
+    end
+
+    def value
+      @value ||= decode
+    end
+
+    def format
+      return :decimal if raw.is_a?(Numeric)
+      return :bin if raw.size == 32
+      return :bin_compressed if raw.size == 33
+      return :hex if raw.size == 64
+      return :hex_compressed if raw.size == 66
+
+      bytes = Utils.base58_check_to_bytes raw
+      return :wif if bytes.size == 32
+      return :wif_compressed if bytes.size == 33
+
+      raise FormatError, "WIF does not represent privkey"
+    end
+
+    def to_pubkey
+      raise ValidationError, "Invalid private key" if value >= Secp256k1::N
+
+      fmt = format.to_s.sub(/wif/, 'hex').to_sym
+      PublicKey.new(Secp256k1.priv_to_pub(encode(:bin))).encode(fmt)
+    end
+
+    def to_bitcoin_address
+      PublicKey.new(to_pubkey).to_bitcoin_address
+    end
+
+    def to_address(extended=false)
+      PublicKey.new(to_pubkey).to_address(extended)
+    end
+
+  end
+end