ethlite 0.2.3 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed8e8c05d930dceca2c2bf5f4b2e21ebeaaef68309b0c16474b47df667da2a89
-  data.tar.gz: 203ef7c86aa93e602028b1e0450e70c1c2c3a1388273263ce1e90fc503a18b08
+  metadata.gz: 3cd659223f8049ca63302c5bb595da6faf483d29d776ed747b5970dde11b415e
+  data.tar.gz: fde6fca03683dac98d474d82bc520a82dc45e74b08eaabbc0c521e2635ca3d3b
 SHA512:
-  metadata.gz: 1527a1fccb6908164d7744e0b06772c48a18f2f67bc60068f72c7577f512d2de295e9dfe8d917c5ca3c724963396cfb02ddff0aac6611be65d79575aaa90c34f
-  data.tar.gz: 92f93f217349b9ef33b1fc1ec7c0da36e50d172e2b44e06b9b8281d008fc770b4da081ad64f46e2be1819bbb7fa423dbe14a6519da4ddae6f782d9ea9f056108
+  metadata.gz: 050226ff51c20a38cb8f1db254e246a555d07baf8a6e12766985850400749a463698e89818780cd031e5ed3cab6bb05e2afae37588149084160138d5e6783e0f
+  data.tar.gz: 0d16770efc489cf88f08ec8ef471563905b2197c1d8330c58558348f1a9076dd717f654b5c221ea78052d31855bb458105c79f2f7ec1021a04451a202088b722

data/Manifest.txt

@@ -10,6 +10,5 @@ lib/ethlite/abi/type.rb
 lib/ethlite/abi/utils.rb
 lib/ethlite/constant.rb
 lib/ethlite/contract.rb
-lib/ethlite/utility.rb
 lib/ethlite/version.rb
 lib/jsonrpc/jsonrpc.rb

data/README.md

@@ -11,10 +11,178 @@ ethlite -  light-weight machinery to query / call ethereum (blockchain contract)
 
 
 
-
 ## Usage
 
