abi2ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad8b991ef9ac6969aa4a618e3f978c8ff9d04572b8e35479614d995f15fe5392
+  data.tar.gz: ab052e6d53d8338ae96d5cb25bb61a8ce10fecf9f43e40955a6cdd0b0e1c1152
+SHA512:
+  metadata.gz: d03c419be9aaea423eff8686363bedbf70df1b526035c041bcdbbec53161166bd4d206c5f86c444cacd3f83b48ffd9334a09ec0ad3c8f65c53619997bbb20869
+  data.tar.gz: 363441a86ddcfcacf9954bd614108127b518da06b68b420190a3fb1360279875f0e67d0d65e3195ac66804515b9ce6d59d7fb3e7d226a1793eaceb08fec45ce8

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+### 0.0.1 / 2023-02-09
+
+* Everything is new. First release

data/Manifest.txt

@@ -0,0 +1,6 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/abi2ruby.rb
+lib/abi2ruby/generate.rb

data/README.md

@@ -0,0 +1,241 @@
+#  Application Binary Interface (ABI) Contract Generator
+
+abi2ruby - generate ready-to-use (blockchain) contract services / function calls for ethereum & co. via application binary inferfaces (abis)
+
+
+* home  :: [github.com/rubycocos/blockchain](https://github.com/rubycocos/blockchain)
+* bugs  :: [github.com/rubycocos/blockchain/issues](https://github.com/rubycocos/blockchain/issues)
+* gem   :: [rubygems.org/gems/abi2ruby](https://rubygems.org/gems/abi2ruby)
+* rdoc  :: [rubydoc.info/gems/abi2ruby](http://rubydoc.info/gems/abi2ruby)
+
+
+
+## Usage
+
+Let's try to generate the contract "wrapper" code in ruby
+from the application binary interface (abi) in json
+for punk blocks (anno 2020) - plus let's add the optional "natspec" comments:
+
+``` ruby
+require 'abi2ruby'
+
+punk_blocks = '0x58e90596c2065befd3060767736c829c18f3474c'
+
+abi     = ABI.read( "./abis/#{punk_blocks}.json" )
+natspec = Natspec.read( "./abis/#{punk_blocks}.md" )
+
+buf =  abi.generate_code( name: 'PunkBlocks',
+                          address: punk_blocks,
+                          natspec: natspec )
+write_text( "./punk_blocks.rb", buf )
+```
+
+resulting in:
+
+
+---
+
+``` ruby
+#########################
+# PunkBlocks contract / (blockchain) services / function calls
+#  auto-generated via abi2ruby (see https://rubygems.org/gems/abi2ruby) on 2023-01-13 15:31:38 UTC
+#  - 8 query functions(s)
+#
+#
+#  - Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
+#  - Version: v0.0.2
+#  - Pragma: solidity ^0.8.17
+#
+#
+#       ███████████                        █████
+#      ░░███░░░░░███                      ░░███
+#       ░███    ░███ █████ ████ ████████   ░███ █████
+#       ░██████████ ░░███ ░███ ░░███░░███  ░███░░███
+#       ░███░░░░░░   ░███ ░███  ░███ ░███  ░██████░
+#       ░███         ░███ ░███  ░███ ░███  ░███░░███
+#       █████        ░░████████ ████ █████ ████ █████
+#      ░░░░░          ░░░░░░░░ ░░░░ ░░░░░ ░░░░ ░░░░░
+#
+#
+#
+#       ███████████  ████                    █████
+#      ░░███░░░░░███░░███                   ░░███
+#       ░███    ░███ ░███   ██████   ██████  ░███ █████  █████
+#       ░██████████  ░███  ███░░███ ███░░███ ░███░░███  ███░░
+#       ░███░░░░░███ ░███ ░███ ░███░███ ░░░  ░██████░  ░░█████
+#       ░███    ░███ ░███ ░███ ░███░███  ███ ░███░░███  ░░░░███
+#       ███████████  █████░░██████ ░░██████  ████ █████ ██████
+#      ░░░░░░░░░░░  ░░░░░  ░░░░░░   ░░░░░░  ░░░░ ░░░░░ ░░░░░░
+#
+#  A Registry of 24x24 png images
+#
+#  This contract:
+#
+#  1. Stores all the classic traits of the CryptoPunks in
+#  individual png files, 100% on-chain. These are then used as
+#  blocks to construct CryptoPunk images. Outputted as SVGs.
+#
+#  2. Any of the 10,000 "classic" CryptoPunks can be generated
+#  by supplying desired arguments to a function, such as
+#  the id of a punk, or a list of the traits.
+#
+#  3. An unlimited number of new punk images can be generated from
+#  the existing classic set of traits, or even from new traits!
+#
+#  4. New traits (blocks) can be added to the contract by
+#  registering them with the `registerBlock` function.
+#
+#  Further documentation:
+#  https://github.com/0xTycoon/punk-blocks
+#
+#
+#
+#  **Data Structures**
+#
+#  Layer is in the order of rendering
+#
+#          enum Layer {
+#              Base,      // 0 Base is the face. Determines if m or f version will be used...
+#              Cheeks,    // 1 (Rosy Cheeks)
+#              Blemish,   // 2 (Mole, Spots)
+#              Hair,      // 3 (Purple Hair, Shaved Head, Pigtails, ...)
+#              Beard,     // 4 (Big Beard, Front Beard, Goat, ...)
+#              Eyes,      // 5 (Clown Eyes Green, Green Eye Shadow, ...)
+#              Eyewear,   // 6 (VR, 3D Glass, Eye Mask, Regular Shades, Welding Glasses, ...)
+#              Nose,      // 7 (Clown Nose)
+#              Mouth,     // 8 (Hot Lipstick, Smile, Buck Teeth, ...)
+#              MouthProp, // 9 (Medical Mask, Cigarette, ...)
+#              Earring,   // 10 (Earring)
+#              Headgear,  // 11 (Beanie, Fedora, Hoodie, Police Cap, Tiara, Headband, ...)
+#              Neck       // 12 (Choker, Silver Chain, Gold Chain)
+#          }
+#
+#          struct Block {
+#              Layer layer;     // 13 possible layers
+#              bytes dataMale;  // male version of this attribute
+#              bytes dataFemale;// female version of this attribute
+#          }
+#
+#
+#  **Events**
+#
+#      event NewBlock(address, uint256, string)
+
+
+class  PunkBlocks <  Ethlite::Contract
+
+  address "0x58e90596c2065befd3060767736c829c18f3474c"
+
+#  storage - mapping(bytes32 => Block) public blocks
+#
+#  stores punk attributes as a png
+sig "blocks", inputs: ["bytes32"], outputs: ["uint8","bytes","bytes"]
+def blocks(arg0)
+  do_call("blocks", arg0)
+end
+
+#  function getBlocks
+#
+#  getBlocks returns a sequential list of blocks in a single call
+#      @param _fromID is which id to begin from
+#      @param _count how many items to retrieve.
+#      @return Block[] list of blocks, uint256 next id
+sig "getBlocks", inputs: ["uint256","uint256"], outputs: ["(uint8,bytes,bytes)[]","uint256"]
+def getBlocks(_fromID, _count)
+  do_call("getBlocks", _fromID, _count)
+end
+
+#  storage - mapping(uint256 => bytes32) public index
+#
+#  index of each block by its sequence
+sig "index", inputs: ["uint256"], outputs: ["bytes32"]
+def index(arg0)
+  do_call("index", arg0)
+end
+
+#  storage - uint256 public nextId
+#
+#  next id to use when adding a block
+sig "nextId", outputs: ["uint256"]
+def nextId()
+  do_call("nextId")
+end
+
+#  function svgFromIDs
+#
+#  svgFromIDs returns the svg data as a string
+#         e.g. [9,55,99]
+#         One of the elements must be must be a layer 0 block.
+#         This element decides what version of image to use for the higher layers
+#         (dataMale or dataFemale)
+#       @param _ids uint256 ids of an attribute, by it's index of creation
+sig "svgFromIDs", inputs: ["uint256[]"], outputs: ["string"]
+def svgFromIDs(_ids)
+  do_call("svgFromIDs", _ids)
+end
+
+#  function svgFromKeys
+#
+#  svgFromKeys returns the svg data as a string
+#  @param _attributeKeys a list of attribute names that have been hashed,
+#          eg keccak256("Male 1"), keccak256("Goat")
+#          must have at least 1 layer 0 attribute (eg. keccak256("Male 1")) which
+#          decides what version of image to use for the higher layers
+#          (dataMale or dataFemale)
+#          e.g. ["0x9039da071f773e85254cbd0f99efa70230c4c11d63fce84323db9eca8e8ef283",
+#          "0xd5de5c20969a9e22f93842ca4d65bac0c0387225cee45a944a14f03f9221fd4a"]
+sig "svgFromKeys", inputs: ["bytes32[]"], outputs: ["string"]
+def svgFromKeys(_attributeKeys)
+  do_call("svgFromKeys", _attributeKeys)
+end
+
+#  function svgFromNames
+#
+#  svgFromNames returns the svg data as a string
+#  @param _attributeNames a list of attribute names, eg "Male 1", "Goat"
+#     must have at least 1 layer 0 attribute (eg. Male, Female, Alien, Ape, Zombie)
+#     e.g. ["Male 1","Goat"]
+#     Where "Male 1" is a layer 0 attribute, that decides what version of
+#     image to use for the higher
+#    layers (dataMale or dataFemale)
+sig "svgFromNames", inputs: ["string[]"], outputs: ["string"]
+def svgFromNames(_attributeNames)
+  do_call("svgFromNames", _attributeNames)
+end
+
+#  function svgFromPunkID
+#
+#  svgFromPunkID returns the svg data as a string given a punk id
+#      @param _tokenID uint256 IDs a punk id, 0-9999
+sig "svgFromPunkID", inputs: ["uint256"], outputs: ["string"]
+def svgFromPunkID(_tokenID)
+  do_call("svgFromPunkID", _tokenID)
+end
+
+end   ## class PunkBlocks
+```
+
+
+That's it for now.
+
+
+Tip: For some pre-packaged ready-to-use "out-of-the-gem" contracts,
+see [**ethlite-contracts »**](https://github.com/rubycocos/blockchain/tree/master/ethlite-contracts)
+
+
+
+
+
+
+## License
+
+The scripts are dedicated to the public domain.
+Use it as you please with no restrictions whatsoever.
+
+
+## Questions? Comments?
+
+
+Post them on the [D.I.Y. Punk (Pixel) Art reddit](https://old.reddit.com/r/DIYPunkArt). Thanks.
+
+

data/Rakefile

@@ -0,0 +1,38 @@
+require 'hoe'
+
+
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
+Hoe.spec 'abi2ruby' do
+
+  self.version = '0.1.0'
+  self.summary = "abi2ruby  - generate ready-to-use (blockchain) contract services / function calls for ethereum & co. via application binary inferfaces (abis)"
+  self.description = summary
+
+  self.urls    = { home: 'https://github.com/rubycocos/blockchain' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+    ['abiparser'],
+    ['natspec'],
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.3'
+  }
+
+end
+

data/lib/abi2ruby/generate.rb

@@ -0,0 +1,128 @@
+
+module ABI
+  class Contract
+
+
+def _generate_func( func )
+  buf = String.new
+
+  buf << "def #{func.name}("
+
+  func.inputs.each_with_index do |param,i|
+      buf << ", "  if i > 0
+      if param.name
+         buf << "#{param.name}"
+      else
+         buf << "arg#{i}"
+      end
+  end
+
+  buf << ")\n"
+
+  buf << "  do_call("
+  buf << %Q{"#{func.name}"}
+
+  func.inputs.each_with_index do |param,i|
+    buf << ", "
+    if param.name
+       buf << "#{param.name}"
+    else
+       buf << "arg#{i}"
+    end
+  end
+
+  buf << ")\n"
+  buf << "end\n"
+
+  ## note: quick hack - for rdoc/yard doc generation
+  ##            move sig method below method
+  buf << %Q{sig "#{func.name}"}
+
+  if func.inputs.size > 0
+      quoted_types = func.inputs.map {|param| %Q{"#{param.sig}"} }
+      buf << ", inputs: [#{quoted_types.join(',')}]"
+  end
+
+  if func.outputs.size > 0
+    quoted_types = func.outputs.map {|param| %Q{"#{param.sig}"} }
+    buf << ", outputs: [#{quoted_types.join(',')}]"
+  end
+  buf
+end
+
+def generate_code( name: 'Contract',
+                   address: nil,
+                   natspec: nil )
+  buf = ''
+  ## buf << "#########################\n"
+  buf << "# #{name} contract / (blockchain) services / function calls\n"
+  buf << "#\n"
+  buf << "#  auto-generated via abi2ruby (see https://rubygems.org/gems/abi2ruby) on #{Time.now.utc}\n"
+  buf << "#  - #{query_functions.size} query functions(s)\n"
+  buf << "#  - #{helper_functions.size} helper functions(s)\n"
+
+  if natspec && natspec.head.size > 0
+     buf << "#\n#\n"
+     natspec.head.each do |line|
+        buf <<  (line.empty? ? "#\n" : "#  #{line}\n")
+     end
+  end
+  buf << "\n\n"
+
+
+
+  buf << "class  #{name} <  Ethlite::Contract\n\n"
+
+  if address
+    buf << "  address "
+    buf << %Q{"#{address}"}
+    buf << "\n"
+  end
+
+
+  if query_functions.size > 0
+    buf << "\n"
+    query_functions.each do |func|
+
+      if natspec && (natspec.storage[ func.name] || natspec.functions[ func.name ])
+         sect = natspec.storage[ func.name ] || natspec.functions[ func.name ]
+         buf << "#  #{sect[0]}\n#\n"
+         sect[1].each do |line|
+               buf <<  (line.empty? ? "#\n" : "#  #{line}\n")
+              end
+      else
+        buf << "#  #{func.doc} _readonly_\n"
+      end
+
+      buf << _generate_func( func )
+      buf << "\n\n"
+    end
+  end
+
+
+  if helper_functions.size > 0
+    buf << "\n"
+    helper_functions.each do |func|
+
+      if natspec && (natspec.storage[ func.name] || natspec.functions[ func.name ])
+         sect = natspec.storage[ func.name ] || natspec.functions[ func.name ]
+         buf << "#  #{sect[0]}\n#\n"
+         sect[1].each do |line|
+               buf <<  (line.empty? ? "#\n" : "#  #{line}\n")
+              end
+      else
+        buf << "#  #{func.doc} _readonly_\n"
+      end
+
+      buf << _generate_func( func )
+      buf << "\n\n"
+   end
+  end
+
+   buf << "end   ## class #{name}\n"
+   buf << "\n"
+   buf
+end
+
+end  ## class Contract
+end ##  module ABI

data/lib/abi2ruby.rb

@@ -0,0 +1,9 @@
+require 'abiparser'
+require 'natspec'
+
+
+## our own code
+## require_relative 'abi2ruby/version'    # note: let version always go first
+
+require_relative 'abi2ruby/generate'
+

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: abi2ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gerald Bauer
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abiparser
+  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: natspec
+  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
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: abi2ruby  - generate ready-to-use (blockchain) contract services / function
+  calls for ethereum & co. via application binary inferfaces (abis)
+email: wwwmake@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/abi2ruby.rb
+- lib/abi2ruby/generate.rb
+homepage: https://github.com/rubycocos/blockchain
+licenses:
+- Public Domain
+metadata: {}
+post_install_message:
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: abi2ruby  - generate ready-to-use (blockchain) contract services / function
+  calls for ethereum & co. via application binary inferfaces (abis)
+test_files: []