ethlite 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6a9601ad8c91c592541ffc721dbe9bbb8572683ef88c995a1bb810f7da79e33
-  data.tar.gz: 4ddf8c5a91c9a370e580bc9519f4d7c9832f863f31e4dfb8fa2b0505c2c6d6e0
+  metadata.gz: f4c28e1b125fefa2964c88a020a14de2d0e95c412e16f50ba5a329382465ccf8
+  data.tar.gz: 324e941a6825091bbf88539eb31acd03b80e8732c61442580a092bbdefe4e845
 SHA512:
-  metadata.gz: 12d4cd45f40f8ecf3835f058e2ac5d4e9a9b361e3cd91fd5bca193e982c7fd726ff3ffab08ed7bedb543c3800e76808364c51f2992d4971816629ac170f700f6
-  data.tar.gz: 236164ce176d5b50187e7402729a895130354f929df269e3b9d7b04472300b1661b9992a5579ba53064cbe0b7aee95e21aeeaae65225519ca55707caad771533
+  metadata.gz: df7dae52f733638a324dceb46371e1ecf6043f75515dc75ced197dfe1e24194b91e75f693f441861a122294e5d2408338584ee2b41a94ff64a277c0739fc9f8f
+  data.tar.gz: 171eea690f22474462316642eea60971eed702b6604681c3126b5900a134c196eb7cd07111d304086410e3ff46ccf7d73c61b2570c3430e563502ee6bf7e55ba

data/Manifest.txt

@@ -5,10 +5,10 @@ Rakefile
 lib/digest/keccak.rb
 lib/digest/sha3.rb
 lib/ethlite.rb
-lib/ethlite/abi/abi_coder.rb
+lib/ethlite/abi/codec.rb
 lib/ethlite/abi/type.rb
-lib/ethlite/abi/utils.rb
 lib/ethlite/constant.rb
 lib/ethlite/contract.rb
+lib/ethlite/utils.rb
 lib/ethlite/version.rb
 lib/jsonrpc/jsonrpc.rb

data/README.md

@@ -11,10 +11,179 @@ 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( ETH_NODE, 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( rpc,
+              contract_address,
+              name, inputs, outputs,
+              args )
+
+  ## binary encode method sig(nature)
+  signature      = "#{name}(#{inputs.join(',')})"
+  signature_hash =  Ethlite::Utils.encode_hex(
+                        Ethlite::Utils.keccak256(signature))[0..7]
+
+  pp signature
+  # => "tokenURI(uint256)"
+  pp signature_hash
+  # => "c87b56dd"
+
+  ## binary encode method arg(ument)s
+  args_encoded = Ethlite::Utils.encode_hex(
+                   Ethlite::Abi.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 = rpc.request( method, params )
+
+  puts "response:"
+  pp response
+
+  ## decode binary result
+  string_data = Ethlite::Utils.decode_hex(
+                     Ethlite::Utils.remove_0x_head(response))
+  result = Ethlite::Abi.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/lib/ethlite/abi/{abi_coder.rb → codec.rb}

@@ -2,19 +2,16 @@
 
 module Ethlite
   module Abi
+    extend self
 
   ##
   # Contract ABI encoding and decoding.
   #
   # @see https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
   #
-  module AbiCoder
-
+  module Codec
     extend self
 
-    include Constant
-
-
     class EncodingError < StandardError; end
     class DecodingError < StandardError; end
     class ValueError < StandardError; end
@@ -43,7 +40,6 @@ module Ethlite
 
       "#{head}#{tail}"
     end
-    alias :encode :encode_abi
 
     ##
     # Encodes a single value (static or dynamic).
@@ -263,7 +259,7 @@ module Ethlite
 
       parsed_types.zip(outputs).map {|(type, out)| decode_type(type, out) }
     end
-    alias :decode :decode_abi
+
 
     def zero_padding data, pos, count, start_positions
       if pos >= data.size
@@ -416,8 +412,21 @@ module Ethlite
         raise EncodingError, "Cannot decode int: #{n}"
       end
     end
+end # module Codec
+
+
+
+
+
+
+def encode_abi(types, args)
+    Codec.encode_abi( types, args )
+end
+
+def decode_abi(types, data, raise_errors = false)
+    Codec.decode_abi( types, data, raise_errors )
+end
 
-  end
 
 end  # module Abi
 end  # module Ethlite

data/lib/ethlite/constant.rb

@@ -1,6 +1,5 @@
 
 module Ethlite
-  module Constant
 
 
     ## todo/check   - use encoding -ascii-8bit for source file or ? - why? why not?
@@ -33,6 +32,4 @@ module Ethlite
 
     CONTRACT_CODE_SIZE_LIMIT = 0x6000
 
-
-  end  # module Constant
 end  # module Ethlite

data/lib/ethlite/contract.rb

@@ -9,12 +9,10 @@
          constant       = !!abi['constant'] || abi['stateMutability']=='view'
          input_types    = abi['inputs']  ? abi['inputs'].map{|a| _parse_component_type( a ) } : []
          output_types   = abi['outputs'] ? abi['outputs'].map{|a| _parse_component_type( a ) } : []
-         type           = abi['type'] || 'function'
 
          new( name, inputs: input_types,
                     outputs: output_types,
-                    constant: constant,
-                    type: type )
+                    constant: constant )
        end
 
        def self._parse_component_type( argument )
@@ -38,20 +36,19 @@
 
         def initialize( name, inputs:,
                               outputs:  [],
-                              constant: true,
-                              type:     'function' )
+                              constant: true )
           @name         = name
           @constant     = constant
           @input_types  = inputs
           @output_types = outputs
-
-          @signature      = Abi::Utils.function_signature( @name, @input_types )
-          @signature_hash = Abi::Utils.signature_hash( @signature, type=='event' ? 64 : 8)
+          @signature      = "#{@name}(#{@input_types.join(',')})"
+          @signature_hash = Utils.signature_hash( @signature, 8 )
         end
 
+
         def do_call( rpc, contract_address, args )
-          data = '0x' + @signature_hash + Abi::Utils.encode_hex(
-                                           Abi::AbiCoder.encode_abi(@input_types, args) )
+          data = '0x' + @signature_hash + Utils.encode_hex(
+                                           Abi.encode_abi(@input_types, args) )
 
           method = 'eth_call'
           params = [{ to:   contract_address,
@@ -63,10 +60,11 @@
           puts "response:"
           pp response
 
-          string_data = [Abi::Utils.remove_0x_head(response)].pack('H*')
+          string_data = Utils.decode_hex(
+                           Utils.remove_0x_head(response))
           return nil if string_data.empty?
 
-          result = Abi::AbiCoder.decode_abi( @output_types, string_data )
+          result = Abi.decode_abi( @output_types, string_data )
           puts
           puts "result decode_abi:"
           pp result

data/lib/ethlite/{abi/utils.rb → utils.rb}

@@ -1,11 +1,8 @@
 module Ethlite
-module Abi
-  module Utils
+module Utils
 
     extend self
 
-    include Constant
-
     ##
     # Not the keccak in sha3, although it's underlying lib named SHA3
     #
@@ -70,7 +67,7 @@ module Abi
     end
 
     def decode_hex(str)
-      raise TypeError, "Value must be an instance of string" unless sstr.instance_of?(String)
+      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
@@ -215,15 +212,11 @@ module Abi
     end
 
 
-    def function_signature method_name, arg_types
-      "#{method_name}(#{arg_types.join(',')})"
-    end
 
-    def signature_hash signature, length=64
-      encode_hex(keccak256(signature))[0...length]
+    def signature_hash( signature, length=8 )
+      encode_hex( keccak256(signature) )[0...length]
     end
-  end
 
-end  # module Abi
+end  # module Utils
 end  # module Ethlite
 

data/lib/ethlite/version.rb

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

data/lib/ethlite.rb

@@ -24,11 +24,11 @@ require_relative 'jsonrpc/jsonrpc'
 require_relative 'ethlite/version'    # note: let version always go first
 
 require_relative 'ethlite/constant'
+require_relative 'ethlite/utils'
 
 
 require_relative 'ethlite/abi/type'
-require_relative 'ethlite/abi/utils'
-require_relative 'ethlite/abi/abi_coder'
+require_relative 'ethlite/abi/codec'
 
 
 require_relative 'ethlite/contract'

data/lib/jsonrpc/jsonrpc.rb

@@ -23,7 +23,7 @@ class JsonRpc
 
           @request_id += 1
 
-          puts "json POST payload:"
+          puts "json_rpc POST payload:"
           puts data.to_json
 
           response = Webclient.post( @uri, json: data )
@@ -33,6 +33,9 @@ class JsonRpc
             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 )
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-19 00:00:00.000000000 Z
+date: 2022-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -89,11 +89,11 @@ files:
 - lib/digest/keccak.rb
 - lib/digest/sha3.rb
 - lib/ethlite.rb
-- lib/ethlite/abi/abi_coder.rb
+- lib/ethlite/abi/codec.rb
 - lib/ethlite/abi/type.rb
-- lib/ethlite/abi/utils.rb
 - lib/ethlite/constant.rb
 - lib/ethlite/contract.rb
+- lib/ethlite/utils.rb
 - lib/ethlite/version.rb
 - lib/jsonrpc/jsonrpc.rb
 homepage: https://github.com/pixelartexchange/artbase