-to be done
+
+### Step 0:  Setup JSON RPC Client
+
+```ruby
+## let's use a simple JSON RPC client
+##    get the eth node uri via the INFURA_URI enviroment variable / key
+##      e.g.  https://mainnet.infura.io/v3/<YOUR_KEY_HERE>
+ETH_NODE  = JsonRpc.new( ENV['INFURA_URI'] )
+```
+
+
+
+###  Do-It-Yourself (DIY) JSON RPC eth_call  With "Hand-Coded" To-The-Metal ABI Encoding/Decoding
+
+
+Let's try to build a JSON-RPC request from scratch calling
+a (constant/read-only/view) blockchain contract method via `eth_call`.
+
+Let's try `function tokenURI(uint256 tokenId) returns (string)`
+that lets you request the metdata uri for a (non-fungible) token.
+
+Let's try the Moonbirds contract @  [0x23581767a106ae21c074b2276d25e5c3e136a68b](https://etherscan.io/address/0x23581767a106ae21c074b2276d25e5c3e136a68b):
+
+```ruby
+## contract address - let's try moonbirds
+contract_address = '0x23581767a106ae21c074b2276d25e5c3e136a68b'
+
+token_ids = (0..9)
+token_ids.each do |token_id|
+
+  puts "==> calling tokenURI(#{token_id})..."
+  tokenURI = eth_call( contract_address,
+                         'tokenURI', ['uint256'], ['string'],
+                         [token_id] )
+  puts "   ...returns: #{tokenURI}"
+end
+```
+
+
+And the "magic"  hand-coded to-the-metal `eth_call` machinery:
+
+```ruby
+## construct a json-rpc call from scratch
+def eth_call( contract_address,
+              name, inputs, outputs,
+              args )
+
+  ## binary encode method sig(nature)
+  signature      = "#{name}(#{inputs.join(',')})"
+  signature_hash =  Ethlite::Abi::Utils.encode_hex(
+                        Ethlite::Abi::Utils.keccak256(signature))[0..7]
+
+  pp signature
+  # => "tokenURI(uint256)"
+  pp signature_hash
+  # => "c87b56dd"
+
+  ## binary encode method arg(ument)s
+  args_encoded = Ethlite::Abi::Utils.encode_hex(
+                   Ethlite::Abi::AbiCoder.encode_abi( inputs, args) )
+
+  data = '0x' + signature_hash + args_encoded
+
+  ## json-rpc  method and params
+  method =  'eth_call'
+  params =  [{ to:   contract_address,
+              data: data},
+            'latest'
+            ]
+
+  ## do the json-rpc request
+  response = ETH_NODE.request( method, params )
+
+  puts "response:"
+  pp response
+
+  ## decode binary result
+  string_data = Ethlite::Abi::Utils.decode_hex(
+                     Ethlite::Abi::Utils.remove_0x_head(response))
+  result = Ethlite::Abi::AbiCoder.decode_abi( outputs, string_data )
+  result.length  == 1 ? result[0] : result
+end
+```
+
+resulting in (with debug json rpc request/reponse output):
+
+
+calling `tokenURI(0)`...  json_rpc POST payload request:
+
+``` json
+{"jsonrpc":"2.0",
+ "method":"eth_call",
+ "params":[
+    {"to":"0x23581767a106ae21c074b2276d25e5c3e136a68b",
+     "data":"0xc87b56dd0000000000000000000000000000000000000000000000000000000000000000"},
+    "latest"],
+  "id":1
+}
+```
+
+json_rpc response:
+
+``` json
+{"jsonrpc":"2.0",
+ "id":1,"result":"0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003a68747470733a2f2f6c6976652d2d2d6d657461646174612d35636f767071696a61612d75632e612e72756e2e6170702f6d657461646174612f30000000000000"
+}
+```
+
+...returns: `https://live---metadata-5covpqijaa-uc.a.run.app/metadata/0`
+
+
+calling `tokenURI(1)...`  json_rpc POST payload request:
+
+``` json
+{"jsonrpc":"2.0",
+ "method":"eth_call",
+ "params":[
+  {"to":"0x23581767a106ae21c074b2276d25e5c3e136a68b",
+   "data":"0xc87b56dd0000000000000000000000000000000000000000000000000000000000000001"},
+   "latest"],
+  "id":2
+}
+```
+
+json_rpc response:
+
+``` json
+{"jsonrpc":"2.0",
+ "id":2,"result":"0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003a68747470733a2f2f6c6976652d2d2d6d657461646174612d35636f767071696a61612d75632e612e72756e2e6170702f6d657461646174612f31000000000000"
+}
+```
+
+...returns: `https://live---metadata-5covpqijaa-uc.a.run.app/metadata/1`
+
+
+
+### JSON RPC eth_call With ContractMethod Helper
+
+Let's retry using the convenience builtin
+`ContractMethod` helper:
+
+```ruby
+## contract address - let's try moonbirds
+contract_address = '0x23581767a106ae21c074b2276d25e5c3e136a68b'
+
+ETH_tokenURI = Ethlite::ContractMethod.new( 'tokenURI',
+                                             inputs: ['uint256'],
+                                             outputs: ['string'] )
+
+token_ids = (0..9)
+token_ids.each do |token_id|
+  puts "==> tokenURI(#{token_id}) returns:"
+  pp ETH_tokenURI.do_call( ETH_NODE, contract_address, [token_id] )
+end
+```
+
+resulting in:
+
+```
+==> tokenURI(0) returns:
+"https://live---metadata-5covpqijaa-uc.a.run.app/metadata/0"
+==> tokenURI(1) returns:
+"https://live---metadata-5covpqijaa-uc.a.run.app/metadata/1"
+==> tokenURI(2) returns:
+"https://live---metadata-5covpqijaa-uc.a.run.app/metadata/3"
+...
+```
+
+
+And so on and so forth.
 
 
 

data/Rakefile

