ethlite-contracts 0.1.0 → 0.1.2

data/lib/ethlite/contracts/mooncats.rb

@@ -0,0 +1,151 @@
+# Mooncats contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:44 UTC
+#  - 23 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  Mooncats <  Ethlite::Contract
+
+  address "0x60cd862c9c687a9de49aecdc3a99b74a4fc54ab6"
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **remainingGenesisCats**() ⇒ (uint16 _) _readonly_
+def remainingGenesisCats()
+  do_call("remainingGenesisCats")
+end
+sig "remainingGenesisCats", outputs: ["uint16"]
+
+#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+def totalSupply()
+  do_call("totalSupply")
+end
+sig "totalSupply", outputs: ["uint256"]
+
+#  function **remainingCats**() ⇒ (uint16 _) _readonly_
+def remainingCats()
+  do_call("remainingCats")
+end
+sig "remainingCats", outputs: ["uint16"]
+
+#  function **mode**() ⇒ (uint8 _) _readonly_
+def mode()
+  do_call("mode")
+end
+sig "mode", outputs: ["uint8"]
+
+#  function **getCatDetails**(bytes5 catId) ⇒ (bytes5 id, address owner, bytes32 name, address onlyOfferTo, uint256 offerPrice, address requester, uint256 requestPrice) _readonly_
+def getCatDetails(catId)
+  do_call("getCatDetails", catId)
+end
+sig "getCatDetails", inputs: ["bytes5"], outputs: ["bytes5","address","bytes32","address","uint256","address","uint256"]
+
+#  function **decimals**() ⇒ (uint8 _) _readonly_
+def decimals()
+  do_call("decimals")
+end
+sig "decimals", outputs: ["uint8"]
+
+#  function **getCatOwners**() ⇒ (address[] _) _readonly_
+def getCatOwners()
+  do_call("getCatOwners")
+end
+sig "getCatOwners", outputs: ["address[]"]
+
+#  function **catOwners**(bytes5 _) ⇒ (address _) _readonly_
+def catOwners(arg0)
+  do_call("catOwners", arg0)
+end
+sig "catOwners", inputs: ["bytes5"], outputs: ["address"]
+
+#  function **rescueOrder**(uint256 _) ⇒ (bytes5 _) _readonly_
+def rescueOrder(arg0)
+  do_call("rescueOrder", arg0)
+end
+sig "rescueOrder", inputs: ["uint256"], outputs: ["bytes5"]
+
+#  function **getCatIds**() ⇒ (bytes5[] _) _readonly_
+def getCatIds()
+  do_call("getCatIds")
+end
+sig "getCatIds", outputs: ["bytes5[]"]
+
+#  function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
+def balanceOf(arg0)
+  do_call("balanceOf", arg0)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **getCatNames**() ⇒ (bytes32[] _) _readonly_
+def getCatNames()
+  do_call("getCatNames")
+end
+sig "getCatNames", outputs: ["bytes32[]"]
+
+#  function **adoptionOffers**(bytes5 _) ⇒ (bool exists, bytes5 catId, address seller, uint256 price, address onlyOfferTo) _readonly_
+def adoptionOffers(arg0)
+  do_call("adoptionOffers", arg0)
+end
+sig "adoptionOffers", inputs: ["bytes5"], outputs: ["bool","bytes5","address","uint256","address"]
+
+#  function **catNames**(bytes5 _) ⇒ (bytes32 _) _readonly_
+def catNames(arg0)
+  do_call("catNames", arg0)
+end
+sig "catNames", inputs: ["bytes5"], outputs: ["bytes32"]
+
+#  function **symbol**() ⇒ (string _) _readonly_
+def symbol()
+  do_call("symbol")
+end
+sig "symbol", outputs: ["string"]
+
+#  function **getCatRequestPrices**() ⇒ (uint256[] _) _readonly_
+def getCatRequestPrices()
+  do_call("getCatRequestPrices")
+end
+sig "getCatRequestPrices", outputs: ["uint256[]"]
+
+#  function **searchSeed**() ⇒ (bytes32 _) _readonly_
+def searchSeed()
+  do_call("searchSeed")
+end
+sig "searchSeed", outputs: ["bytes32"]
+
+#  function **imageGenerationCodeMD5**() ⇒ (bytes16 _) _readonly_
+def imageGenerationCodeMD5()
+  do_call("imageGenerationCodeMD5")
+end
+sig "imageGenerationCodeMD5", outputs: ["bytes16"]
+
+#  function **adoptionRequests**(bytes5 _) ⇒ (bool exists, bytes5 catId, address requester, uint256 price) _readonly_
+def adoptionRequests(arg0)
+  do_call("adoptionRequests", arg0)
+end
+sig "adoptionRequests", inputs: ["bytes5"], outputs: ["bool","bytes5","address","uint256"]
+
+#  function **getCatOfferPrices**() ⇒ (uint256[] _) _readonly_
+def getCatOfferPrices()
+  do_call("getCatOfferPrices")
+end
+sig "getCatOfferPrices", outputs: ["uint256[]"]
+
+#  function **rescueIndex**() ⇒ (uint16 _) _readonly_
+def rescueIndex()
+  do_call("rescueIndex")
+end
+sig "rescueIndex", outputs: ["uint16"]
+
+#  function **pendingWithdrawals**(address _) ⇒ (uint256 _) _readonly_
+def pendingWithdrawals(arg0)
+  do_call("pendingWithdrawals", arg0)
+end
+sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
+
+end   ## class Mooncats
+

