ethlite-contracts 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d178b4a5c7a28105b60fe1dfaff5bf4f3e5f4f55b3211d264b6dea4c3f50ebf5
-  data.tar.gz: b353c9a48aee0ba0cc116f4c6d924d4c6ad1e9a8c795b67520eb8d0313f8f57b
+  metadata.gz: ca6de1c37a18e18603847fb4f34cece9177d8839e561a2e68cf1e772fbe81c81
+  data.tar.gz: 52e07b948256fae1714ac69cf6fa3f3580638c89d41fcfdbbfe9ce84528c45d7
 SHA512:
-  metadata.gz: 28fc5a42637286b9124b038da8c48667187755e508eeda7716716cefb4aefef66c66dcdae754cc653a13430ac47d82c13d3d6857d4f95323759a30cd51b0b36d
-  data.tar.gz: b599c075e9721301ba1865a151a320fbc8f28ee3a444e4aff68cf421c1ad748a34b03478e6b75cb9c6139d0b629ce6afe66bf8abcff164d650fdbfb0de58b8e4
+  metadata.gz: 7132e907281f9bd8efdabd16f337943339315d7406e05fc22f043a605616ea626d6886f9bad87ad089da5bfa6b6116f3d5edf163f69ec86cb957e81898fe5b96
+  data.tar.gz: ff12785374324d102cb92a8ae0a6c52ec2af1d15c8925aab796a07ce9c467adb5572d03d5bb369208ad8a70462387fc2387c6e28577dfe3f14370849471e7557

data/Rakefile

@@ -3,7 +3,7 @@ require 'hoe'
 
 Hoe.spec 'ethlite-contracts' do
 
-  self.version = '0.0.1'
+  self.version = '0.1.1'
   self.summary = "ethlite-contracts  - ready-to-use (blockchain) contract services / function calls for ethereum & co."
   self.description = summary
 

data/lib/ethlite/contracts/punk_blocks.rb

@@ -1,59 +1,178 @@
 #########################
 # PunkBlocks contract / (blockchain) services / function calls
-#    auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-09 17:48:57 UTC
-#    - 8 query functions(s)
+#  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"
 
-#  function **blocks**(bytes32 _) ⇒ (enum PunkBlocks.Layer layer, bytes dataMale, bytes dataFemale) _readonly_
-sig "blocks", inputs: ["bytes32"], outputs: ["uint8","bytes","bytes"]
+#  storage - mapping(bytes32 => Block) public blocks
+#
+#  stores punk attributes as a png
 def blocks(arg0)
   do_call("blocks", arg0)
 end
+sig "blocks", inputs: ["bytes32"], outputs: ["uint8","bytes","bytes"]
 
-#  function **getBlocks**(uint256 _fromID, uint256 _count) ⇒ (struct PunkBlocks.Block[] _, uint256 _) _readonly_
-sig "getBlocks", inputs: ["uint256","uint256"], outputs: ["(uint8,bytes,bytes)[]","uint256"]
+#  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
 def getBlocks(_fromID, _count)
   do_call("getBlocks", _fromID, _count)
 end
+sig "getBlocks", inputs: ["uint256","uint256"], outputs: ["(uint8,bytes,bytes)[]","uint256"]
 
-#  function **index**(uint256 _) ⇒ (bytes32 _) _readonly_
-sig "index", inputs: ["uint256"], outputs: ["bytes32"]
+#  storage - mapping(uint256 => bytes32) public index
+#
+#  index of each block by its sequence
 def index(arg0)
   do_call("index", arg0)
 end
+sig "index", inputs: ["uint256"], outputs: ["bytes32"]
 
-#  function **nextId**() ⇒ (uint256 _) _readonly_
-sig "nextId", outputs: ["uint256"]
+#  storage - uint256 public nextId
+#
+#  next id to use when adding a block
 def nextId()
   do_call("nextId")
 end
+sig "nextId", outputs: ["uint256"]
 