@@ -21,7 +21,7 @@ Hoe.spec 'ethlite' do
   self.extra_deps = [
     ['cocos'],
     ## ['keccak'],  -- try using bundled ruby version for now
-    ['rlp'],
+    ['rlp-lite'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/ethlite/abi/utils.rb

@@ -56,44 +56,50 @@ module Abi
     end
 
     def to_signed(i)
-      i > Constant::INT_MAX ? (i-Constant::TT256) : i
+      i > INT_MAX ? (i-TT256) : i
     end
 
-    def base58_check_to_bytes(s)
-      leadingzbytes = s.match(/\A1*/)[0]
-      data = Constant::BYTE_ZERO * leadingzbytes.size + BaseConvert.convert(s, 58, 256)
-
-      raise ChecksumError, "double sha256 checksum doesn't match" unless double_sha256(data[0...-4])[0,4] == data[-4..-1]
-      data[1...-4]
-    end
-
-    def bytes_to_base58_check(bytes, magicbyte=0)
-      bs = "#{magicbyte.chr}#{bytes}"
-      leadingzbytes = bs.match(/\A#{Constant::BYTE_ZERO}*/)[0]
-      checksum = double_sha256(bs)[0,4]
-      '1'*leadingzbytes.size + BaseConvert.convert("#{bs}#{checksum}", 256, 58)
-    end
 
     def ceil32(x)
       x % 32 == 0 ? x : (x + 32 - x%32)
     end
 
     def encode_hex(b)
-      RLP::Utils.encode_hex b
+      raise TypeError, "Value must be an instance of String" unless b.instance_of?(String)
+      b.unpack("H*").first
+    end
+
+    def decode_hex(str)
+      raise TypeError, "Value must be an instance of string" unless str.instance_of?(String)
+      raise TypeError, 'Non-hexadecimal digit found' unless str =~ /\A[0-9a-fA-F]*\z/
+      [str].pack("H*")
     end
 
-    def decode_hex(s)
-      RLP::Utils.decode_hex s
+
+
+
+    def int_to_big_endian(n)
+      RLP::Sedes.big_endian_int.serialize n
     end
 
     def big_endian_to_int(s)
       RLP::Sedes.big_endian_int.deserialize s.sub(/\A(\x00)+/, '')
     end
 
-    def int_to_big_endian(n)
-      RLP::Sedes.big_endian_int.serialize n
+
+    def encode_int(n)
+      raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
+      int_to_big_endian n
+    end
+
+    def decode_int(v)
+      raise ArgumentError, "No leading zero bytes allowed for integers" if v.size > 0 && (v[0] == BYTE_ZERO || v[0] == 0)
+      big_endian_to_int v
     end
 
+
+
+
     def lpad(x, symbol, l)
       return x if x.size >= l
       symbol * (l - x.size) + x
@@ -124,15 +130,6 @@ module Abi
       zpad_int x, 20
     end
 
-    def encode_int(n)
-      raise ArgumentError, "Integer invalid or out of range: #{n}" unless n.is_a?(Integer) && n >= 0 && n <= UINT_MAX
-      int_to_big_endian n
-    end
-
-    def decode_int(v)
-      raise ArgumentError, "No leading zero bytes allowed for integers" if v.size > 0 && (v[0] == Constant::BYTE_ZERO || v[0] == 0)
-      big_endian_to_int v
-    end
 
     def bytearray_to_int(arr)
       o = 0
@@ -148,6 +145,7 @@ module Abi
       bytes.unpack('C*')
     end
 
+
     def coerce_to_int(x)
       if x.is_a?(Numeric)
         x
@@ -178,19 +176,6 @@ module Abi
       end
     end
 
-    def normalize_address(x, allow_blank: false)
-      address = Address.new(x)
-      raise ValueError, "address is blank" if !allow_blank && address.blank?
-      address.to_bytes
-    end
-
-    def mk_contract_address(sender, nonce)
-      keccak256_rlp([normalize_address(sender), nonce])[12..-1]
-    end
-
-    def mk_metropolis_contract_address(sender, initcode)
-      keccak256(normalize_address(sender) + initcode)[12..-1]
-    end
 
 
     def parse_int_or_hex(s)
@@ -203,6 +188,24 @@ module Abi
       end
     end
 
+
+=begin
+  ## add? moved over from the old module Utility
+     def hex( num )
+        '0x' + num.to_s(16)
+      end
+
+      def from_hex( h )
+        h.nil? ? 0 : (h.kind_of?(String) ? h.to_i(16) : h)
+      end
+=end
+
+
+    def remove_0x_head( s )
+      return s if !s || s.length<2
+      s[0,2] == '0x' ? s[2..-1] : s
+    end
+
     def normalize_hex_without_prefix(s)
       if s[0,2] == '0x'
         (s.size % 2 == 1 ? '0' : '') + s[2..-1]
@@ -211,6 +214,7 @@ module Abi
       end
     end
 
+
     def function_signature method_name, arg_types
       "#{method_name}(#{arg_types.join(',')})"
     end

data/lib/ethlite/constant.rb

@@ -2,9 +2,15 @@
 module Ethlite
   module Constant
 
-    BYTE_EMPTY = "".freeze
-    BYTE_ZERO  = "\x00".freeze
-    BYTE_ONE   = "\x01".freeze
+
+    ## todo/check   - use encoding -ascii-8bit for source file or ? - why? why not?
+    ## use  #b/.b  to ensure binary encoding? - why? why not?
+
+    ## todo/check:  use auto-freeze string literals magic comment - why? why not?
+    BYTE_EMPTY = "".b.freeze
+    BYTE_ZERO  = "\x00".b.freeze
+    BYTE_ONE   = "\x01".b.freeze
+
 
     TT32   = 2**32
     TT40   = 2**40
@@ -17,35 +23,16 @@ module Ethlite
     INT_MAX  = 2**255 - 1
     INT_MIN  = -2**255
 
-    HASH_ZERO = ("\x00"*32).freeze
+    HASH_ZERO = ("\x00"*32).b.freeze
 
 
-    PUBKEY_ZERO = ("\x00"*32).freeze
-    PRIVKEY_ZERO = ("\x00"*32).freeze
+    PUBKEY_ZERO = ("\x00"*32).b.freeze
+    PRIVKEY_ZERO = ("\x00"*32).b.freeze
+
     PRIVKEY_ZERO_HEX = ('0'*64).freeze
 
     CONTRACT_CODE_SIZE_LIMIT = 0x6000
 
 
-=begin
-   # The RLP short length limit.
-    SHORT_LENGTH_LIMIT = 56.freeze
-
-    # The RLP long length limit.
-    LONG_LENGTH_LIMIT = (256 ** 8).freeze
-
-    # The RLP primitive type offset.
-    PRIMITIVE_PREFIX_OFFSET = 0x80.freeze
-
-    # The RLP array type offset.
-    LIST_PREFIX_OFFSET = 0xc0.freeze
-
-    # The binary encoding is ASCII (8-bit).
-    BINARY_ENCODING = "ASCII-8BIT".freeze
-
-    # Infinity as constant for convenience.
-    INFINITY = (1.0 / 0.0).freeze
-
-=end
   end  # module Constant
 end  # module Ethlite

data/lib/ethlite/contract.rb

@@ -1,7 +1,5 @@
   module Ethlite
       class ContractMethod
-        include Utility
-
 
        def self.parse_abi( abi )
          ## convenience helper -  auto-convert to json if string passed in
@@ -31,8 +29,7 @@
 
 
 
-        attr_reader :abi,
-                    :signature,
+        attr_reader :signature,
                     :name,
                     :signature_hash,
                     :input_types,
@@ -66,7 +63,8 @@
           puts "response:"
           pp response
 
-          string_data = [remove_0x_head(response)].pack('H*')
+          string_data = Abi::Utils.decode_hex(
+                           Abi::Utils.remove_0x_head(response))
           return nil if string_data.empty?
 
           result = Abi::AbiCoder.decode_abi( @output_types, string_data )

data/lib/ethlite/version.rb

@@ -3,7 +3,7 @@
 module Ethlite
   MAJOR = 0
   MINOR = 2
-  PATCH = 3
+  PATCH = 5
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/lib/ethlite.rb

@@ -10,7 +10,7 @@ require 'openssl'
 require 'digest'
 
 ## 3rd party gems
-require 'rlp'               ## gem rlp    - see https://rubygems.org/gems/rlp
+require 'rlp-lite'
 
 ##  bundled require 'digest/keccak'     ## gem keccak - see https://rubygems.org/gems/keccak
 require_relative 'digest/keccak'
@@ -31,7 +31,6 @@ require_relative 'ethlite/abi/utils'
 require_relative 'ethlite/abi/abi_coder'
 
 
-require_relative 'ethlite/utility'
 require_relative 'ethlite/contract'
 
 

data/lib/jsonrpc/jsonrpc.rb

@@ -9,49 +9,43 @@
 
 class JsonRpc
       def initialize( uri )
-        @client_id = Random.rand( 10000000 )
-
-        @uri = URI.parse( uri )
+        @uri        = uri    ## assume uri always as string for now
+        @request_id = 1
       end
 
 
       def request( method, params=[] )
-        opts = {}
-        if @uri.instance_of?( URI::HTTPS )
-          opts[:use_ssl]     = true
-          opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
-        end
-
-        Net::HTTP.start( @uri.host, @uri.port, **opts ) do |http|
-          headers = {"Content-Type" => "application/json"}
-          request = Net::HTTP::Post.new( @uri.request_uri, headers )
 
-          json = { jsonrpc: '2.0',
+          data = { jsonrpc: '2.0',
                    method:  method,
                    params:  params,
-                   id: @client_id }.to_json
+                   id: @request_id }
+
+          @request_id += 1
 
-          puts "json POST payload:"
-          puts json
+          puts "json_rpc POST payload:"
+          puts data.to_json
 
-          request.body = json
-          response = http.request( request )
+          response = Webclient.post( @uri, json: data )
 
-          unless response.kind_of?( Net::HTTPOK )
-            raise "Error code #{response.code} on request #{@uri.to_s} #{request.body}"
+
+          if response.status.nok?
+            raise "Error code #{response.status.code} on request #{@uri} #{data}"
           end
 
+          puts "json_rpc response.body:"
+          puts response.body
+
 
           body = JSON.parse( response.body, max_nesting: 1500 )
 
           if body['result']
             body['result']
           elsif body['error']
-            raise "Error #{@uri.to_s} #{body['error']} on request #{@uri.to_s} #{request.body}"
+            raise "Error #{@uri} #{body['error']} on request #{@uri} #{data}"
           else
-            raise "No response on request #{@uri.to_s} #{request.body}"
+            raise "No response on request #{@uri} #{data}"
           end
-        end
-      end
+      end  # method request
 end  # class JsonRpc
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.5
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-15 00:00:00.000000000 Z
+date: 2022-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rlp
+  name: rlp-lite
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +94,6 @@ files:
 - lib/ethlite/abi/utils.rb
 - lib/ethlite/constant.rb
 - lib/ethlite/contract.rb
-- lib/ethlite/utility.rb
 - lib/ethlite/version.rb
 - lib/jsonrpc/jsonrpc.rb
 homepage: https://github.com/pixelartexchange/artbase

data/lib/ethlite/utility.rb

@@ -1,23 +0,0 @@
-module Ethlite
-
-    module Utility
-
-      def hex( num )
-        '0x' + num.to_s(16)
-      end
-
-      def from_hex( h )
-        h.nil? ? 0 : (h.kind_of?(String) ? h.to_i(16) : h)
-      end
-
-      def remove_0x_head( s )
-        return s if !s || s.length<2
-        s[0,2] == '0x' ? s[2..-1] : s
-      end
-
-
-      def wei_to_ether( wei )
-        1.0 * wei / 10**18
-      end
-    end
-end    # module Ethlite