ethlite-contracts 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d178b4a5c7a28105b60fe1dfaff5bf4f3e5f4f55b3211d264b6dea4c3f50ebf5
-  data.tar.gz: b353c9a48aee0ba0cc116f4c6d924d4c6ad1e9a8c795b67520eb8d0313f8f57b
+  metadata.gz: a198b63a1148a0e8e36cc2d5ab99f30857ca3a9c70d6e53199c97b33601ce547
+  data.tar.gz: a7446a701fbe7e7b84af8d51042f97c05a40389ca410e3b3222070c1a5e1b5ea
 SHA512:
-  metadata.gz: 28fc5a42637286b9124b038da8c48667187755e508eeda7716716cefb4aefef66c66dcdae754cc653a13430ac47d82c13d3d6857d4f95323759a30cd51b0b36d
-  data.tar.gz: b599c075e9721301ba1865a151a320fbc8f28ee3a444e4aff68cf421c1ad748a34b03478e6b75cb9c6139d0b629ce6afe66bf8abcff164d650fdbfb0de58b8e4
+  metadata.gz: 022d69134a5f510655876772b81351715bbc1fb67fadeb6cbf025a8e535f3f848af74cb4d9da19e3ab0188ff7f6bdebdef0e8cd883d9a9489bf585c19914b41c
+  data.tar.gz: 7a6f8b1eee2674d998fab9b19e4f4c9c5100942b23eaf844a12e4d2011213833ba1534d2149ecc8b776d504484045e944ffa1b643782f8903b0725208e5bcd7d

data/Rakefile

@@ -3,7 +3,7 @@ require 'hoe'
 
 Hoe.spec 'ethlite-contracts' do
 
-  self.version = '0.0.1'
+  self.version = '0.1.0'
   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,55 +1,214 @@
 #########################
 # 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-12 17:17:30 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_
+#  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**(uint256 _fromID, uint256 _count) ⇒ (struct PunkBlocks.Block[] _, uint256 _) _readonly_
+#  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
 
-#  function **index**(uint256 _) ⇒ (bytes32 _) _readonly_
+#  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
 
-#  function **nextId**() ⇒ (uint256 _) _readonly_
+#  storage - uint256 public nextId
+#
+#  
+#  next id to use when adding a block
+#  
 sig "nextId", outputs: ["uint256"]
 def nextId()
   do_call("nextId")
 end
 
-#  function **svgFromIDs**(uint256[] _ids) ⇒ (string _) _readonly_
+#  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**(bytes32[] _attributeKeys) ⇒ (string _) _readonly_
+#  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**(string[] _attributeNames) ⇒ (string _) _readonly_
+#  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**(uint256 _tokenID) ⇒ (string _) _readonly_
+#  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)

data/lib/ethlite/contracts/punks_v1.rb

@@ -1,91 +1,155 @@
 #########################
 # 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-12 17:17:29 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_
+#  storage - string public name
+#
 sig "name", outputs: ["string"]
 def name()
   do_call("name")
 end
 
-#  function **punksOfferedForSale**(uint256 _) ⇒ (bool isForSale, uint256 punkIndex, address seller, uint256 minValue, address onlySellTo) _readonly_
+#  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
+#  
 sig "punksOfferedForSale", inputs: ["uint256"], outputs: ["bool","uint256","address","uint256","address"]
 def punksOfferedForSale(arg0)
   do_call("punksOfferedForSale", arg0)
 end
 
-#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+#  storage -   uint256 public totalSupply
+#
+#  
 sig "totalSupply", outputs: ["uint256"]
 def totalSupply()
   do_call("totalSupply")
 end
 
-#  function **decimals**() ⇒ (uint8 _) _readonly_
+#  storage -    uint8 public decimals
+#
 sig "decimals", outputs: ["uint8"]
 def decimals()
   do_call("decimals")
 end
 
-#  function **imageHash**() ⇒ (string _) _readonly_
+#  storage - string public imageHash
+#
+#  
+#  You can use this hash to verify the image file containing all the punks
+#  
 sig "imageHash", outputs: ["string"]
 def imageHash()
   do_call("imageHash")
 end
 
-#  function **nextPunkIndexToAssign**() ⇒ (uint256 _) _readonly_
+#  storage -    uint public nextPunkIndexToAssign
+#
+#  
 sig "nextPunkIndexToAssign", outputs: ["uint256"]
 def nextPunkIndexToAssign()
   do_call("nextPunkIndexToAssign")
 end
 
-#  function **punkIndexToAddress**(uint256 _) ⇒ (address _) _readonly_
+#  storage -   mapping (uint => address) public punkIndexToAddress
+#
+#  
+#  
 sig "punkIndexToAddress", inputs: ["uint256"], outputs: ["address"]
 def punkIndexToAddress(arg0)
   do_call("punkIndexToAddress", arg0)
 end
 
-#  function **standard**() ⇒ (string _) _readonly_
+#  storage - string public standard
+#
+#  
 sig "standard", outputs: ["string"]
 def standard()
   do_call("standard")
 end
 
-#  function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
+#  storage -  mapping (address => uint256) public balanceOf
+#
+#  This creates an array with all balances
+#  
+#  
 sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
 def balanceOf(arg0)
   do_call("balanceOf", arg0)
 end
 
-#  function **symbol**() ⇒ (string _) _readonly_
+#  storage -    string public symbol
+#
 sig "symbol", outputs: ["string"]
 def symbol()
   do_call("symbol")
 end
 
-#  function **numberOfPunksToReserve**() ⇒ (uint256 _) _readonly_
+#  storage -   uint public numberOfPunksToReserve
+#
 sig "numberOfPunksToReserve", outputs: ["uint256"]
 def numberOfPunksToReserve()
   do_call("numberOfPunksToReserve")
 end
 
-#  function **numberOfPunksReserved**() ⇒ (uint256 _) _readonly_
+#  storage -   uint public numberOfPunksReserved
+#
+#  
 sig "numberOfPunksReserved", outputs: ["uint256"]
 def numberOfPunksReserved()
   do_call("numberOfPunksReserved")
 end
 
-#  function **punksRemainingToAssign**() ⇒ (uint256 _) _readonly_
+#  storage -   uint public punksRemainingToAssign
+#
 sig "punksRemainingToAssign", outputs: ["uint256"]
 def punksRemainingToAssign()
   do_call("punksRemainingToAssign")
 end
 
-#  function **pendingWithdrawals**(address _) ⇒ (uint256 _) _readonly_
+#  storage - mapping (address => uint) public pendingWithdrawals
+#
+#  
+#  
+#  
 sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
 def pendingWithdrawals(arg0)
   do_call("pendingWithdrawals", arg0)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite-contracts
 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-09 00:00:00.000000000 Z
+date: 2023-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethlite