abigen 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2af88adfb037b066adbcdb376f41d9c7b22f90ac72832ed0804b6f14de2964e3
-  data.tar.gz: f95aee9a46c98b9896d9c9c09587ddfe55b1ac1b81d4e6d1a9905b07b5e5d9a5
+  metadata.gz: 961de95760c3dc2b5b3f6c6eafc2e95bd10848a4d3a395256e85038dec22638e
+  data.tar.gz: 4bfc9edef80e2ffc854a9f81a9dae1a59d40554e5e44983cff827a74734dba07
 SHA512:
-  metadata.gz: 3395ab689b6efc2b354287940f376567c5b7c0e34e6693662931150a7c19da0768c377ab1187a82563a5d33f667c1684d4aedc720b9a7da0fdfed484a5b33097
-  data.tar.gz: 470b580d57671302f73b10abaebf83e1519096c6e93d4843626160a30b4dd268ad4f45c8ff5f9e895eb48f9973955e72ced6b434745e7027a0bc884f9bb0626f
+  metadata.gz: 9c9e9d95d7f029bb08cf58c93ff0c2fd7b7b1a0808086283b090484ae4fc182c81ca0cba26b1a9c78a294eb84f019d9a6f23022eb0b36b1ef78dd88617b5877b
+  data.tar.gz: c4535d75a502ea5a8a425328008bc1552e156dd33470546bb21c392ec5661f5fd3138574ad9c5e88c5cccb028899a4723a77470d39050e70aa638b9b8f9fdb73

data/README.md

@@ -12,7 +12,217 @@ abigen - generate ready-to-use (blockchain) contract services / function calls f
 
 ## Usage
 
-To be done
+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 'abigen'
+
+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 abigen (see https://rubygems.org/gems/abigen) 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 to render the remaining layers
+#              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 »**](../ethlite_contracts)
+
+
 
 
 

data/Rakefile

@@ -1,9 +1,16 @@
 require 'hoe'
 
 
+###
+# hack/ quick fix for broken intuit_values - overwrite with dummy
+class Hoe
+  def intuit_values( input ); end
+end
+
+
 Hoe.spec 'abigen' do
 
-  self.version = '0.0.1'
+  self.version = '0.1.0'
   self.summary = "abigen  - generate ready-to-use (blockchain) contract services / function calls for ethereum & co. via application binary inferfaces (abis)"
   self.description = summary
 
@@ -18,6 +25,7 @@ Hoe.spec 'abigen' do
 
   self.extra_deps = [
     ['abiparser'],
+    ['natspec'],
   ]
 
   self.licenses = ['Public Domain']

data/lib/abigen.rb

@@ -1,4 +1,5 @@
 require 'abiparser'
+require 'natspec'
 
 
 ## our own code
@@ -10,12 +11,23 @@ module ABI
   class Contract
 
 
-def generate_code( name: 'Contract', address: nil )
+def generate_code( name: 'Contract',
+                   address: nil,
+                   natspec: nil )
   buf = ''
   buf << "#########################\n"
   buf << "# #{name} contract / (blockchain) services / function calls\n"
-  buf << "#    auto-generated via abigen (see https://rubygems.org/gems/abigen) on #{Time.now.utc}\n"
-  buf << "#    - #{query_functions.size} query functions(s)\n\n"
+  buf << "#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on #{Time.now.utc}\n"
+  buf << "#  - #{query_functions.size} query 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"
@@ -30,20 +42,18 @@ def generate_code( name: 'Contract', address: nil )
   if query_functions.size > 0
     buf << "\n"
     query_functions.each do |func|
-      buf << "#  #{func.doc} _readonly_\n"
-
-      buf << %Q{sig "#{func.name}"}
 
-      if func.inputs.size > 0
-          quoted_types = func.inputs.map {|param| %Q{"#{param.sig}"} }
-          buf << ", inputs: [#{quoted_types.join(',')}]"
+      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
 
-      if func.outputs.size > 0
-        quoted_types = func.outputs.map {|param| %Q{"#{param.sig}"} }
-        buf << ", outputs: [#{quoted_types.join(',')}]"
-      end
-      buf << "\n"
+
 
       buf << "def #{func.name}("
 
@@ -73,6 +83,26 @@ def generate_code( name: 'Contract', address: nil )
       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 << "\n"
+
+
+
+
+
       buf << "\n"
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: abigen
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-10 00:00:00.000000000 Z
+date: 2023-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abiparser
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !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