ethlite-contracts 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca6de1c37a18e18603847fb4f34cece9177d8839e561a2e68cf1e772fbe81c81
-  data.tar.gz: 52e07b948256fae1714ac69cf6fa3f3580638c89d41fcfdbbfe9ce84528c45d7
+  metadata.gz: 3ef0b4a37ea13739431d9959ac8509eedbdffe2adad9504f530f62098de2ea44
+  data.tar.gz: 0b559c031eca7bce44b9690b198f661f3774c9b02de0a68e7bc0d70d9c388bfe
 SHA512:
-  metadata.gz: 7132e907281f9bd8efdabd16f337943339315d7406e05fc22f043a605616ea626d6886f9bad87ad089da5bfa6b6116f3d5edf163f69ec86cb957e81898fe5b96
-  data.tar.gz: ff12785374324d102cb92a8ae0a6c52ec2af1d15c8925aab796a07ce9c467adb5572d03d5bb369208ad8a70462387fc2387c6e28577dfe3f14370849471e7557
+  metadata.gz: 3a4e36ab85ac89b933bd2ea63ba0557786384a647a377389d51eb381dbb00fd1413c576f8927883643ee615dc42f822341cc986bd3fe3e661abe5f2e5b7b19a5
+  data.tar.gz: 22531fef29752c98a72fd0491bac7384fab6db6f9b51b9147979b6eba8a79b88800f0be339409363ec20b7cfb4fe57c457abf9ef8ca2f42b5e08afff6abe56df

data/Manifest.txt

@@ -5,5 +5,13 @@ Rakefile
 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

data/Rakefile

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

data/lib/ethlite/contracts/mad_camels.rb

