abiparser 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77899a7da00b8be7b61c97d2f1ebad297a6d33f74bd081c59b17f8b66bca78f1
-  data.tar.gz: 15a102dc8505eb359fcb5d117de026e9308641e714ea50096895ee15fb4d655e
+  metadata.gz: 9f938a2858e7da14cc5a8b42f4691a93c4721cef9e271168de78535c64f70115
+  data.tar.gz: 8450885be9f443548be957d0815bb31e3c56862f0368eb17f574ab176ea9e4b0
 SHA512:
-  metadata.gz: 2bf5a3d5928df6f9d5a650f50ca05df22edb82f0d305a5ef66c552b36fee9b33d6166b63dfd4e878c8a32f7a86e042517159cc6b0155cf96734b36a0ab596817
-  data.tar.gz: 8181ddd11ad89481204f1796ef4eebc854d10ec83fb8cd6d3fd45ce8da830cff2fd1273c726c507853843442c174c603bd66fcb735ae4aabf433141827befebb
+  metadata.gz: bc52799f38979a1e8b77b21d711e0ff935510ce7988bdec34e5ad0a09a5dde8db522df3038808f165dcd4178051ef49f7f832d1b76fc9fac0ef5c4f3331fd92b
+  data.tar.gz: 6a6d1e03041d70e7080c38ad3e534c5e57a0cd49af187c4a16dfe1f19ae7fa55d4c8a3068b12968dd64a3d23f3c08c8f4c5fd47ac96e83f9bc7da695e0dfef7b

data/Manifest.txt

@@ -7,5 +7,7 @@ lib/abiparser/constructor.rb
 lib/abiparser/contract.rb
 lib/abiparser/export/interface.rb
 lib/abiparser/function.rb
+lib/abiparser/interface.rb
 lib/abiparser/param.rb
+lib/abiparser/utils.rb
 lib/abiparser/version.rb

data/README.md

@@ -13,6 +13,133 @@ abiparser - application binary interface (abi) parser machinery / helper for Eth
 ## Usage
 
 