-#  function **svgFromIDs**(uint256[] _ids) ⇒ (string _) _readonly_
-sig "svgFromIDs", inputs: ["uint256[]"], outputs: ["string"]
+#  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
 def svgFromIDs(_ids)
   do_call("svgFromIDs", _ids)
 end
+sig "svgFromIDs", inputs: ["uint256[]"], outputs: ["string"]
 
-#  function **svgFromKeys**(bytes32[] _attributeKeys) ⇒ (string _) _readonly_
-sig "svgFromKeys", inputs: ["bytes32[]"], outputs: ["string"]
+#  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"]
 def svgFromKeys(_attributeKeys)
   do_call("svgFromKeys", _attributeKeys)
 end
+sig "svgFromKeys", inputs: ["bytes32[]"], outputs: ["string"]
 
-#  function **svgFromNames**(string[] _attributeNames) ⇒ (string _) _readonly_
-sig "svgFromNames", inputs: ["string[]"], outputs: ["string"]
+#  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)
 def svgFromNames(_attributeNames)
   do_call("svgFromNames", _attributeNames)
 end
+sig "svgFromNames", inputs: ["string[]"], outputs: ["string"]
 
-#  function **svgFromPunkID**(uint256 _tokenID) ⇒ (string _) _readonly_
-sig "svgFromPunkID", inputs: ["uint256"], outputs: ["string"]
+#  function svgFromPunkID
+#
+#  svgFromPunkID returns the svg data as a string given a punk id
+#      @param _tokenID uint256 IDs a punk id, 0-9999
 def svgFromPunkID(_tokenID)
   do_call("svgFromPunkID", _tokenID)
 end
+sig "svgFromPunkID", inputs: ["uint256"], outputs: ["string"]
 
 end   ## class PunkBlocks
 

data/lib/ethlite/contracts/punks_v1.rb

@@ -1,95 +1,137 @@
 #########################
 # PunksV1 contract / (blockchain) services / function calls
-#    auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-09 17:48:57 UTC
-#    - 14 query functions(s)
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-13 15:31:37 UTC
+#  - 14 query functions(s)
+#
+#
+#  - Pragma:  solidity ^0.4.8
+#
+#
+#  **Data Structures**
+#
+#
+#          struct Offer {
+#              bool isForSale;
+#              uint punkIndex;
+#              address seller;
+#              uint minValue;          // in ether
+#              address onlySellTo;     // specify to sell only to a specific person
+#          }
+#
+#  **Events**
+#
+#          event Assign(address indexed to, uint256 punkIndex)
+#          event Transfer(address indexed from, address indexed to, uint256 value)
+#          event PunkTransfer(address indexed from, address indexed to, uint256 punkIndex)
+#          event PunkOffered(uint indexed punkIndex, uint minValue, address indexed toAddress)
+#          event PunkBought(uint indexed punkIndex, uint value, address indexed fromAddress, address indexed toAddress)
+#          event PunkNoLongerForSale(uint indexed punkIndex)
+
 
 class  PunksV1 <  Ethlite::Contract
 
   address "0x6ba6f2207e343923ba692e5cae646fb0f566db8d"
 
-#  function **name**() ⇒ (string _) _readonly_
-sig "name", outputs: ["string"]
+#  storage - string public name
+#
 def name()
   do_call("name")
 end
+sig "name", outputs: ["string"]
 
-#  function **punksOfferedForSale**(uint256 _) ⇒ (bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo) _readonly_
-sig "punksOfferedForSale", inputs: ["uint256"], outputs: ["bool","uint256","address","uint256","address"]
+#  storage - mapping (uint => Offer) public punksOfferedForSale
+#
+#  A record of punks that are offered for sale at a specific minimum value, and perhaps to a specific person
 def punksOfferedForSale(arg0)
   do_call("punksOfferedForSale", arg0)
 end
+sig "punksOfferedForSale", inputs: ["uint256"], outputs: ["bool","uint256","address","uint256","address"]
 