data/lib/ethlite/contracts/phunks_v2.rb

@@ -0,0 +1,145 @@
+# PhunksV2 contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:46 UTC
+#  - 22 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  PhunksV2 <  Ethlite::Contract
+
+  address "0xf07468ead8cf26c752c676e43c814fee9c8cf402"
+
+#  function **MAX_MINTABLE_AT_ONCE**() ⇒ (uint256 _) _readonly_
+def MAX_MINTABLE_AT_ONCE()
+  do_call("MAX_MINTABLE_AT_ONCE")
+end
+sig "MAX_MINTABLE_AT_ONCE", outputs: ["uint256"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **contractURI**() ⇒ (string _) _readonly_
+def contractURI()
+  do_call("contractURI")
+end
+sig "contractURI", outputs: ["string"]
+
+#  function **freeRollPhunks**(address _) ⇒ (uint256 _) _readonly_
+def freeRollPhunks(arg0)
+  do_call("freeRollPhunks", arg0)
+end
+sig "freeRollPhunks", inputs: ["address"], outputs: ["uint256"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getCostForMintingPhunks**(uint256 _numToMint) ⇒ (uint256 _) _readonly_
+def getCostForMintingPhunks(_numToMint)
+  do_call("getCostForMintingPhunks", _numToMint)
+end
+sig "getCostForMintingPhunks", inputs: ["uint256"], outputs: ["uint256"]
+
+#  function **getNumFreeRollPhunks**(address owner) ⇒ (uint256 _) _readonly_
+def getNumFreeRollPhunks(owner)
+  do_call("getNumFreeRollPhunks", owner)
+end
+sig "getNumFreeRollPhunks", inputs: ["address"], outputs: ["uint256"]
+
+#  function **getPhunksBelongingToOwner**(address _owner) ⇒ (uint256[] _) _readonly_
+def getPhunksBelongingToOwner(_owner)
+  do_call("getPhunksBelongingToOwner", _owner)
+end
+sig "getPhunksBelongingToOwner", inputs: ["address"], outputs: ["uint256[]"]
+
+#  function **imageHash**() ⇒ (string _) _readonly_
+def imageHash()
+  do_call("imageHash")
+end
+sig "imageHash", outputs: ["string"]
+
+#  function **isApprovedForAll**(address owner, address operator) ⇒ (bool _) _readonly_
+def isApprovedForAll(owner, operator)
+  do_call("isApprovedForAll", owner, operator)
+end
+sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
+
+#  function **isSaleOn**() ⇒ (bool _) _readonly_
+def isSaleOn()
+  do_call("isSaleOn")
+end
+sig "isSaleOn", outputs: ["bool"]
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **numTotalPhunks**() ⇒ (uint256 _) _readonly_
+def numTotalPhunks()
+  do_call("numTotalPhunks")
+end
+sig "numTotalPhunks", outputs: ["uint256"]
+
+#  function **owner**() ⇒ (address _) _readonly_
+def owner()
+  do_call("owner")
+end
+sig "owner", outputs: ["address"]
+
+#  function **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
+def ownerOf(tokenId)
+  do_call("ownerOf", tokenId)
+end
+sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
+
+#  function **saleHasBeenStarted**() ⇒ (bool _) _readonly_
+def saleHasBeenStarted()
+  do_call("saleHasBeenStarted")
+end
+sig "saleHasBeenStarted", outputs: ["bool"]
+
+#  function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
+def supportsInterface(interfaceId)
+  do_call("supportsInterface", interfaceId)
+end
+sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
+
+#  function **symbol**() ⇒ (string _) _readonly_
+def symbol()
+  do_call("symbol")
+end
+sig "symbol", outputs: ["string"]
+
+#  function **tokenByIndex**(uint256 index) ⇒ (uint256 _) _readonly_
+def tokenByIndex(index)
+  do_call("tokenByIndex", index)
+end
+sig "tokenByIndex", inputs: ["uint256"], outputs: ["uint256"]
+
+#  function **tokenOfOwnerByIndex**(address owner, uint256 index) ⇒ (uint256 _) _readonly_
+def tokenOfOwnerByIndex(owner, index)
+  do_call("tokenOfOwnerByIndex", owner, index)
+end
+sig "tokenOfOwnerByIndex", inputs: ["address","uint256"], outputs: ["uint256"]
+
+#  function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenURI(_tokenId)
+  do_call("tokenURI", _tokenId)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+def totalSupply()
+  do_call("totalSupply")
+end
+sig "totalSupply", outputs: ["uint256"]
+
+end   ## class PhunksV2
+

data/lib/ethlite/contracts/punk_blocks.rb

@@ -1,97 +1,88 @@
-#########################
 # PunkBlocks contract / (blockchain) services / function calls
-#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-12 17:17:30 UTC
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:58 UTC
 #  - 8 query functions(s)
-
-#  
+#  - 0 helper 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
-#      }
-#  ```
-#  
-#  
+#
+#          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)
-#  ```
-#  
-#  
+#
+#      event NewBlock(address, uint256, string)
 
 
 class  PunkBlocks <  Ethlite::Contract
@@ -100,73 +91,54 @@ class  PunkBlocks <  Ethlite::Contract
 
 #  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
+sig "blocks", inputs: ["bytes32"], outputs: ["uint8","bytes","bytes"]
 
 #  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
+sig "getBlocks", inputs: ["uint256","uint256"], outputs: ["(uint8,bytes,bytes)[]","uint256"]
 
 #  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
+sig "index", inputs: ["uint256"], outputs: ["bytes32"]
 
 #  storage - uint256 public nextId
 #
-#  
 #  next id to use when adding a block
-#  
-sig "nextId", outputs: ["uint256"]
 def nextId()
   do_call("nextId")
 end
+sig "nextId", outputs: ["uint256"]
 
 #  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
+sig "svgFromIDs", inputs: ["uint256[]"], 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")
@@ -175,17 +147,13 @@ end
 #          (dataMale or dataFemale)
 #          e.g. ["0x9039da071f773e85254cbd0f99efa70230c4c11d63fce84323db9eca8e8ef283",
 #          "0xd5de5c20969a9e22f93842ca4d65bac0c0387225cee45a944a14f03f9221fd4a"]
-#  ```
-#  
-sig "svgFromKeys", inputs: ["bytes32[]"], outputs: ["string"]
 def svgFromKeys(_attributeKeys)
   do_call("svgFromKeys", _attributeKeys)
 end
+sig "svgFromKeys", inputs: ["bytes32[]"], 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)
@@ -193,26 +161,19 @@ end
 #     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
+sig "svgFromNames", inputs: ["string[]"], 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
-#  ```
-#  
-sig "svgFromPunkID", inputs: ["uint256"], outputs: ["string"]
 def svgFromPunkID(_tokenID)
   do_call("svgFromPunkID", _tokenID)
 end
+sig "svgFromPunkID", inputs: ["uint256"], outputs: ["string"]
 
 end   ## class PunkBlocks
 

data/lib/ethlite/contracts/punks_data.rb

@@ -0,0 +1,31 @@
+# PunksData contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:46 UTC
+#  - 3 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  PunksData <  Ethlite::Contract
+
+  address "0x16f5a35647d6f03d5d3da7b35409d65ba03af3b2"
+
+#  function **punkAttributes**(uint16 index) ⇒ (string text) _readonly_
+def punkAttributes(index)
+  do_call("punkAttributes", index)
+end
+sig "punkAttributes", inputs: ["uint16"], outputs: ["string"]
+
+#  function **punkImage**(uint16 index) ⇒ (bytes _) _readonly_
+def punkImage(index)
+  do_call("punkImage", index)
+end
+sig "punkImage", inputs: ["uint16"], outputs: ["bytes"]
+
+#  function **punkImageSvg**(uint16 index) ⇒ (string svg) _readonly_
+def punkImageSvg(index)
+  do_call("punkImageSvg", index)
+end
+sig "punkImageSvg", inputs: ["uint16"], outputs: ["string"]
+
+end   ## class PunksData
+