+### Functions Signature Hashes / Selectors & Interface (Type) Ids
+
+
+You can calculate the function selectors (or "sighash",
+that is, signature hash)
+by hashing the function signature
+e.g. `supportsInterface(bytes4)` with the Keccak 256-Bit algorithm
+and than use the first 4 bytes, that is, `0x01ffc9a7` (out of 32 bytes),
+that is, `0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2`. Example:
+
+
+``` ruby
+require 'abiparser'
+
+sig = 'supportsInterface(bytes4)'
+pp keccak256( sig )[0,4].hexdigest
+#=> "0x01ffc9a7"
+```
+
+Note: The `String#hexdigest` (also known as `String#bin_to_hex`) helper
+converts a binary string (with `BINARY`/`ASCII-8BIT` encoding)
+into a hex(adecimal) string.
+
+
+You can calcuate interface (type) ids
+by xor-ing (`^`) together the sighashes.
+If the interface only has one function than
+the interface (type) id equals the function sighash (by definition).
+
+
+``` solidity
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+  function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+// The interface identifier for this interface is 0x01ffc9a7.
+```
+
+If you check the sighash for `supportsInterface(bytes4)`,
+that is, `0x01ffc9a7`  (see above)
+than -  bingo! - the  interface id for ERC165 matches up.
+
+
+Let's try to calculate the ERC20 standard (fungible) token interface
+where the official id is `0x36372b07` by xor-ing (`^`) together all function sighashes:
+
+``` ruby
+pp (keccak256('totalSupply()')[0,4] ^
+    keccak256('balanceOf(address)')[0,4] ^
+    keccak256('allowance(address,address)')[0,4] ^
+    keccak256('transfer(address,uint256)')[0,4] ^
+    keccak256('approve(address,uint256)')[0,4] ^
+    keccak256('transferFrom(address,address,uint256)')[0,4]).hexdigest
+#=> "0x36372b07"
+
+# or where   def sig(bin) = keccak256(bin)[0,4])
+
+pp (sig('totalSupply()') ^
+    sig('balanceOf(address)') ^
+    sig('allowance(address,address)') ^
+    sig('transfer(address,uint256)') ^
+    sig('approve(address,uint256)') ^
+    sig('transferFrom(address,address,uint256)')).hexdigest
+#=> "0x36372b07"
+```
+
+Voila!
+Or re(use) the builtin pre-defined interfaces. Example:
+
+``` ruby
+pp IERC165.inteface_id             #=> "0x01ffc9a7"
+pp IERC20.interface_id             #=> "0x36372b07"
+pp IERC721.interface_id            #=> "0x80ac58cd"
+pp IERC721_METADATA.interface_id   #=> "0x5b5e139f"
+pp IERC721_ENUMERABLE.interface_id #=> "0x780e9d63"
+```
+
+Yes, you can. Define your own interface. Let's have a looksie
+at the built-ins. Example:
+
+``` ruby
+IERC165 = ABI::Interface.new(
+  'supportsInterface(bytes4)'
+)
+
+IERC20  = ABI::Interface.new(
+   'totalSupply()',
+   'balanceOf(address)',
+   'allowance(address,address)',
+   'transfer(address,uint256)',
+   'approve(address,uint256)',
+   'transferFrom(address,address,uint256)'
+)
+
+IERC721 = ABI::Interface.new(
+  'balanceOf(address)',
+  'ownerOf(uint256)',
+  'approve(address,uint256)',
+  'getApproved(uint256)',
+  'setApprovalForAll(address,bool)',
+  'isApprovedForAll(address,address)',
+  'transferFrom(address,address,uint256)',
+  'safeTransferFrom(address,address,uint256)',
+  'safeTransferFrom(address,address,uint256,bytes)' )
+
+IERC721_METADATA = ABI::Interface.new(
+  'name()',
+  'symbol()',
+  'tokenURI(uint256)' )
+
+IERC721_ENUMERABLE = ABI::Interface.new(
+  'tokenOfOwnerByIndex(address,uint256)',
+  'totalSupply()',
+  'tokenByIndex(uint256)' )
+
+...
+```
+
+
+To be continued...
+
+
+
 
 
 ## License

data/Rakefile

@@ -22,6 +22,7 @@ Hoe.spec 'abiparser' do
     ['cocos'],
     ['bytes'],
     ['digest-lite'],