@@ -0,0 +1,199 @@
+# MadCamels contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:56 UTC
+#  - 31 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  MadCamels <  Ethlite::Contract
+
+  address "0xad8474ba5a7f6abc52708f171f57fefc5cdc8c1c"
+
+#  function **allowListPrice**() ⇒ (uint256 _) _readonly_
+def allowListPrice()
+  do_call("allowListPrice")
+end
+sig "allowListPrice", outputs: ["uint256"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **baseURI**() ⇒ (string _) _readonly_
+def baseURI()
+  do_call("baseURI")
+end
+sig "baseURI", outputs: ["string"]
+
+#  function **contractData**() ⇒ (string name, string description, string image, string banner, string website, uint256 royalties, string royaltiesRecipient) _readonly_
+def contractData()
+  do_call("contractData")
+end
+sig "contractData", outputs: ["string","string","string","string","string","uint256","string"]
+
+#  function **contractURI**() ⇒ (string _) _readonly_
+def contractURI()
+  do_call("contractURI")
+end
+sig "contractURI", outputs: ["string"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getLinkedTraits**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (uint256[] _) _readonly_
+def getLinkedTraits(_layerIndex, _traitIndex)
+  do_call("getLinkedTraits", _layerIndex, _traitIndex)
+end
+sig "getLinkedTraits", inputs: ["uint256","uint256"], outputs: ["uint256[]"]
+
+#  function **hashToMetadata**(string _hash) ⇒ (string _) _readonly_
+def hashToMetadata(_hash)
+  do_call("hashToMetadata", _hash)
+end
+sig "hashToMetadata", inputs: ["string"], outputs: ["string"]
+
+#  function **hashToSVG**(string _hash) ⇒ (string _) _readonly_
+def hashToSVG(_hash)
+  do_call("hashToSVG", _hash)
+end
+sig "hashToSVG", inputs: ["string"], outputs: ["string"]
+
+#  function **isAllowListActive**() ⇒ (bool _) _readonly_
+def isAllowListActive()
+  do_call("isAllowListActive")
+end
+sig "isAllowListActive", outputs: ["bool"]
+
+#  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 **isContractSealed**() ⇒ (bool _) _readonly_
+def isContractSealed()
+  do_call("isContractSealed")
+end
+sig "isContractSealed", outputs: ["bool"]
+
+#  function **isMintActive**() ⇒ (bool _) _readonly_
+def isMintActive()
+  do_call("isMintActive")
+end
+sig "isMintActive", outputs: ["bool"]
+
+#  function **isPublicMintActive**() ⇒ (bool _) _readonly_
+def isPublicMintActive()
+  do_call("isPublicMintActive")
+end
+sig "isPublicMintActive", outputs: ["bool"]
+
+#  function **maxPerAddress**() ⇒ (uint256 _) _readonly_
+def maxPerAddress()
+  do_call("maxPerAddress")
+end
+sig "maxPerAddress", outputs: ["uint256"]
+
+#  function **maxPerAllowList**() ⇒ (uint256 _) _readonly_
+def maxPerAllowList()
+  do_call("maxPerAllowList")
+end
+sig "maxPerAllowList", outputs: ["uint256"]
+
+#  function **maxSupply**() ⇒ (uint256 _) _readonly_
+def maxSupply()
+  do_call("maxSupply")
+end
+sig "maxSupply", outputs: ["uint256"]
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **onAllowList**(address addr, bytes32[] merkleProof) ⇒ (bool _) _readonly_
+def onAllowList(addr, merkleProof)
+  do_call("onAllowList", addr, merkleProof)
+end
+sig "onAllowList", inputs: ["address","bytes32[]"], outputs: ["bool"]
+
+#  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 **publicMintPrice**() ⇒ (uint256 _) _readonly_
+def publicMintPrice()
+  do_call("publicMintPrice")
+end
+sig "publicMintPrice", outputs: ["uint256"]
+
+#  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 **tokenIdToHash**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenIdToHash(_tokenId)
+  do_call("tokenIdToHash", _tokenId)
+end
+sig "tokenIdToHash", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokenIdToSVG**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenIdToSVG(_tokenId)
+  do_call("tokenIdToSVG", _tokenId)
+end
+sig "tokenIdToSVG", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenURI(_tokenId)
+  do_call("tokenURI", _tokenId)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokensAreDuplicates**(uint256 tokenIdA, uint256 tokenIdB) ⇒ (bool _) _readonly_
+def tokensAreDuplicates(tokenIdA, tokenIdB)
+  do_call("tokensAreDuplicates", tokenIdA, tokenIdB)
+end
+sig "tokensAreDuplicates", inputs: ["uint256","uint256"], outputs: ["bool"]
+
+#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+def totalSupply()
+  do_call("totalSupply")
+end
+sig "totalSupply", outputs: ["uint256"]
+
+#  function **traitData**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (string _) _readonly_
+def traitData(_layerIndex, _traitIndex)
+  do_call("traitData", _layerIndex, _traitIndex)
+end
+sig "traitData", inputs: ["uint256","uint256"], outputs: ["string"]
+
+#  function **traitDetails**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (struct Indelible.Trait _) _readonly_
+def traitDetails(_layerIndex, _traitIndex)
+  do_call("traitDetails", _layerIndex, _traitIndex)
+end
+sig "traitDetails", inputs: ["uint256","uint256"], outputs: ["(string,string)"]
+
+end   ## class MadCamels
+

data/lib/ethlite/contracts/marcs.rb

@@ -0,0 +1,199 @@
+# Marcs contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:53 UTC
+#  - 31 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  Marcs <  Ethlite::Contract
+
+  address "0xe9b91d537c3aa5a3fa87275fbd2e4feaaed69bd0"
+
+#  function **allowListPrice**() ⇒ (uint256 _) _readonly_
+def allowListPrice()
+  do_call("allowListPrice")
+end
+sig "allowListPrice", outputs: ["uint256"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **baseURI**() ⇒ (string _) _readonly_
+def baseURI()
+  do_call("baseURI")
+end
+sig "baseURI", outputs: ["string"]
+
+#  function **contractData**() ⇒ (string name, string description, string image, string banner, string website, uint256 royalties, string royaltiesRecipient) _readonly_
+def contractData()
+  do_call("contractData")
+end
+sig "contractData", outputs: ["string","string","string","string","string","uint256","string"]
+
+#  function **contractURI**() ⇒ (string _) _readonly_
+def contractURI()
+  do_call("contractURI")
+end
+sig "contractURI", outputs: ["string"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **hashToMetadata**(string _hash) ⇒ (string _) _readonly_
+def hashToMetadata(_hash)
+  do_call("hashToMetadata", _hash)
+end
+sig "hashToMetadata", inputs: ["string"], outputs: ["string"]
+
+#  function **hashToSVG**(string _hash) ⇒ (string _) _readonly_
+def hashToSVG(_hash)
+  do_call("hashToSVG", _hash)
+end
+sig "hashToSVG", inputs: ["string"], outputs: ["string"]
+
+#  function **isAllowListActive**() ⇒ (bool _) _readonly_
+def isAllowListActive()
+  do_call("isAllowListActive")
+end
+sig "isAllowListActive", outputs: ["bool"]
+
+#  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 **isContractSealed**() ⇒ (bool _) _readonly_
+def isContractSealed()
+  do_call("isContractSealed")
+end
+sig "isContractSealed", outputs: ["bool"]
+
+#  function **isMintActive**() ⇒ (bool _) _readonly_
+def isMintActive()
+  do_call("isMintActive")
+end
+sig "isMintActive", outputs: ["bool"]
+
+#  function **isPublicMintActive**() ⇒ (bool _) _readonly_
+def isPublicMintActive()
+  do_call("isPublicMintActive")
+end
+sig "isPublicMintActive", outputs: ["bool"]
+
+#  function **maxPerAddress**() ⇒ (uint256 _) _readonly_
+def maxPerAddress()
+  do_call("maxPerAddress")
+end
+sig "maxPerAddress", outputs: ["uint256"]
+
+#  function **maxPerAllowList**() ⇒ (uint256 _) _readonly_
+def maxPerAllowList()
+  do_call("maxPerAllowList")
+end
+sig "maxPerAllowList", outputs: ["uint256"]
+
+#  function **maxSupply**() ⇒ (uint256 _) _readonly_
+def maxSupply()
+  do_call("maxSupply")
+end
+sig "maxSupply", outputs: ["uint256"]
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **ockAddress**() ⇒ (address _) _readonly_
+def ockAddress()
+  do_call("ockAddress")
+end
+sig "ockAddress", outputs: ["address"]
+
+#  function **onAllowList**(address addr, bytes32[] merkleProof) ⇒ (bool _) _readonly_
+def onAllowList(addr, merkleProof)
+  do_call("onAllowList", addr, merkleProof)
+end
+sig "onAllowList", inputs: ["address","bytes32[]"], outputs: ["bool"]
+
+#  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 **publicMintPrice**() ⇒ (uint256 _) _readonly_
+def publicMintPrice()
+  do_call("publicMintPrice")
+end
+sig "publicMintPrice", outputs: ["uint256"]
+
+#  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 **tokenIdToHash**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenIdToHash(_tokenId)
+  do_call("tokenIdToHash", _tokenId)
+end
+sig "tokenIdToHash", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokenIdToSVG**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenIdToSVG(_tokenId)
+  do_call("tokenIdToSVG", _tokenId)
+end
+sig "tokenIdToSVG", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
+def tokenURI(_tokenId)
+  do_call("tokenURI", _tokenId)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **tokensAreDuplicates**(uint256 tokenId1, uint256 tokenId2) ⇒ (bool _) _readonly_
+def tokensAreDuplicates(tokenId1, tokenId2)
+  do_call("tokensAreDuplicates", tokenId1, tokenId2)
+end
+sig "tokensAreDuplicates", inputs: ["uint256","uint256"], outputs: ["bool"]
+
+#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+def totalSupply()
+  do_call("totalSupply")
+end
+sig "totalSupply", outputs: ["uint256"]
+
+#  function **traitData**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (string _) _readonly_
+def traitData(_layerIndex, _traitIndex)
+  do_call("traitData", _layerIndex, _traitIndex)
+end
+sig "traitData", inputs: ["uint256","uint256"], outputs: ["string"]
+
+#  function **traitDetails**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (struct IndelibleERC721A.Trait _) _readonly_
+def traitDetails(_layerIndex, _traitIndex)
+  do_call("traitDetails", _layerIndex, _traitIndex)
+end
+sig "traitDetails", inputs: ["uint256","uint256"], outputs: ["(string,string)"]
+
+end   ## class Marcs
+

data/lib/ethlite/contracts/moonbirds.rb

@@ -0,0 +1,211 @@
+# Moonbirds contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:51 UTC
+#  - 33 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  Moonbirds <  Ethlite::Contract
+
+  address "0x23581767a106ae21c074b2276d25e5c3e136a68b"
+
+#  function **DEFAULT_ADMIN_ROLE**() ⇒ (bytes32 _) _readonly_
+def DEFAULT_ADMIN_ROLE()
+  do_call("DEFAULT_ADMIN_ROLE")
+end
+sig "DEFAULT_ADMIN_ROLE", outputs: ["bytes32"]
+
+#  function **EXPULSION_ROLE**() ⇒ (bytes32 _) _readonly_
+def EXPULSION_ROLE()
+  do_call("EXPULSION_ROLE")
+end
+sig "EXPULSION_ROLE", outputs: ["bytes32"]
+
+#  function **alreadyMinted**(address to, bytes32 nonce) ⇒ (bool _) _readonly_
+def alreadyMinted(to, nonce)
+  do_call("alreadyMinted", to, nonce)
+end
+sig "alreadyMinted", inputs: ["address","bytes32"], outputs: ["bool"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **baseTokenURI**() ⇒ (string _) _readonly_
+def baseTokenURI()
+  do_call("baseTokenURI")
+end
+sig "baseTokenURI", outputs: ["string"]
+
+#  function **beneficiary**() ⇒ (address payable _) _readonly_
+def beneficiary()
+  do_call("beneficiary")
+end
+sig "beneficiary", outputs: ["address"]
+
+#  function **cost**(uint256 n, uint256 _) ⇒ (uint256 _) _readonly_
+def cost(n, arg1)
+  do_call("cost", n, arg1)
+end
+sig "cost", inputs: ["uint256","uint256"], outputs: ["uint256"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getRoleAdmin**(bytes32 role) ⇒ (bytes32 _) _readonly_
+def getRoleAdmin(role)
+  do_call("getRoleAdmin", role)
+end
+sig "getRoleAdmin", inputs: ["bytes32"], outputs: ["bytes32"]
+
+#  function **getRoleMember**(bytes32 role, uint256 index) ⇒ (address _) _readonly_
+def getRoleMember(role, index)
+  do_call("getRoleMember", role, index)
+end
+sig "getRoleMember", inputs: ["bytes32","uint256"], outputs: ["address"]
+
+#  function **getRoleMemberCount**(bytes32 role) ⇒ (uint256 _) _readonly_
+def getRoleMemberCount(role)
+  do_call("getRoleMemberCount", role)
+end
+sig "getRoleMemberCount", inputs: ["bytes32"], outputs: ["uint256"]
+
+#  function **hasRole**(bytes32 role, address account) ⇒ (bool _) _readonly_
+def hasRole(role, account)
+  do_call("hasRole", role, account)
+end
+sig "hasRole", inputs: ["bytes32","address"], outputs: ["bool"]
+
+#  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 **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **nestingOpen**() ⇒ (bool _) _readonly_
+def nestingOpen()
+  do_call("nestingOpen")
+end
+sig "nestingOpen", outputs: ["bool"]
+
+#  function **nestingPeriod**(uint256 tokenId) ⇒ (bool nesting, uint256 current, uint256 total) _readonly_
+def nestingPeriod(tokenId)
+  do_call("nestingPeriod", tokenId)
+end
+sig "nestingPeriod", inputs: ["uint256"], outputs: ["bool","uint256","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 **paused**() ⇒ (bool _) _readonly_
+def paused()
+  do_call("paused")
+end
+sig "paused", outputs: ["bool"]
+
+#  function **price**() ⇒ (uint256 _) _readonly_
+def price()
+  do_call("price")
+end
+sig "price", outputs: ["uint256"]
+
+#  function **proof**() ⇒ (contract IERC721 _) _readonly_
+def proof()
+  do_call("proof")
+end
+sig "proof", outputs: ["address"]
+
+#  function **proofClaimsRemaining**(uint256 tokenId) ⇒ (uint256 _) _readonly_
+def proofClaimsRemaining(tokenId)
+  do_call("proofClaimsRemaining", tokenId)
+end
+sig "proofClaimsRemaining", inputs: ["uint256"], outputs: ["uint256"]
+
+#  function **proofMintingOpen**() ⇒ (bool _) _readonly_
+def proofMintingOpen()
+  do_call("proofMintingOpen")
+end
+sig "proofMintingOpen", outputs: ["bool"]
+
+#  function **proofPoolRemaining**() ⇒ (uint256 _) _readonly_
+def proofPoolRemaining()
+  do_call("proofPoolRemaining")
+end
+sig "proofPoolRemaining", outputs: ["uint256"]
+
+#  function **renderingContract**() ⇒ (contract ITokenURIGenerator _) _readonly_
+def renderingContract()
+  do_call("renderingContract")
+end
+sig "renderingContract", outputs: ["address"]
+
+#  function **royaltyInfo**(uint256 _tokenId, uint256 _salePrice) ⇒ (address _, uint256 _) _readonly_
+def royaltyInfo(_tokenId, _salePrice)
+  do_call("royaltyInfo", _tokenId, _salePrice)
+end
+sig "royaltyInfo", inputs: ["uint256","uint256"], outputs: ["address","uint256"]
+
+#  function **sellerConfig**() ⇒ (uint256 totalInventory, uint256 maxPerAddress, uint256 maxPerTx, uint248 freeQuota, bool reserveFreeQuota, bool lockFreeQuota, bool lockTotalInventory) _readonly_
+def sellerConfig()
+  do_call("sellerConfig")
+end
+sig "sellerConfig", outputs: ["uint256","uint256","uint256","uint248","bool","bool","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 **tokenURI**(uint256 tokenId) ⇒ (string _) _readonly_
+def tokenURI(tokenId)
+  do_call("tokenURI", tokenId)
+end
+sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **totalSold**() ⇒ (uint256 _) _readonly_
+def totalSold()
+  do_call("totalSold")
+end
+sig "totalSold", outputs: ["uint256"]
+
+#  function **totalSupply**() ⇒ (uint256 _) _readonly_
+def totalSupply()
+  do_call("totalSupply")
+end
+sig "totalSupply", outputs: ["uint256"]
+
+#  function **usedMessages**(bytes32 _) ⇒ (bool _) _readonly_
+def usedMessages(arg0)
+  do_call("usedMessages", arg0)
+end
+sig "usedMessages", inputs: ["bytes32"], outputs: ["bool"]
+
+end   ## class Moonbirds
+

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,7 +1,8 @@
-#########################
 # PunkBlocks contract / (blockchain) services / function calls
-#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-13 15:31:38 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!

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
+

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,7 +1,8 @@
-#########################
 # PunksV1 contract / (blockchain) services / function calls
-#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-13 15:31:37 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/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/punks_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.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-13 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