ethlite-contracts 0.1.0 → 0.1.2

data/lib/ethlite/contracts/punks_meta.rb

@@ -0,0 +1,80 @@
+# PunksMeta contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:56 UTC
+#  - 3 query functions(s)
+#  - 1 helper functions(s)
+#
+#
+#  - Author: 0xTycoon. Includes Base64 functionality from OpenZeppelin and builds  on top of the on-chain Punks data contact deployed by Larva Labs  as described here https://www.larvalabs.com/blog/2021-8-18-18-0/on-chain-cryptopunks
+#  - Version: 0.0.2
+#  - Pragma: solidity ^0.8.17
+#
+#
+#        █████                                   ██████
+#       █     █ █████  █   █ █████  █████  ████  █     █ █    █ █    █ █    █  ████
+#       █       █    █  █ █  █    █   █   █    █ █     █ █    █ ██   █ █   █  █
+#       █       █    █   █   █    █   █   █    █ ██████  █    █ █ █  █ ████    ████
+#       █       █████    █   █████    █   █    █ █       █    █ █  █ █ █  █        █
+#       █     █ █   █    █   █        █   █    █ █       █    █ █   ██ █   █  █    █
+#        █████  █    █   █   █        █    ████  █        ████  █    █ █    █  ████
+#      
+#       ███████                             █     █
+#          █     ████  █    █ ██████ █    █ █     █ █████  █
+#          █    █    █ █   █  █      ██   █ █     █ █    █ █
+#          █    █    █ ████   █████  █ █  █ █     █ █    █ █
+#          █    █    █ █  █   █      █  █ █ █     █ █████  █
+#          █    █    █ █   █  █      █   ██ █     █ █   █  █
+#          █     ████  █    █ ██████ █    █  █████  █    █ █
+#
+#
+#  Punks's missing tokenURI function
+
+
+class  PunksMeta <  Ethlite::Contract
+
+  address "0xd8e916c3016be144eb2907778cf972c4b01645fC"
+
+#  function getAttributes(uint256 _tokenId) returns (string)
+#
+#  getAttributes calls parseAttributes and returns the result as JSON
+#    @param _tokenId the punk id
+def getAttributes(_tokenId)
+  do_call("getAttributes", _tokenId)
+end
+sig "getAttributes", inputs: ["uint256"], outputs: ["string"]
+
+#  function parseAttributes(uint256 _tokenId) returns (string[8])
+#
+#  parseAttributes returns an array of punk attributes. 8 rows in total
+#      The first row is the Type, and next seven rows are the attributes.
+#      The values are fetched form the CryptoPunksData contract and then the
+#      string is parsed.
+#    @param _tokenId the punk id
+def parseAttributes(_tokenId)
+  do_call("parseAttributes", _tokenId)
+end
+sig "parseAttributes", inputs: ["uint256"], outputs: ["string[8]"]
+
+#  function tokenURI(uint256 _tokenId)  returns (string)
+#
+#  tokenURI gets the metadata about a punk and returns as a JSON
+#      formatted string, according to the ERC721 schema and market
+#      recommendations. It also embeds the SVG data.
+#      The attributes and SVG data are fetched form the CryptoPunksData
+#      contract, which stores all the CryptoPunks metadata on-chain.
+#    @param _tokenId the punk id
+def tokenURI(_tokenId)
+  do_call("tokenURI", _tokenId)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+
+#  function intToString(uint256 value) returns (string)
+#
+def intToString(value)
+  do_call("intToString", value)
+end
+sig "intToString", inputs: ["uint256"], outputs: ["string"]
+
+end   ## class PunksMeta
+

data/lib/ethlite/contracts/punks_v1.rb

@@ -1,38 +1,32 @@
-#########################
 # PunksV1 contract / (blockchain) services / function calls
-#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-12 17:17:29 UTC
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:57 UTC
 #  - 14 query functions(s)
-
+#  - 0 helper 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
-#      }
-#  ```
-#  
+#
+#
+#          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)
-#  ```
-#  
-#  
-#  
-#  
+#
+#          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
@@ -41,119 +35,104 @@ class  PunksV1 <  Ethlite::Contract
 
 #  storage - string public name
 #
-sig "name", outputs: ["string"]
 def name()
   do_call("name")
 end
+sig "name", outputs: ["string"]
 
 #  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
+sig "punksOfferedForSale", inputs: ["uint256"], outputs: ["bool","uint256","address","uint256","address"]
 
 #  storage -   uint256 public totalSupply
 #
-#  
-sig "totalSupply", outputs: ["uint256"]
 def totalSupply()
   do_call("totalSupply")
 end
+sig "totalSupply", outputs: ["uint256"]
 
 #  storage -    uint8 public decimals
 #
-sig "decimals", outputs: ["uint8"]
 def decimals()
   do_call("decimals")
 end
+sig "decimals", outputs: ["uint8"]
 
 #  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
+sig "imageHash", outputs: ["string"]
 
 #  storage -    uint public nextPunkIndexToAssign
 #
-#  
-sig "nextPunkIndexToAssign", outputs: ["uint256"]
 def nextPunkIndexToAssign()
   do_call("nextPunkIndexToAssign")
 end
+sig "nextPunkIndexToAssign", outputs: ["uint256"]
 
 #  storage -   mapping (uint => address) public punkIndexToAddress
 #
-#  
-#  
-sig "punkIndexToAddress", inputs: ["uint256"], outputs: ["address"]
 def punkIndexToAddress(arg0)
   do_call("punkIndexToAddress", arg0)
 end
+sig "punkIndexToAddress", inputs: ["uint256"], outputs: ["address"]
 
 #  storage - string public standard
 #
-#  
-sig "standard", outputs: ["string"]
 def standard()
   do_call("standard")
 end
+sig "standard", outputs: ["string"]
 
 #  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
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
 
 #  storage -    string public symbol
 #
-sig "symbol", outputs: ["string"]
 def symbol()
   do_call("symbol")
 end
+sig "symbol", outputs: ["string"]
 
 #  storage -   uint public numberOfPunksToReserve
 #
-sig "numberOfPunksToReserve", outputs: ["uint256"]
 def numberOfPunksToReserve()
   do_call("numberOfPunksToReserve")
 end
+sig "numberOfPunksToReserve", outputs: ["uint256"]
 
 #  storage -   uint public numberOfPunksReserved
 #
-#  
-sig "numberOfPunksReserved", outputs: ["uint256"]
 def numberOfPunksReserved()
   do_call("numberOfPunksReserved")
 end
+sig "numberOfPunksReserved", outputs: ["uint256"]
 
 #  storage -   uint public punksRemainingToAssign
 #
-sig "punksRemainingToAssign", outputs: ["uint256"]
 def punksRemainingToAssign()
   do_call("punksRemainingToAssign")
 end
+sig "punksRemainingToAssign", outputs: ["uint256"]
 
 #  storage - mapping (address => uint) public pendingWithdrawals
 #
-#  
-#  
-#  
-sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
 def pendingWithdrawals(arg0)
   do_call("pendingWithdrawals", arg0)
 end
+sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
 
 end   ## class PunksV1
 

data/lib/ethlite/contracts/synth_punks.rb

@@ -0,0 +1,182 @@
+# SynthPunks contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:48 UTC
+#  - 20 query functions(s)
+#  - 8 helper functions(s)
+
+
+class  SynthPunks <  Ethlite::Contract
+
+  address "0xaf9ce4b327a3b690abea6f78eccbfefffbea9fdf"
+
+#  function **_getAttributes**(address _address) ⇒ (uint256[] _) _readonly_
+def _getAttributes(_address)
+  do_call("_getAttributes", _address)
+end
+sig "_getAttributes", inputs: ["address"], outputs: ["uint256[]"]
+
+#  function **_tokenURI**(address _address) ⇒ (string _) _readonly_
+def _tokenURI(_address)
+  do_call("_tokenURI", _address)
+end
+sig "_tokenURI", inputs: ["address"], outputs: ["string"]
+
+#  function **assets**() ⇒ (contract ISyntheticPunksAssets _) _readonly_
+def assets()
+  do_call("assets")
+end
+sig "assets", outputs: ["address"]
+
+#  function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
+def balanceOf(arg0)
+  do_call("balanceOf", arg0)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **claimMessage**() ⇒ (string _) _readonly_
+def claimMessage()
+  do_call("claimMessage")
+end
+sig "claimMessage", outputs: ["string"]
+
+#  function **claimPrice**() ⇒ (uint256 _) _readonly_
+def claimPrice()
+  do_call("claimPrice")
+end
+sig "claimPrice", outputs: ["uint256"]
+
+#  function **claimed**(address _) ⇒ (bool _) _readonly_
+def claimed(arg0)
+  do_call("claimed", arg0)
+end
+sig "claimed", inputs: ["address"], outputs: ["bool"]
+
+#  function **generatePunkSVG**(uint256[] layers) ⇒ (string _) _readonly_
+def generatePunkSVG(layers)
+  do_call("generatePunkSVG", layers)
+end
+sig "generatePunkSVG", inputs: ["uint256[]"], outputs: ["string"]
+
+#  function **getApproved**(uint256 _) ⇒ (address _) _readonly_
+def getApproved(arg0)
+  do_call("getApproved", arg0)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getAttribute**(uint256 id, uint256 _attributeId) ⇒ (uint256 _) _readonly_
+def getAttribute(id, _attributeId)
+  do_call("getAttribute", id, _attributeId)
+end
+sig "getAttribute", inputs: ["uint256","uint256"], outputs: ["uint256"]
+
+#  function **getAttributeCategories**(uint256 id) ⇒ (uint256[] _) _readonly_
+def getAttributeCategories(id)
+  do_call("getAttributeCategories", id)
+end
+sig "getAttributeCategories", inputs: ["uint256"], outputs: ["uint256[]"]
+
+#  function **getAttributes**(uint256 id) ⇒ (uint256[] _) _readonly_
+def getAttributes(id)
+  do_call("getAttributes", id)
+end
+sig "getAttributes", inputs: ["uint256"], outputs: ["uint256[]"]
+
+#  function **getGender**(uint256 id) ⇒ (enum SyntheticPunks.Gender _) _readonly_
+def getGender(id)
+  do_call("getGender", id)
+end
+sig "getGender", inputs: ["uint256"], outputs: ["uint8"]
+
+#  function **isApprovedForAll**(address _, address _) ⇒ (bool _) _readonly_
+def isApprovedForAll(arg0, arg1)
+  do_call("isApprovedForAll", arg0, arg1)
+end
+sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **ownerOf**(uint256 _) ⇒ (address _) _readonly_
+def ownerOf(arg0)
+  do_call("ownerOf", arg0)
+end
+sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
+
+#  function **randomUint**(uint256 seed, uint256 offset) ⇒ (uint256 _) _readonly_
+def randomUint(seed, offset)
+  do_call("randomUint", seed, offset)
+end
+sig "randomUint", inputs: ["uint256","uint256"], outputs: ["uint256"]
+
+#  function **symbol**() ⇒ (string _) _readonly_
+def symbol()
+  do_call("symbol")
+end
+sig "symbol", outputs: ["string"]
+
+#  function **tokenURI**(uint256 id) ⇒ (string _) _readonly_
+def tokenURI(id)
+  do_call("tokenURI", id)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **withdrawAddress**() ⇒ (address _) _readonly_
+def withdrawAddress()
+  do_call("withdrawAddress")
+end
+sig "withdrawAddress", outputs: ["address"]
+
+
+#  function **getAddress**(uint256 id) ⇒ (address _) _readonly_
+def getAddress(id)
+  do_call("getAddress", id)
+end
+sig "getAddress", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getEthSignedMessageHash**(bytes32 _messageHash) ⇒ (bytes32 _) _readonly_
+def getEthSignedMessageHash(_messageHash)
+  do_call("getEthSignedMessageHash", _messageHash)
+end
+sig "getEthSignedMessageHash", inputs: ["bytes32"], outputs: ["bytes32"]
+
+#  function **getMessageHash**(string _message) ⇒ (bytes32 _) _readonly_
+def getMessageHash(_message)
+  do_call("getMessageHash", _message)
+end
+sig "getMessageHash", inputs: ["string"], outputs: ["bytes32"]
+
+#  function **getTokenID**(address _address) ⇒ (uint256 _) _readonly_
+def getTokenID(_address)
+  do_call("getTokenID", _address)
+end
+sig "getTokenID", inputs: ["address"], outputs: ["uint256"]
+
+#  function **recoverSigner**(bytes32 _ethSignedMessageHash, bytes _signature) ⇒ (address _) _readonly_
+def recoverSigner(_ethSignedMessageHash, _signature)
+  do_call("recoverSigner", _ethSignedMessageHash, _signature)
+end
+sig "recoverSigner", inputs: ["bytes32","bytes"], outputs: ["address"]
+
+#  function **splitSignature**(bytes sig) ⇒ (bytes32 r, bytes32 s, uint8 v) _readonly_
+def splitSignature(sig)
+  do_call("splitSignature", sig)
+end
+sig "splitSignature", inputs: ["bytes"], outputs: ["bytes32","bytes32","uint8"]
+
+#  function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
+def supportsInterface(interfaceId)
+  do_call("supportsInterface", interfaceId)
+end
+sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
+
+#  function **verify**(address _signer, string _message, bytes signature) ⇒ (bool _) _readonly_
+def verify(_signer, _message, signature)
+  do_call("verify", _signer, _message, signature)
+end
+sig "verify", inputs: ["address","string","bytes"], outputs: ["bool"]
+
+end   ## class SynthPunks
+

data/lib/ethlite-contracts.rb

@@ -4,7 +4,7 @@ require 'ethlite'
 
 
 
-## out own code
+## our own code
 
 # shared base contract machinery - keep here
 ##      or rename to Base or such - why? why not?
@@ -13,5 +13,13 @@ require_relative 'ethlite/contract'
 ### generated contracts via abigen
 require_relative 'ethlite/contracts/punks_v1'
 require_relative 'ethlite/contracts/punk_blocks'
-
+require_relative 'ethlite/contracts/punk_meta'
+
+require_relative 'ethlite/contracts/mooncats'
+require_relative 'ethlite/contracts/phunks_v2'
+require_relative 'ethlite/contracts/punks_data'
+require_relative 'ethlite/contracts/synth_punks'
+require_relative 'ethlite/contracts/moonbirds'
+require_relative 'ethlite/contracts/marcs'
+require_relative 'ethlite/contracts/mad_camels'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite-contracts
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-12 00:00:00.000000000 Z
+date: 2023-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethlite
@@ -75,8 +75,16 @@ files:
 - lib/ethlite-contracts.rb
 - lib/ethlite/contract.rb
 - lib/ethlite/contracts.rb
+- lib/ethlite/contracts/mad_camels.rb
+- lib/ethlite/contracts/marcs.rb
+- lib/ethlite/contracts/moonbirds.rb
+- lib/ethlite/contracts/mooncats.rb
+- lib/ethlite/contracts/phunks_v2.rb
 - lib/ethlite/contracts/punk_blocks.rb
+- lib/ethlite/contracts/punks_data.rb
+- lib/ethlite/contracts/punks_meta.rb
 - lib/ethlite/contracts/punks_v1.rb
+- lib/ethlite/contracts/synth_punks.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses:
 - Public Domain