+    ['abicoder'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/abiparser/constructor.rb

@@ -47,14 +47,20 @@ class Constructor
   end
 
 
-  attr_reader :inputs
+  attr_reader :inputs, :input_types
 
   def initialize( inputs: [],
                   payable: false )
      @inputs  = inputs
      @payable = payable
+
+     ##  parse inputs into types
+     ##    note: use "calculated" sig(nature) and NOT the type
+     ##        (differs for tuples, that is, types with components !!!)
+     @input_types  = @inputs.map {|param| Type.parse( param.sig ) }
   end
 
+
   ##  add - why? why not?
   ## def constant?() false; end
   ## alias_method :readonly?, :constant?
@@ -74,7 +80,7 @@ class Constructor
       buf << "(#{buf2.join(',')})"
     end
     buf
- end
+  end
 
 
   def doc
@@ -98,9 +104,7 @@ class Constructor
     end
     buf << ";"
     buf
-end
-
-
+  end
 
 
 end  # class Constructor

data/lib/abiparser/contract.rb

@@ -63,8 +63,37 @@ class Contract
       @events = events
       @has_receive = has_receive
       @has_fallback = has_fallback
+
+      @selectors = {}
+
+      ## auto-add selectors (hashed signatures)
+      @funcs.each do |func|
+         sighash = func.sighash
+         puts "0x#{sighash} => #{func.sig}"
+
+         ## assert - no duplicates allowed
+         if @selectors[sighash]
+            puts "!! ERROR - duplicate function signature #{func.sig}; already in use; sorry"
+            exit 1
+         end
+
+         @selectors[sighash] = func
+      end
   end
 
+
+  ## return hexstrings of sig(natures) - why? why not?
+  ## rename to sighashes - why? why not?
+  def selectors()  @selectors.keys;  end
+
+
+ def support?( sig )
+   Utils.support?( @selectors.keys, sig )
+ end
+ alias_method :supports?, :support?   ## add alternate spelling - why? why not?
+
+
+
   def constructor() @ctor; end
   def functions() @funcs; end
 

data/lib/abiparser/export/interface.rb

@@ -6,11 +6,14 @@ class Contract
     buf = ''
     buf << "interface #{name} {"
 
-    if @ctor
-      buf << "\n"
-      buf << "// Constructor\n"
-      buf << "#{@ctor.decl}\n"
-    end
+
+#  include constructor - why? why not?
+#
+#   if @ctor
+#      buf << "\n"
+#      buf << "// Constructor\n"
+#      buf << "#{@ctor.decl}\n"
+#    end
 
     if payable_functions.size > 0
       buf << "\n"

data/lib/abiparser/function.rb

@@ -7,9 +7,9 @@ class Function
     inputs  = o['inputs'].map {|param| Param.parse( param ) }
     outputs = o['outputs'].map {|param| Param.parse( param ) }
 
-    payable = nil
-    contant = nil
-    pure    = nil
+    payable  = nil
+    constant = nil
+    pure     = nil
 
     ## old soliditity before v0.6
     ##  newer version uses stateMutability
@@ -54,10 +54,11 @@ class Function
 
 
   attr_reader :name,
-              :inputs, :outputs
+              :inputs, :outputs,
+              :input_types, :output_types
 
   def initialize( name,
-                  inputs: [],
+                  inputs:  [],
                   outputs: [],
                   payable: false,
                   constant: false,
@@ -65,10 +66,21 @@ class Function
      @name    = name
      @inputs  = inputs
      @outputs = outputs
-
      @payable = payable
      @constant = constant
      @pure = pure
+
+     ##  parse inputs & outputs into types
+     ##    note: use "calculated" sig(nature) and NOT the type
+     ##        (differs for tuples, that is, types with components !!!)
+     @input_types  = @inputs.map do |param|
+                                     Type.parse( param.sig )
+                                 end
+     @output_types = @outputs.map do |param|
+                                       ## pp param
+                                       ## puts "sig: #{param.sig}"
+                                      Type.parse( param.sig )
+                                  end
   end
 
 
@@ -92,11 +104,16 @@ class Function
       buf << "(#{buf2.join(',')})"
     end
     buf
- end
+  end
+
+  def sighash
+    keccak256( sig )[0,4].hexdigest
+  end
 
 
   def doc
-      buf = "function #{@name}"
+      ## note: text with markdown formatting
+      buf = "function **#{@name}**"
       if @inputs.empty?
         buf << "()"
       else
@@ -134,7 +151,7 @@ class Function
     end
     buf << ";"
     buf
-end
+  end
 
 
 def types

data/lib/abiparser/interface.rb

@@ -0,0 +1,59 @@
+
+module ABI
+
+
+  ## rename to QueryInterface or SupportInterface
+  ##   or InterfaceType or InterfaceId or such - why? why not?
+class Interface
+
+  attr_reader :interface_id
+
+
+  ##
+  ## todo/fix:  make sure full function defs get passed in (not only sigs!!!)
+  def initialize( *functions )
+    @functions = functions
+    @selectors = {}
+
+    @functions.each do |func|
+      sig = func
+      sighash =  keccak256( sig )[0,4].hexdigest
+      puts "0x#{sighash} => #{sig}"
+
+      ## assert - no duplicates allowed
+      if @selectors[sighash]
+        puts "!! ERROR - duplicate function signature #{sig}; already in use; sorry"
+        exit 1
+      end
+
+      @selectors[sighash] = sig
+    end
+    @interface_id = calc_interface_id
+  end
+
+
+  def calc_interface_id
+    interface_id = nil
+    @selectors.each do |sighash,_|
+      sighash = sighash.hex_to_bin   ## note: convert to binary string (from hexstring)!!
+      interface_id = if interface_id.nil?
+        sighash   ## init with sighash
+      else
+        interface_id ^ sighash   ## use xor
+      end
+    end
+    interface_id.hexdigest
+  end
+
+
+  ## return hexstrings of sig(natures) - why? why not?
+  ## rename to sighashes - why? why not?
+  def selectors()  @selectors.keys;  end
+
+  def support?( sig )
+     Utils.support?( @selectors.keys, sig )
+  end
+  alias_method :supports?, :support?   ## add alternate spelling - why? why not?
+
+end  ## class Interface
+end  # module ABI

data/lib/abiparser/param.rb

@@ -1,36 +1,78 @@
 module ABI
 class Param
-
-    attr_reader :type, :name
+    attr_reader :type, :name,
+                :internal_type,
+                :components
 
     def self.parse( o )
-      type = o['type']
-      name = o['name']
-      new( type, name )
+      type          = o['type']
+      internal_type = o['internalType']
+      name          = o['name']
+      components    = o['components'] ? o['components'].map { |c| parse( c ) } : nil
+
+      new( type, name,
+             internal_type: internal_type,
+             components: components )
     end
 
-    def initialize( type, name )  ## note: type goes first!!!
-      @type = type
-      @name = name
+    ### check - find a "better" name for internal_type
+    ##            use a keyword param - why? why not?
+    def initialize( type, name=nil,
+                     internal_type: nil,
+                     components: nil  )  ## note: type goes first!!!
+      @type          = type
+      ## note: convert empty string "" to nil - why? why not?
+      @name          = if name && name.empty?
+                             nil
+                       else
+                          name
+                       end
+      @internal_type = if internal_type && internal_type.empty?
+                              nil
+                       else
+                          internal_type
+                       end
+      @components  = components
     end
 
+
     def sig
-      buf = "#{@type}"
-      buf
+      @sig ||= begin
+                  if @components
+                     ## replace tuple with  (type,...)
+                     ##  e.g.  tuple[] becomes (type,...)[] etc.
+                     tuple = @components.map {|c| c.sig }.join(',')
+                     @type.sub( "tuple", "(#{tuple})" )
+                  else
+                    "#{@type}"
+                  end
+               end
+      @sig
     end
 
+
     def doc
         buf = ''
-        buf << "#{@type} "
-        buf <<  (@name.empty? ?  '_' : @name)
+        if @internal_type && @internal_type != sig
+          buf << "#{@internal_type} "
+        else
+          buf << "#{sig} "
+        end
+        buf <<  (@name ?  @name : '_')
         buf
     end
 
     def decl
       buf = ''
-      buf << "#{@type} "
-      buf <<  (@name.empty? ?  '_' : @name)
+      buf << "#{sig} "
+      buf <<  (@name ? @name :  '_')
+      ## use inline comment - why? why not?
+      if @internal_type && @internal_type != sig
+         buf << " /* #{@internal_type} */"
+      end
       buf
     end
+
+
 end  ## class Param
 end  ## module ABI

data/lib/abiparser/utils.rb

@@ -0,0 +1,40 @@
+module ABI
+module Helpers
+
+
+  SIGHASH_RX = /\A
+                (0x)?
+                (?<sighash>[0-9a-f]{8})
+                \z/ix
+
+  def support?( selectors, sig )
+    if sig.is_a?( Interface )
+      iface = sig
+      iface.selectors.each do |sighash|
+          unless selectors.include?( sighash )
+            puts "  sighash >#{sighash}< not found in interface"
+            return false
+          end
+      end
+      true
+    else
+      sighash =  if m=SIGHASH_RX.match( sig )
+                  m[:sighash].downcase  ## assume it's sighash (hexstring)
+                 else
+                  ## for convenience allow (white)spaces; auto-strip - why? why not?
+                  sig = sig.gsub( /[ \r\t\n]/, '' )
+                  keccak256( sig )[0,4].hexdigest
+                 end
+
+      selectors.include?( sighash ) ? true : false
+    end
+  end
+end  # module Helpers
+
+
+module Utils
+  extend Helpers
+  ## e.g. Utils.supports?( selectors, sig ) etc.
+end
+
+end  # module ABI

data/lib/abiparser/version.rb

@@ -1,8 +1,7 @@
 
 module ABIParser
-
   MAJOR = 0
-  MINOR = 0
+  MINOR = 1
   PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 

data/lib/abiparser.rb

@@ -6,9 +6,27 @@ require 'digest-lite'
 ## extend String
 class String
   alias_method :hexdigest, :bin_to_hex   ## note: bin_to_hex added via Bytes!!!
+
+    # given two numeric strings,
+    # returns the bitwise xor string
+    def xor(other)
+        a = self.bytes
+        b = other.bytes
+        ## todo/check: cut-off on lower count (lc) - why? why not?
+        lc = (a.size < b.size) ? a.size : b.size
+        c = []
+        lc.times do |i|
+           c << (a[i] ^ b[i])
+        end
+        c = c.pack( 'C*' )
+        puts "#{self.bin_to_hex} ^ #{other.bin_to_hex} = #{c.bin_to_hex}<"
+        c
+    end
+    alias_method :^, :xor
 end  # class String
 
 
+
 def keccak256( bin )
   Digest::KeccakLite.new( 256 ).digest( bin )
 end
@@ -18,15 +36,84 @@ def sig( bin )
 end
 
 
+require 'abicoder'
+
 
 ## our own code
 require_relative 'abiparser/version'    # note: let version always go first
+
 require_relative 'abiparser/param'
 require_relative 'abiparser/constructor'
 require_relative 'abiparser/function'
+require_relative 'abiparser/utils'
 require_relative 'abiparser/contract'
+require_relative 'abiparser/interface'
+
+require_relative 'abiparser/export/interface'
+
+
+
+
+## note: make "global" constants - why? why not?
+
+## IERC165  0x01ffc9a7
+IERC165 = ABI::Interface.new(
+  'supportsInterface(bytes4)',
+)
+
+## IERC20  0x36372b07
+IERC20  = ABI::Interface.new(
+   'totalSupply()',
+   'balanceOf(address)',
+   'allowance(address,address)',
+   'transfer(address,uint256)',
+   'approve(address,uint256)',
+   'transferFrom(address,address,uint256)'
+)
+
+## IERC20_NAME 0x06fdde03
+IERC20_NAME = ABI::Interface.new(
+  'name()'
+)
+
+## IERC20_SYMBOL 0x95d89b41
+IERC20_SYMBOL = ABI::Interface.new(
+  'symbol()'
+)
+
+## IERC20_DECIMALS 0x313ce567
+IERC20_DECIMALS = ABI::Interface.new(
+  'decimals()'
+)
+
+## IERC721  0x80ac58cd
+IERC721 = ABI::Interface.new(
+  'balanceOf(address)',
+  'ownerOf(uint256)',
+  'approve(address,uint256)',
+  'getApproved(uint256)',
+  'setApprovalForAll(address,bool)',
+  'isApprovedForAll(address,address)',
+  'transferFrom(address,address,uint256)',
+  'safeTransferFrom(address,address,uint256)',
+  'safeTransferFrom(address,address,uint256,bytes)'
+)
+
+## IERC721_METADATA  0x5b5e139f
+IERC721_METADATA   = ABI::Interface.new(
+  'name()',
+  'symbol()',
+  'tokenURI(uint256)'
+)
+
+## IERC721_ENUMERABLE  0x780e9d63
+IERC721_ENUMERABLE   = ABI::Interface.new(
+  'tokenOfOwnerByIndex(address,uint256)',
+  'totalSupply()',
+  'tokenByIndex(uint256)'
+)
+
 
-require_relative 'abiparser/export/interface.rb'
 
 
 
@@ -37,9 +124,6 @@ module ABI
 end  # module ABI
 
 
-## add convenience alternate spellings - why? why not?
-Abi = ABI
-
 
-puts AbiParser.banner
+puts ABIParser.banner
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abiparser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-26 00:00:00.000000000 Z
+date: 2023-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: abicoder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +119,9 @@ files:
 - lib/abiparser/contract.rb
 - lib/abiparser/export/interface.rb
 - lib/abiparser/function.rb
+- lib/abiparser/interface.rb
 - lib/abiparser/param.rb
+- lib/abiparser/utils.rb
 - lib/abiparser/version.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses: