web3-hpb 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b7e982320fc9431c55b9ed18807faf4feb1e959e70abf311a562e64aee2a5312
+  data.tar.gz: 38e2cd202a29c2e776b9d531a490a23107714e484601a428464e2e3e55bfbaae
+SHA512:
+  metadata.gz: b05becc6a38e14f9a67da0e4810ca4b3fc09431b0dd07f82cd236bb0fac45eeaccc3aca5c8e706f7d4192aedadc5264872bc18d6029c3cbff9cd9c98f4ceb4aa
+  data.tar.gz: d034534dfc9031cb5cb4d6887a6c843cd7e93feabf482728dfc7b4071c1f0e9fda966be8dd69c24361a57bf768465fba639c1a11e7e469a516fe08ab13f2bdb2

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.4

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at sean.shen@hpb.io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    web3-hpb (0.0.2)
+      digest-sha3 (~> 1.1.0)
+      rlp (~> 0.7.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    digest-sha3 (1.1.0)
+    minitest (5.11.3)
+    rake (10.4.2)
+    rlp (0.7.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.14)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  web3-hpb!
+
+BUNDLED WITH
+   1.16.4

data/README.md

@@ -0,0 +1,87 @@
+# Web3::Hpb
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/web3/hpb`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'web3-hpb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install web3-hpb
+
+## Usage
+
+### 连接
+初始化一个web3对象
+```ruby
+web3 = Web3::Hpb::Rpc.new
+```
+默认配置为
+```ruby
+web3 = Web3::Hpb::Rpc.new host: 'node.host.com',
+                          port: 8545,
+                          connect_options: { use_ssl: true, read_timeout: 120 }
+```
+
+### 使用hpb接口
+
+```
+>> web3.hpb.blockNumber
+4376369
+
+>> web3.hpb.getBalance '0x4c8a1996754c11ac255c747fdb36a4288d230541'
+3916.6597314456685
+
+>> block = web3.hpb.getBlockByNumber 4376369
+#<Web3::Hpb::Block:0x007f844d6f1138 @block_data={"author"=>"0x4c8a1996754c11ac255c797fdb36f4288d230541", ...
+
+>> block.timestamp_time
+2017-10-17 12:51:36 +0300
+
+>> block.transactions.count
+129
+
+>> block.transactions[0].from
+"0x4c8a199481ac255c747fdb36f4288d230541"
+
+>> block.transactions[0].value_eth
+0.51896811
+
+```
+
+### 使用abi接口
+```
+# creation of contract object
+myContract = web3.hpb.contract(abi);
+
+# initiate contract for an address
+myContractInstance = myContract.at('0x57d180cbaffbc97237f572148fc1b283b68d8861');
+
+# call constant function
+result = myContractInstance.balanceOf('0x...'); # any constant method works
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/web3-hpb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the Web3::Hpb project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/web3-hpb/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "web3/hpb"
+
+# 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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

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/lib/web3/hpb.rb

@@ -0,0 +1,12 @@
+require "web3/hpb/version"
+require "web3/hpb/abi/abi_coder"
+require "web3/hpb/utility"
+require "web3/hpb/block"
+require "web3/hpb/transaction"
+require "web3/hpb/contract"
+require "web3/hpb/call_trace"
+require "web3/hpb/log"
+require "web3/hpb/transaction_receipt"
+require "web3/hpb/hpb_module"
+require "web3/hpb/trace_module"
+require "web3/hpb/rpc"

data/lib/web3/hpb/abi/abi_coder.rb

@@ -0,0 +1,389 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'web3/hpb/abi/type'
+require 'web3/hpb/abi/constant'
+require 'web3/hpb/abi/exceptions'
+require 'web3/hpb/abi/utils'
+
+module Web3::Hpb::Abi
+  ##
+  # abi的解码和编码
+  # Contract ABI encoding and decoding.
+  #
+  module AbiCoder
+    extend self
+
+    include Constant
+    class EncodingError < StandardError; end
+    class DecodingError < StandardError; end
+    class ValueOutOfBounds < ValueError; end
+
+    ##
+    # 使用head/tail机制编码多个参数
+    # Encodes multiple arguments using the head/tail mechanism.
+    #
+    def encode_abi(types, args)
+      parsed_types = types.map{ |t| Type.parse(t) }
+      head_size = (0...args.size)
+        .map{ |i| parsed_types[i].size || 32 }
+        .reduce(0, &:+)
+
+      head, tail = '', ''
+      args.each_with_index do |arg, i|
+        if parsed_types[i].dynamic?
+          head += encode_type(Type.size_type, head_size, tail.size)
+          tail += encode_type(parsed_types[i], arg)
+        else
+          head += encode_type(parsed_types[i], arg)
+        end
+      end
+
+      "#{head}#{tail}"
+    end
+
+    alias :encode :encode_abi
+
+    ##
+    # Encodes a single value (static or dynamic).
+    #
+    # @param type [HPB::ABI::Type] value type
+    # @param arg [Object] value
+    #
+    # @return [String] encoded bytes
+    #
+
+    def encode_type(type, arg)
+
+      if %w(string bytes).include?(type.base) && type.sub.empty?
+        encode_primitive_type(type, arg)
+      elsif type.dynamic?
+
+        raise ArgumentRrror, "arg must be an array" unless arg.instance_of?(Array)
+
+        head, tail = '', ''
+        if type.dims.last == 0
+          head += encode_type(Type.size_type, arg.size)
+        else
+          raise ArgumentError, "Wrong array size: found #{arg.size}, expecting #{type.dims.last}" unless arg.size == type.dims.last
+        end
+
+        sub_type = type.subtype
+        sub_size = type.subtype.size
+
+        arg.size.times do |i|
+          if sub_size.nil?
+            head += encode_type(Type.size_type, 32*arg.size + tail.size)
+            tail += encode_type(sub_type, arg[i])
+          else
+            head += encode_type(sub_type, arg[i])
+          end
+        end
+
+        "#{head}#{tail}"
+      else # static type
+        if type.dims.empty?
+          encode_primitive_type(type, arg)
+        else
+          arg.map { |x| encode_type(type.subtype, x) }.join
+        end
+      end
+    end
+
+    def encode_primitive_type(type, arg)
+      case type.base
+      when 'uint'
+        begin
+          real_size = type.sub.to_i
+          i = get_uint(arg)
+
+          raise ValueOutOfBounds, arg unless i >= 0 && i < 2**real_size
+          Utils.zpad_int(i)
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
+      when 'bool'
+        raise ArgumentError, "arg is not bool: #{arg}" unless arg.instance_of?(TrueClass) || arg.instance_of?(FalseClass)
+        Utils.zpad_int(arg ? 1 : 0)
+      when 'int'
+        begin
+          real_size = type.sub.to_i
+          i = get_int(arg)
+
+          raise ValueOutOfBounds, arg unless i >= -2**(real_size-1) && i < 2**(real_size-1)
+          Utils.zpad_int(i % 2**type.sub.to_i)
+        rescue EncodingError
+          raise ValueOutOfBounds, arg
+        end
+      when 'ufixed'
+        high, low = type.sub.split('x').map(&:to_i)
+
+        raise ValueOutOfBounds, arg unless arg >= 0 && arg < 2**high
+        Utils.zpad_int((arg * 2**low).to_i)
+      when 'fixed'
+        high, low = type.sub.split('x').map(&:to_i)
+
+        raise ValueOutOfBounds, arg unless arg >= -2**(high - 1) && arg < 2**(high - 1)
+
+        i = (arg * 2**low).to_i
+        Utils.zpad_int(i % 2**(high+low))
+      when 'string'
+        if arg.encoding.name == 'UTF-8'
+          arg = arg.b
+        else
+          begin
+            arg.unpack('U*')
+          rescue ArgumentError
+            raise ValueError, "string must be UTF-8 encoded"
+          end
+        end
+
+        if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
+          size = Utils.zpad_int(arg.size)
+          value = Utils.rpad(arg, BYTE_ZERO, Utils.ceil32(arg.size))
+          "#{size}#{value}"
+        else # fixed length type
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid string length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid string length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
+        end
+      when 'bytes'
+        raise EncodingError, "Expecting string: #{arg}" unless arg.instance_of?(String)
+        arg = arg.b
+
+        if type.sub.empty? # variable length type
+          raise ValueOutOfBounds, "Integer invalid or out of range: #{arg.size}" if arg.size >= TT256
+          size = Utils.zpad_int(arg.size)
+          value = Utils.rpad(arg, BYTE_ZERO, Utils.ceil32(arg.size))
+          "#{size}#{value}"
+        else # fixed length type
+          sub = type.sub.to_i
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if arg.size > sub
+          raise ValueOutOfBounds, "invalid bytes length #{sub}" if sub < 0 || sub > 32
+          Utils.rpad(arg, BYTE_ZERO, 32)
+        end
+      when 'hash'
+        size = type.sub.to_i
+        raise EncodingError, "too long: #{arg}" unless size > 0 && size <= 32
+
+        if arg.is_a?(Integer)
+          Utils.zpad_int(arg)
+        elsif arg.size == size
+          Utils.zpad(arg, 32)
+        elsif arg.size == size * 2
+          Utils.zpad_hex(arg)
+        else
+          raise EncodingError, "Could not parse hash: #{arg}"
+        end
+      when 'address'
+        if arg.is_a?(Integer)
+          Utils.zpad_int(arg)
+        elsif arg.size == 20
+          Utils.zpad(arg, 32)
+        elsif arg.size == 40
+          Utils.zpad_hex(arg)
+        elsif arg.size == 42 && arg[0,2] == '0x'
+          Utils.zpad_hex(arg[2..-1])
+        else
+          raise EncodingError, "Could not parse address: #{arg}"
+        end
+      else
+        raise EncodingError, "Unhandled type: #{type.base} #{type.sub}"
+      end
+    end
+
+    ##
+    # Decodes multiple arguments using the head/tail mechanism.
+    #
+    def decode_abi(types, data)
+      parsed_types = types.map {|t| Type.parse(t) }
+
+      outputs = [nil] * types.size
+      start_positions = [nil] * types.size + [data.size]
+
+      # TODO: refactor, a reverse iteration will be better
+      pos = 0
+      parsed_types.each_with_index do |t, i|
+        # If a type is static, grab the data directly, otherwise record its
+        # start position
+        if t.dynamic?
+          start_positions[i] = Utils.big_endian_to_int(data[pos, 32])
+
+          j = i - 1
+          while j >= 0 && start_positions[j].nil?
+            start_positions[j] = start_positions[i]
+            j -= 1
+          end
+
+          pos += 32
+        else
+          outputs[i] = data[pos, t.size]
+          pos += t.size
+        end
+      end
+
+      # We add a start position equal to the length of the entire data for
+      # convenience.
+      j = types.size - 1
+      while j >= 0 && start_positions[j].nil?
+        start_positions[j] = start_positions[types.size]
+        j -= 1
+      end
+
+      #raise DecodingError, "Not enough data for head" unless pos <= data.size
+
+      parsed_types.each_with_index do |t, i|
+        if t.dynamic?
+          offset, next_offset = start_positions[i, 2]
+          outputs[i] = data[offset...next_offset]
+        end
+      end
+
+      parsed_types.zip(outputs).map {|(type, out)| decode_type(type, out) }
+    end
+
+    alias :decode :decode_abi
+
+    def decode_typed_data type_name, data
+      decode_primitive_type Type.parse(type_name), data
+    end
+
+    def decode_type(type, arg)
+      if %w(string bytes).include?(type.base) && type.sub.empty?
+        l = Utils.big_endian_to_int arg[0,32]
+        data = arg[32..-1]
+        data[0, l]
+      elsif type.dynamic?
+        l = Utils.big_endian_to_int arg[0,32]
+        subtype = type.subtype
+
+        if subtype.dynamic?
+          raise DecodingError, "Not enough data for head" unless arg.size >= 32 + 32*l
+
+          start_positions = (1..l).map {|i| Utils.big_endian_to_int arg[32*i, 32] }
+          start_positions.push arg.size
+
+          outputs = (0...l).map {|i| arg[start_positions[i]...start_positions[i+1]] }
+
+          outputs.map {|out| decode_type(subtype, out) }
+        else
+          (0...l).map {|i| decode_type(subtype, arg[32 + subtype.size*i, subtype.size]) }
+        end
+      elsif !type.dims.empty? # static-sized arrays
+        l = type.dims.last
+        subtype = type.subtype
+
+        (0...l).map {|i| decode_type(subtype, arg[subtype.size*i, subtype.size]) }
+      else
+        decode_primitive_type type, arg
+      end
+    end
+
+    def decode_primitive_type(type, data)
+      case type.base
+      when 'address'
+        Utils.encode_hex data[12..-1]
+      when 'string', 'bytes'
+        if type.sub.empty? # dynamic
+          if data.length==32
+            data[0..32]
+          else
+            size = Utils.big_endian_to_int data[0,32]
+            data[32..-1][0,size]
+          end
+        else # fixed
+          data[0, type.sub.to_i]
+        end
+      when 'hash'
+        data[(32 - type.sub.to_i), type.sub.to_i]
+      when 'uint'
+        Utils.big_endian_to_int data
+      when 'int'
+        u = Utils.big_endian_to_int data
+        u >= 2**(type.sub.to_i-1) ? (u - 2**type.sub.to_i) : u
+      when 'ufixed'
+        high, low = type.sub.split('x').map(&:to_i)
+        Utils.big_endian_to_int(data) * 1.0 / 2**low
+      when 'fixed'
+        high, low = type.sub.split('x').map(&:to_i)
+        u = Utils.big_endian_to_int data
+        i = u >= 2**(high+low-1) ? (u - 2**(high+low)) : u
+        i * 1.0 / 2**low
+      when 'bool'
+        data[-1] == BYTE_ONE
+      else
+        raise DecodingError, "Unknown primitive type: #{type.base}"
+      end
+    end
+
+    private
+
+    def get_uint(n)
+      case n
+      when Integer
+        raise EncodingError, "Number out of range: #{n}" if n > UINT_MAX || n < UINT_MIN
+        n
+      when String
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        raise EncodingError, "Number out of range: #{i}" if i > UINT_MAX || i < UINT_MIN
+        i
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode uint: #{n}"
+      end
+    end
+
+    def get_int(n)
+      case n
+      when Integer
+        raise EncodingError, "Number out of range: #{n}" if n > INT_MAX || n < INT_MIN
+        n
+      when String
+        i = if n.size == 40
+              Utils.decode_hex(n)
+            elsif n.size <= 32
+              n
+            else
+              raise EncodingError, "String too long: #{n}"
+            end
+        i = Utils.big_endian_to_int i
+
+        i = i > INT_MAX ? (i-TT256) : i
+        raise EncodingError, "Number out of range: #{i}" if i > INT_MAX || i < INT_MIN
+        i
+      when true
+        1
+      when false, nil
+        0
+      else
+        raise EncodingError, "Cannot decode int: #{n}"
+      end
+    end
+
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+