abiparser 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77899a7da00b8be7b61c97d2f1ebad297a6d33f74bd081c59b17f8b66bca78f1
-  data.tar.gz: 15a102dc8505eb359fcb5d117de026e9308641e714ea50096895ee15fb4d655e
+  metadata.gz: 43f7d1f45a66ea6fd2deb690979c26f4289a666692bcb84c81420dbab5c2ab8b
+  data.tar.gz: 487f1407542dc6d6f5e22b2975f4a7828fc0f08f5147961dc44230486bccbe71
 SHA512:
-  metadata.gz: 2bf5a3d5928df6f9d5a650f50ca05df22edb82f0d305a5ef66c552b36fee9b33d6166b63dfd4e878c8a32f7a86e042517159cc6b0155cf96734b36a0ab596817
-  data.tar.gz: 8181ddd11ad89481204f1796ef4eebc854d10ec83fb8cd6d3fd45ce8da830cff2fd1273c726c507853843442c174c603bd66fcb735ae4aabf433141827befebb
+  metadata.gz: 5fc14d110513a91161272beb5a9e8d41401fe8ba5407d52beb43b782ac2b173108aaea79738b4f75d00439bf17908257376100c1d4166dc34434f936019eddbf
+  data.tar.gz: ed21d7bcdbb58144832ba46c82d6fae1c1ec22f501936b34902e68c56ab44a556f219c35294cf09a836382252d77e67de231476b027724fcb60e681d3925d90f

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/lib/abiparser/constructor.rb

@@ -74,7 +74,7 @@ class Constructor
       buf << "(#{buf2.join(',')})"
     end
     buf
- end
+  end
 
 
   def doc
@@ -98,9 +98,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
@@ -92,11 +92,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 +139,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,19 +1,35 @@
 module ABI
 class Param
-
-    attr_reader :type, :name
+    attr_reader :type, :name, :internal_type
 
     def self.parse( o )
-      type = o['type']
-      name = o['name']
-      new( type, name )
+      type          = o['type']
+      internal_type = o['internalType']
+      name          = o['name']
+
+      new( type, name,
+             internal_type: internal_type )
     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 )  ## 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
     end
 
+
     def sig
       buf = "#{@type}"
       buf
@@ -21,16 +37,26 @@ class Param
 
     def doc
         buf = ''
-        buf << "#{@type} "
-        buf <<  (@name.empty? ?  '_' : @name)
+        if @internal_type && @internal_type != @type
+          buf << "#{@internal_type} "
+        else
+          buf << "#{@type} "
+        end
+        buf <<  (@name ?  @name : '_')
         buf
     end
 
     def decl
       buf = ''
       buf << "#{@type} "
-      buf <<  (@name.empty? ?  '_' : @name)
+      buf <<  (@name ? @name :  '_')
+      ## use inline comment - why? why not?
+      if @internal_type && @internal_type != @type
+         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,9 +1,8 @@
 
 module ABIParser
-
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

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
@@ -24,12 +42,78 @@ 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.rb'
 
 
 
+
+## 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)'
+)
+
+
+
+
+
 module ABI
   def self.read( path )  Contract.read( path ); end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abiparser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-26 00:00:00.000000000 Z
+date: 2022-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocos
@@ -105,7 +105,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: