ethlite 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6a9601ad8c91c592541ffc721dbe9bbb8572683ef88c995a1bb810f7da79e33
-  data.tar.gz: 4ddf8c5a91c9a370e580bc9519f4d7c9832f863f31e4dfb8fa2b0505c2c6d6e0
+  metadata.gz: 3cd659223f8049ca63302c5bb595da6faf483d29d776ed747b5970dde11b415e
+  data.tar.gz: fde6fca03683dac98d474d82bc520a82dc45e74b08eaabbc0c521e2635ca3d3b
 SHA512:
-  metadata.gz: 12d4cd45f40f8ecf3835f058e2ac5d4e9a9b361e3cd91fd5bca193e982c7fd726ff3ffab08ed7bedb543c3800e76808364c51f2992d4971816629ac170f700f6
-  data.tar.gz: 236164ce176d5b50187e7402729a895130354f929df269e3b9d7b04472300b1661b9992a5579ba53064cbe0b7aee95e21aeeaae65225519ca55707caad771533
+  metadata.gz: 050226ff51c20a38cb8f1db254e246a555d07baf8a6e12766985850400749a463698e89818780cd031e5ed3cab6bb05e2afae37588149084160138d5e6783e0f
+  data.tar.gz: 0d16770efc489cf88f08ec8ef471563905b2197c1d8330c58558348f1a9076dd717f654b5c221ea78052d31855bb458105c79f2f7ec1021a04451a202088b722

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/lib/ethlite/abi/utils.rb

@@ -70,7 +70,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

data/lib/ethlite/contract.rb

@@ -63,7 +63,8 @@
           puts "response:"
           pp response
 
-          string_data = [Abi::Utils.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 = 4
+  PATCH = 5
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

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.2.5
 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