-#  function **totalSupply**() ⇒ (uint256 _) _readonly_
-sig "totalSupply", outputs: ["uint256"]
+#  storage -   uint256 public totalSupply
+#
 def totalSupply()
   do_call("totalSupply")
 end
+sig "totalSupply", outputs: ["uint256"]
 
-#  function **decimals**() ⇒ (uint8 _) _readonly_
-sig "decimals", outputs: ["uint8"]
+#  storage -    uint8 public decimals
+#
 def decimals()
   do_call("decimals")
 end
+sig "decimals", outputs: ["uint8"]
 
-#  function **imageHash**() ⇒ (string _) _readonly_
-sig "imageHash", outputs: ["string"]
+#  storage - string public imageHash
+#
+#  You can use this hash to verify the image file containing all the punks
 def imageHash()
   do_call("imageHash")
 end
+sig "imageHash", outputs: ["string"]
 
-#  function **nextPunkIndexToAssign**() ⇒ (uint256 _) _readonly_
-sig "nextPunkIndexToAssign", outputs: ["uint256"]
+#  storage -    uint public nextPunkIndexToAssign
+#
 def nextPunkIndexToAssign()
   do_call("nextPunkIndexToAssign")
 end
+sig "nextPunkIndexToAssign", outputs: ["uint256"]
 
-#  function **punkIndexToAddress**(uint256 _) ⇒ (address _) _readonly_
-sig "punkIndexToAddress", inputs: ["uint256"], outputs: ["address"]
+#  storage -   mapping (uint => address) public punkIndexToAddress
+#
 def punkIndexToAddress(arg0)
   do_call("punkIndexToAddress", arg0)
 end
+sig "punkIndexToAddress", inputs: ["uint256"], outputs: ["address"]
 
-#  function **standard**() ⇒ (string _) _readonly_
-sig "standard", outputs: ["string"]
+#  storage - string public standard
+#
 def standard()
   do_call("standard")
 end
+sig "standard", outputs: ["string"]
 
-#  function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
-sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+#  storage -  mapping (address => uint256) public balanceOf
+#
+#  This creates an array with all balances
 def balanceOf(arg0)
   do_call("balanceOf", arg0)
 end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
 
-#  function **symbol**() ⇒ (string _) _readonly_
-sig "symbol", outputs: ["string"]
+#  storage -    string public symbol
+#
 def symbol()
   do_call("symbol")
 end
+sig "symbol", outputs: ["string"]
 
-#  function **numberOfPunksToReserve**() ⇒ (uint256 _) _readonly_
-sig "numberOfPunksToReserve", outputs: ["uint256"]
+#  storage -   uint public numberOfPunksToReserve
+#
 def numberOfPunksToReserve()
   do_call("numberOfPunksToReserve")
 end
+sig "numberOfPunksToReserve", outputs: ["uint256"]
 
-#  function **numberOfPunksReserved**() ⇒ (uint256 _) _readonly_
-sig "numberOfPunksReserved", outputs: ["uint256"]
+#  storage -   uint public numberOfPunksReserved
+#
 def numberOfPunksReserved()
   do_call("numberOfPunksReserved")
 end
+sig "numberOfPunksReserved", outputs: ["uint256"]
 
-#  function **punksRemainingToAssign**() ⇒ (uint256 _) _readonly_
-sig "punksRemainingToAssign", outputs: ["uint256"]
+#  storage -   uint public punksRemainingToAssign
+#
 def punksRemainingToAssign()
   do_call("punksRemainingToAssign")
 end
+sig "punksRemainingToAssign", outputs: ["uint256"]
 
-#  function **pendingWithdrawals**(address _) ⇒ (uint256 _) _readonly_
-sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
+#  storage - mapping (address => uint) public pendingWithdrawals
+#
 def pendingWithdrawals(arg0)
   do_call("pendingWithdrawals", arg0)
 end
+sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
 
 end   ## class PunksV1
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite-contracts
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-09 00:00:00.000000000 Z
+date: 2023-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethlite