ethlite-contracts 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90a5da8f2e9e8abbfc97d576c29c7e17f8215df0dc1900182dc18235931ef89e
-  data.tar.gz: 4951c60b51a16136b2dbb0e73c01dd2a8a47ea69c34e59f4d411660ae58ccec7
+  metadata.gz: c38d59d6529247e37f709720a7d5d4b699eebf0f4f83d2ec1c095e6d62672dfe
+  data.tar.gz: d4153da09c7191dcfa95c8ae05697b7c136c5e65c1a2eaf1d5f9b77cb8a5e962
 SHA512:
-  metadata.gz: 6ff8e3aa22de5f85f2569199813499c78f02731d66c8d0e4813ea546fea402d808ac97ca4bb7e5bf3e7804e0c63751d6909b5b3230e994319e8894b9e152edda
-  data.tar.gz: 0bdc6e1f5e5d7065676e97041f067f8ce58624567daf14b0f5e3a4272dc93964b3e934041962408c8bfba21bdece4431aec6c7902e3eb0e8da694e400ec9e6d7
+  metadata.gz: 9ca5826c5e7e9f80cdb45cbe489e159970553e6d50b03e93f90636507a1599358e5fa39ce479bb7193912883a51c79701158672426173dce574f69f8035982da
+  data.tar.gz: 1ebcbfa74d46fade327ec0e9a24131f165b224dfb2d889af99be48b01849fe8fd618b969570e80f7e96999392a7d9d4fa55b5b8be15296d513932208d8421c1c

data/Manifest.txt

@@ -9,9 +9,15 @@ lib/ethlite/contracts/mad_camels.rb
 lib/ethlite/contracts/marcs.rb
 lib/ethlite/contracts/moonbirds.rb
 lib/ethlite/contracts/mooncats.rb
+lib/ethlite/contracts/nouns.rb
+lib/ethlite/contracts/nouns_auction_house.rb
+lib/ethlite/contracts/nouns_descriptor.rb
+lib/ethlite/contracts/nouns_descriptor_v2.rb
+lib/ethlite/contracts/nouns_seeder.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_nouns.rb
 lib/ethlite/contracts/synth_punks.rb

data/README.md

@@ -11,9 +11,267 @@ ethlite-contracts  - ready-to-use (blockchain) contract services / function call
 
 
 
-## Usage
+## Usage by Example
+
+
+### Contract №1 - Nouns, NounsSeeder, NounsDescriptor, NounsDescriptorV2
+
+Let's try the `Nouns` contract
+with  the token id 1, that is, noun no. 1:
+
+``` ruby
+require 'ethlite/contracts'
+
+
+contract = Nouns.new
+
+contract.totalSupply    # as of Jan/16, 2023
+#=> 580
+
+token_ids = [1,2,3]
+token_ids.each do |token_id|
+  pp seeds = contract.seeds( token_id )
+  #=> [1, 20, 95, 88, 14]
+  #  for background, body, accessory, head, glasses
+
+  str = contract.tokenURI( token_id )
+  if str.start_with?( 'data:application/json;base64,' )
+    str = str.sub( 'data:application/json;base64,', '' )
+    ## get metadata (base64-encoded)
+    data = JSON.parse( Base64.decode64( str ) )
+    pp data
+#=>  {"name"=>"Noun 1",
+#      "description"=>"Noun 1 is a member of the Nouns DAO",
+#      "image"=> "data:image/svg+xml;base64..."
+#     }
+    str_image = data.delete( 'image' )
+    str_image = str_image.sub( 'data:image/svg+xml;base64,', '' )
+    image = Base64.decode64( str_image )
+    write_text( "./tmp/noun#{token_id}.svg", image )
+  else
+    puts "!! ERROR - expected json base64-encoded; got:"
+    pp str
+    exit 1
+  end
+end
+
+
+contract.seeder
+#=> "cc8a0fb5ab3c7132c1b2a0109142fb112c4ce515"
+
+contract.descriptor
+#=> "6229c811d04501523c6058bfaac29c91bb586268"
+```
+
+Note:  See [`nouns/noun1.svg`](nouns/noun1.svg),
+[`nouns/noun2.svg`](nouns/noun2.svg),
+etc. for the saved copies of the ("on-chain") image data.
+
+
+Let's try the `NounsSeeder` contract
+that returns the pseudo-random seeds for a noun.
+Note - the formula uses the blockhash - 1, and, thus,
+is only deterministic, that is, returns the same seeds - if called within the same block:
+
+
+``` ruby
+contract = NounsSeeder.new
+
+# using the address of NounsDescriptor
+contract.generateSeed( 1, '0x0cfdb3ba1694c2bb2cfacb0339ad7b1ae5932b63' )
+#=> [1, 15, 54, 48, 16]
+#      for background, body, accessory, head, glasses
+
+
+# using the address of NounsDescriptorV2
+contract.generateSeed( 579, '0x6229c811d04501523c6058bfaac29c91bb586268' )
+#=> [0, 25, 83, 99, 9]
+contract.generateSeed( 579, '0x6229c811d04501523c6058bfaac29c91bb586268' )
+#=> [0, 25, 83, 99, 9]
+```
+
+Let's try the `NounsDescriptor` and
+`NounsDescriptorV2` contracts and get the max available
+artwork counts:
+
+``` ruby
+contract = NounsDescriptor.new
+
+contract.backgroundCount    #=> 2
+contract.bodyCount          #=> 30
+contract.accessoryCount     #=> 137
+contract.headCount          #=> 234
+contract.glassesCount       #=> 21
+
+contract = NounsDescriptorV2.new
+
+contract.backgroundCount   #=> 2
+contract.bodyCount         #=> 30
+contract.accessoryCount    #=> 140
+contract.headCount         #=> 242
+contract.glassesCount      #=> 23
+```
+
+And lets generate some more nouns via seeds
+using the `NounsDescriptorV2` contract:
+
+``` ruby
+seeds = [1, 20, 95, 88, 14]
+#    for background, body, accessory, head, glasses
+str = contract.generateSVGImage( seeds )
+svg = Base64.decode64( str )
+write_text( "nouns/noun_#{seeds.join('-')}.svg", svg )
+```
+
+
+
+
+### Contract №2 - SynthPunks
+
+Let's try the `SynthPunks` contract that lets you generate
+punks for every ethereum address. Note - the punk token id is
+the ethereum address converted into a (big) integer number:
+
+
+``` ruby
+contract  = SynthPunks.new
+
+## let's add "pure ruby" helper
+##  convert hex string (that is, address) to (big) integer
+def getTokenID( address ) address.to_i( 16 ); end
+
+getTokenID( '0x71c7656ec7ab88b098defb751b7401b5f6d8976f' )
+#=> 649562641434947955654834859981556155081347864431
+getTokenID( '0x0000000000000000000000000000000000000000' )
+#=> 0
+
+
+
+token_ids = [
+  30311890011735557186986086868537068337617285922,
+  699372119169819039191610289391678040975564001026,
+  getTokenID( '0x71c7656ec7ab88b098defb751b7401b5f6d8976f' ),
+]
+
+token_ids.each do |token_id|
+  contract.getAttributes( token_id )
+end
+#=> [6,20,109,114,14]
+#=> [0,12,65,124,41]
+#=> [7,27,15]
+
+[
+ [6,20,109,114,14],
+ [0,12,65,124,41],
+ [7,27,15],
+].each do |attributes|
+  svg = contract.generatePunkSVG( attributes )
+  write_text( "synthpunks/punk_#{attributes.join('-')}.svg", svg )
+end
+
+
+token_ids.each do |token_id|
+  str = contract.tokenURI( token_id )
+  if str.start_with?( 'data:application/json;base64,' )
+     str = str.sub( 'data:application/json;base64,', '' )
+     data = JSON.parse( Base64.decode64( str ) )
+     ## extract image
+     ##  "image"=> "data:image/svg+xml;base64
+     str_image = data.delete( 'image' )
+     str_image = str_image.sub( 'data:image/svg+xml;base64,', '' )
+     image = Base64.decode64( str_image )
+
+     write_json( "synthpunks/punk#{token_id}.json", data )
+     write_text( "synthpunks/punk#{token_id}.svg", image )
+  else
+    puts "!! ERROR - expected json base64-encoded; got:"
+    pp str
+    exit 1
+  end
+end
+```
+
+
+
+
+### Contract №3 - PunksMeta  (aka CryptoPunksTokenUri)  by 0xTycoon
+
+_The missing tokenURI() for the Punks_
+
+
+Let's try the `PunksMeta` contract
+with  the token id 0, that is, punk no. 0:
+
+``` ruby
+contract = PunksMeta.new
+
+
+#  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
+ary = contract.parseAttributes( 0 )
+#=> ["Female 2", "Earring", "Blonde Bob", "Green Eye Shadow", "", "", "", ""]
+
+
+#  function getAttributes(uint256 _tokenId) returns (string)
+#
+#  getAttributes calls parseAttributes and returns the result as JSON
+#    @param _tokenId the punk id
+str = contract.getAttributes( 0 )
+data = JSON.parse( str )
+#=> [{"trait_type"=>"Type", "value"=>"Female 2"},
+#    {"trait_type"=>"Accessory", "value"=>"Earring"},
+#    {"trait_type"=>"Accessory", "value"=>"Blonde Bob"},
+#    {"trait_type"=>"Accessory", "value"=>"Green Eye Shadow"}]
+
+
+#  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
+str = contract.tokenURI( 0 )
+if str.start_with?( 'data:application/json;base64,' )
+  str = str.sub( 'data:application/json;base64,', '' )
+  ## get metadata (base64-encoded)
+  data = JSON.parse( Base64.decode64( str ) )
+#=> {"description"=> "CryptoPunks launched as a fixed set of 10,000 items in mid-2017...",
+#    "external_url"=>"https://cryptopunks.app/cryptopunks/details/0",
+#    "image"=> "data:image/svg+xml;base64,...",
+#    "name"=>"CryptoPunk #0",
+#    "attributes"=>
+#      [{"trait_type"=>"Type", "value"=>"Female 2"},
+#       {"trait_type"=>"Accessory", "value"=>"Earring"},
+#       {"trait_type"=>"Accessory", "value"=>"Blonde Bob"},
+#       {"trait_type"=>"Accessory", "value"=>"Green Eye Shadow"}]}
+
+      ## get image (base64-encoded)
+      str_image = data.delete( 'image' )
+      str_image = str_image.sub( 'data:image/svg+xml;base64,', '' )
+      image = Base64.decode64( str_image )
+      ## cut-off inline leading data:image/svg+xml;utf8, too
+      image = image.sub( 'data:image/svg+xml;utf8,', '' )
+
+      write_json( "punksmeta/punk0.json", data )
+      write_text( "punksmeta/punk0.svg", image )
+   else
+     puts "!! ERROR - expected json base64-encoded; got:"
+     pp str
+     exit 1
+   end
+end
+```
+
+Note:  See [`punksmeta/punk0.json`](punksmeta/punk0.json)
+and [`punksmeta/punk0.svg`](punksmeta/punk0.svg) for the saved copies of the "on-chain" data.
 
-To be done
 
 
 

data/Rakefile

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

data/lib/ethlite/contracts/nouns.rb

@@ -0,0 +1,211 @@
+# Nouns contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:12 UTC
+#  - 33 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  Nouns <  Ethlite::Contract
+
+  address "0x9c8ff314c9bc7f6e59a9d9225fb22946427edc03"
+
+#  function **DELEGATION_TYPEHASH**() ⇒ (bytes32 _) _readonly_
+def DELEGATION_TYPEHASH()
+  do_call("DELEGATION_TYPEHASH")
+end
+sig "DELEGATION_TYPEHASH", outputs: ["bytes32"]
+
+#  function **DOMAIN_TYPEHASH**() ⇒ (bytes32 _) _readonly_
+def DOMAIN_TYPEHASH()
+  do_call("DOMAIN_TYPEHASH")
+end
+sig "DOMAIN_TYPEHASH", outputs: ["bytes32"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **checkpoints**(address _, uint32 _) ⇒ (uint32 fromBlock, uint96 votes) _readonly_
+def checkpoints(arg0, arg1)
+  do_call("checkpoints", arg0, arg1)
+end
+sig "checkpoints", inputs: ["address","uint32"], outputs: ["uint32","uint96"]
+
+#  function **contractURI**() ⇒ (string _) _readonly_
+def contractURI()
+  do_call("contractURI")
+end
+sig "contractURI", outputs: ["string"]
+
+#  function **dataURI**(uint256 tokenId) ⇒ (string _) _readonly_
+def dataURI(tokenId)
+  do_call("dataURI", tokenId)
+end
+sig "dataURI", inputs: ["uint256"], outputs: ["string"]
+
+#  function **decimals**() ⇒ (uint8 _) _readonly_
+def decimals()
+  do_call("decimals")
+end
+sig "decimals", outputs: ["uint8"]
+
+#  function **delegates**(address delegator) ⇒ (address _) _readonly_
+def delegates(delegator)
+  do_call("delegates", delegator)
+end
+sig "delegates", inputs: ["address"], outputs: ["address"]
+
+#  function **descriptor**() ⇒ (contract INounsDescriptor _) _readonly_
+def descriptor()
+  do_call("descriptor")
+end
+sig "descriptor", outputs: ["address"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  function **getCurrentVotes**(address account) ⇒ (uint96 _) _readonly_
+def getCurrentVotes(account)
+  do_call("getCurrentVotes", account)
+end
+sig "getCurrentVotes", inputs: ["address"], outputs: ["uint96"]
+
+#  function **getPriorVotes**(address account, uint256 blockNumber) ⇒ (uint96 _) _readonly_
+def getPriorVotes(account, blockNumber)
+  do_call("getPriorVotes", account, blockNumber)
+end
+sig "getPriorVotes", inputs: ["address","uint256"], outputs: ["uint96"]
+
+#  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 **isDescriptorLocked**() ⇒ (bool _) _readonly_
+def isDescriptorLocked()
+  do_call("isDescriptorLocked")
+end
+sig "isDescriptorLocked", outputs: ["bool"]
+
+#  function **isMinterLocked**() ⇒ (bool _) _readonly_
+def isMinterLocked()
+  do_call("isMinterLocked")
+end
+sig "isMinterLocked", outputs: ["bool"]
+
+#  function **isSeederLocked**() ⇒ (bool _) _readonly_
+def isSeederLocked()
+  do_call("isSeederLocked")
+end
+sig "isSeederLocked", outputs: ["bool"]
+
+#  function **minter**() ⇒ (address _) _readonly_
+def minter()
+  do_call("minter")
+end
+sig "minter", outputs: ["address"]
+
+#  function **name**() ⇒ (string _) _readonly_
+def name()
+  do_call("name")
+end
+sig "name", outputs: ["string"]
+
+#  function **nonces**(address _) ⇒ (uint256 _) _readonly_
+def nonces(arg0)
+  do_call("nonces", arg0)
+end
+sig "nonces", inputs: ["address"], outputs: ["uint256"]
+
+#  function **noundersDAO**() ⇒ (address _) _readonly_
+def noundersDAO()
+  do_call("noundersDAO")
+end
+sig "noundersDAO", outputs: ["address"]
+
+#  function **numCheckpoints**(address _) ⇒ (uint32 _) _readonly_
+def numCheckpoints(arg0)
+  do_call("numCheckpoints", arg0)
+end
+sig "numCheckpoints", inputs: ["address"], outputs: ["uint32"]
+
+#  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 **proxyRegistry**() ⇒ (contract IProxyRegistry _) _readonly_
+def proxyRegistry()
+  do_call("proxyRegistry")
+end
+sig "proxyRegistry", outputs: ["address"]
+
+#  function **seeder**() ⇒ (contract INounsSeeder _) _readonly_
+def seeder()
+  do_call("seeder")
+end
+sig "seeder", outputs: ["address"]
+
+#  function **seeds**(uint256 _) ⇒ (uint48 background, uint48 body, uint48 accessory, uint48 head, uint48 glasses) _readonly_
+def seeds(arg0)
+  do_call("seeds", arg0)
+end
+sig "seeds", inputs: ["uint256"], outputs: ["uint48","uint48","uint48","uint48","uint48"]
+
+#  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"]
+
+#  function **votesToDelegate**(address delegator) ⇒ (uint96 _) _readonly_
+def votesToDelegate(delegator)
+  do_call("votesToDelegate", delegator)
+end
+sig "votesToDelegate", inputs: ["address"], outputs: ["uint96"]
+
+end   ## class Nouns
+

data/lib/ethlite/contracts/nouns_auction_house.rb

@@ -0,0 +1,67 @@
+# NounsAuctionHouse contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:13 UTC
+#  - 9 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  NounsAuctionHouse <  Ethlite::Contract
+
+  address "0xf15a943787014461d94da08ad4040f79cd7c124e"
+
+#  function **auction**() ⇒ (uint256 nounId, uint256 amount, uint256 startTime, uint256 endTime, address payable bidder, bool settled) _readonly_
+def auction()
+  do_call("auction")
+end
+sig "auction", outputs: ["uint256","uint256","uint256","uint256","address","bool"]
+
+#  function **duration**() ⇒ (uint256 _) _readonly_
+def duration()
+  do_call("duration")
+end
+sig "duration", outputs: ["uint256"]
+
+#  function **minBidIncrementPercentage**() ⇒ (uint8 _) _readonly_
+def minBidIncrementPercentage()
+  do_call("minBidIncrementPercentage")
+end
+sig "minBidIncrementPercentage", outputs: ["uint8"]
+
+#  function **nouns**() ⇒ (contract INounsToken _) _readonly_
+def nouns()
+  do_call("nouns")
+end
+sig "nouns", outputs: ["address"]
+
+#  function **owner**() ⇒ (address _) _readonly_
+def owner()
+  do_call("owner")
+end
+sig "owner", outputs: ["address"]
+
+#  function **paused**() ⇒ (bool _) _readonly_
+def paused()
+  do_call("paused")
+end
+sig "paused", outputs: ["bool"]
+
+#  function **reservePrice**() ⇒ (uint256 _) _readonly_
+def reservePrice()
+  do_call("reservePrice")
+end
+sig "reservePrice", outputs: ["uint256"]
+
+#  function **timeBuffer**() ⇒ (uint256 _) _readonly_
+def timeBuffer()
+  do_call("timeBuffer")
+end
+sig "timeBuffer", outputs: ["uint256"]
+
+#  function **weth**() ⇒ (address _) _readonly_
+def weth()
+  do_call("weth")
+end
+sig "weth", outputs: ["address"]
+
+end   ## class NounsAuctionHouse
+

data/lib/ethlite/contracts/nouns_descriptor.rb

@@ -0,0 +1,127 @@
+# NounsDescriptor contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:10 UTC
+#  - 19 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  NounsDescriptor <  Ethlite::Contract
+
+  address "0x0cfdb3ba1694c2bb2cfacb0339ad7b1ae5932b63"
+
+#  function **accessories**(uint256 _) ⇒ (bytes _) _readonly_
+def accessories(arg0)
+  do_call("accessories", arg0)
+end
+sig "accessories", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **accessoryCount**() ⇒ (uint256 _) _readonly_
+def accessoryCount()
+  do_call("accessoryCount")
+end
+sig "accessoryCount", outputs: ["uint256"]
+
+#  function **arePartsLocked**() ⇒ (bool _) _readonly_
+def arePartsLocked()
+  do_call("arePartsLocked")
+end
+sig "arePartsLocked", outputs: ["bool"]
+
+#  function **backgroundCount**() ⇒ (uint256 _) _readonly_
+def backgroundCount()
+  do_call("backgroundCount")
+end
+sig "backgroundCount", outputs: ["uint256"]
+
+#  function **backgrounds**(uint256 _) ⇒ (string _) _readonly_
+def backgrounds(arg0)
+  do_call("backgrounds", arg0)
+end
+sig "backgrounds", inputs: ["uint256"], outputs: ["string"]
+
+#  function **baseURI**() ⇒ (string _) _readonly_
+def baseURI()
+  do_call("baseURI")
+end
+sig "baseURI", outputs: ["string"]
+
+#  function **bodies**(uint256 _) ⇒ (bytes _) _readonly_
+def bodies(arg0)
+  do_call("bodies", arg0)
+end
+sig "bodies", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **bodyCount**() ⇒ (uint256 _) _readonly_
+def bodyCount()
+  do_call("bodyCount")
+end
+sig "bodyCount", outputs: ["uint256"]
+
+#  function **dataURI**(uint256 tokenId, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def dataURI(tokenId, seed)
+  do_call("dataURI", tokenId, seed)
+end
+sig "dataURI", inputs: ["uint256","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **generateSVGImage**(struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def generateSVGImage(seed)
+  do_call("generateSVGImage", seed)
+end
+sig "generateSVGImage", inputs: ["(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **genericDataURI**(string name, string description, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def genericDataURI(name, description, seed)
+  do_call("genericDataURI", name, description, seed)
+end
+sig "genericDataURI", inputs: ["string","string","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **glasses**(uint256 _) ⇒ (bytes _) _readonly_
+def glasses(arg0)
+  do_call("glasses", arg0)
+end
+sig "glasses", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **glassesCount**() ⇒ (uint256 _) _readonly_
+def glassesCount()
+  do_call("glassesCount")
+end
+sig "glassesCount", outputs: ["uint256"]
+
+#  function **headCount**() ⇒ (uint256 _) _readonly_
+def headCount()
+  do_call("headCount")
+end
+sig "headCount", outputs: ["uint256"]
+
+#  function **heads**(uint256 _) ⇒ (bytes _) _readonly_
+def heads(arg0)
+  do_call("heads", arg0)
+end
+sig "heads", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **isDataURIEnabled**() ⇒ (bool _) _readonly_
+def isDataURIEnabled()
+  do_call("isDataURIEnabled")
+end
+sig "isDataURIEnabled", outputs: ["bool"]
+
+#  function **owner**() ⇒ (address _) _readonly_
+def owner()
+  do_call("owner")
+end
+sig "owner", outputs: ["address"]
+
+#  function **palettes**(uint8 _, uint256 _) ⇒ (string _) _readonly_
+def palettes(arg0, arg1)
+  do_call("palettes", arg0, arg1)
+end
+sig "palettes", inputs: ["uint8","uint256"], outputs: ["string"]
+
+#  function **tokenURI**(uint256 tokenId, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def tokenURI(tokenId, seed)
+  do_call("tokenURI", tokenId, seed)
+end
+sig "tokenURI", inputs: ["uint256","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+end   ## class NounsDescriptor
+

data/lib/ethlite/contracts/nouns_descriptor_v2.rb

@@ -0,0 +1,145 @@
+# NounsDescriptorV2 contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:16 UTC
+#  - 22 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  NounsDescriptorV2 <  Ethlite::Contract
+
+  address "0x6229c811d04501523c6058bfaac29c91bb586268"
+
+#  function **accessories**(uint256 index) ⇒ (bytes _) _readonly_
+def accessories(index)
+  do_call("accessories", index)
+end
+sig "accessories", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **accessoryCount**() ⇒ (uint256 _) _readonly_
+def accessoryCount()
+  do_call("accessoryCount")
+end
+sig "accessoryCount", outputs: ["uint256"]
+
+#  function **arePartsLocked**() ⇒ (bool _) _readonly_
+def arePartsLocked()
+  do_call("arePartsLocked")
+end
+sig "arePartsLocked", outputs: ["bool"]
+
+#  function **art**() ⇒ (contract INounsArt _) _readonly_
+def art()
+  do_call("art")
+end
+sig "art", outputs: ["address"]
+
+#  function **backgroundCount**() ⇒ (uint256 _) _readonly_
+def backgroundCount()
+  do_call("backgroundCount")
+end
+sig "backgroundCount", outputs: ["uint256"]
+
+#  function **backgrounds**(uint256 index) ⇒ (string _) _readonly_
+def backgrounds(index)
+  do_call("backgrounds", index)
+end
+sig "backgrounds", inputs: ["uint256"], outputs: ["string"]
+
+#  function **baseURI**() ⇒ (string _) _readonly_
+def baseURI()
+  do_call("baseURI")
+end
+sig "baseURI", outputs: ["string"]
+
+#  function **bodies**(uint256 index) ⇒ (bytes _) _readonly_
+def bodies(index)
+  do_call("bodies", index)
+end
+sig "bodies", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **bodyCount**() ⇒ (uint256 _) _readonly_
+def bodyCount()
+  do_call("bodyCount")
+end
+sig "bodyCount", outputs: ["uint256"]
+
+#  function **dataURI**(uint256 tokenId, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def dataURI(tokenId, seed)
+  do_call("dataURI", tokenId, seed)
+end
+sig "dataURI", inputs: ["uint256","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **generateSVGImage**(struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def generateSVGImage(seed)
+  do_call("generateSVGImage", seed)
+end
+sig "generateSVGImage", inputs: ["(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **genericDataURI**(string name, string description, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def genericDataURI(name, description, seed)
+  do_call("genericDataURI", name, description, seed)
+end
+sig "genericDataURI", inputs: ["string","string","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+#  function **getPartsForSeed**(struct INounsSeeder.Seed seed) ⇒ (struct ISVGRenderer.Part[] _) _readonly_
+def getPartsForSeed(seed)
+  do_call("getPartsForSeed", seed)
+end
+sig "getPartsForSeed", inputs: ["(uint48,uint48,uint48,uint48,uint48)"], outputs: ["(bytes,bytes)[]"]
+
+#  function **glasses**(uint256 index) ⇒ (bytes _) _readonly_
+def glasses(index)
+  do_call("glasses", index)
+end
+sig "glasses", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **glassesCount**() ⇒ (uint256 _) _readonly_
+def glassesCount()
+  do_call("glassesCount")
+end
+sig "glassesCount", outputs: ["uint256"]
+
+#  function **headCount**() ⇒ (uint256 _) _readonly_
+def headCount()
+  do_call("headCount")
+end
+sig "headCount", outputs: ["uint256"]
+
+#  function **heads**(uint256 index) ⇒ (bytes _) _readonly_
+def heads(index)
+  do_call("heads", index)
+end
+sig "heads", inputs: ["uint256"], outputs: ["bytes"]
+
+#  function **isDataURIEnabled**() ⇒ (bool _) _readonly_
+def isDataURIEnabled()
+  do_call("isDataURIEnabled")
+end
+sig "isDataURIEnabled", outputs: ["bool"]
+
+#  function **owner**() ⇒ (address _) _readonly_
+def owner()
+  do_call("owner")
+end
+sig "owner", outputs: ["address"]
+
+#  function **palettes**(uint8 index) ⇒ (bytes _) _readonly_
+def palettes(index)
+  do_call("palettes", index)
+end
+sig "palettes", inputs: ["uint8"], outputs: ["bytes"]
+
+#  function **renderer**() ⇒ (contract ISVGRenderer _) _readonly_
+def renderer()
+  do_call("renderer")
+end
+sig "renderer", outputs: ["address"]
+
+#  function **tokenURI**(uint256 tokenId, struct INounsSeeder.Seed seed) ⇒ (string _) _readonly_
+def tokenURI(tokenId, seed)
+  do_call("tokenURI", tokenId, seed)
+end
+sig "tokenURI", inputs: ["uint256","(uint48,uint48,uint48,uint48,uint48)"], outputs: ["string"]
+
+end   ## class NounsDescriptorV2
+

data/lib/ethlite/contracts/nouns_seeder.rb

@@ -0,0 +1,19 @@
+# NounsSeeder contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:10 UTC
+#  - 1 query functions(s)
+#  - 0 helper functions(s)
+
+
+class  NounsSeeder <  Ethlite::Contract
+
+  address "0xcc8a0fb5ab3c7132c1b2a0109142fb112c4ce515"
+
+#  function **generateSeed**(uint256 nounId, contract INounsDescriptor descriptor) ⇒ (struct INounsSeeder.Seed _) _readonly_
+def generateSeed(nounId, descriptor)
+  do_call("generateSeed", nounId, descriptor)
+end
+sig "generateSeed", inputs: ["uint256","address"], outputs: ["(uint48,uint48,uint48,uint48,uint48)"]
+
+end   ## class NounsSeeder
+

data/lib/ethlite/contracts/synth_nouns.rb

@@ -0,0 +1,104 @@
+# SynthNouns contract / (blockchain) services / function calls
+#
+#  auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-16 16:17:17 UTC
+#  - 14 query functions(s)
+#  - 1 helper functions(s)
+
+
+class  SynthNouns <  Ethlite::Contract
+
+  address "0x8761b55af5a703d5855f1865db8fe4dd18e94c53"
+
+#  function **addressPreview**(address _address) ⇒ (string _) _readonly_
+def addressPreview(_address)
+  do_call("addressPreview", _address)
+end
+sig "addressPreview", inputs: ["address"], outputs: ["string"]
+
+#  function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
+def balanceOf(owner)
+  do_call("balanceOf", owner)
+end
+sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
+
+#  function **claimed**(address _) ⇒ (bool _) _readonly_
+def claimed(arg0)
+  do_call("claimed", arg0)
+end
+sig "claimed", inputs: ["address"], outputs: ["bool"]
+
+#  function **claimerOf**(uint256 _) ⇒ (address _) _readonly_
+def claimerOf(arg0)
+  do_call("claimerOf", arg0)
+end
+sig "claimerOf", inputs: ["uint256"], outputs: ["address"]
+
+#  function **descriptor**() ⇒ (contract INounsDescriptor _) _readonly_
+def descriptor()
+  do_call("descriptor")
+end
+sig "descriptor", outputs: ["address"]
+
+#  function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
+def getApproved(tokenId)
+  do_call("getApproved", tokenId)
+end
+sig "getApproved", inputs: ["uint256"], outputs: ["address"]
+
+#  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 **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
+def ownerOf(tokenId)
+  do_call("ownerOf", tokenId)
+end
+sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
+
+#  function **reverseRecords**() ⇒ (contract IENSReverseRecords _) _readonly_
+def reverseRecords()
+  do_call("reverseRecords")
+end
+sig "reverseRecords", outputs: ["address"]
+
+#  function **seeds**(uint256 _) ⇒ (uint48 background, uint48 body, uint48 accessory, uint48 head, uint48 glasses) _readonly_
+def seeds(arg0)
+  do_call("seeds", arg0)
+end
+sig "seeds", inputs: ["uint256"], outputs: ["uint48","uint48","uint48","uint48","uint48"]
+
+#  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 **getSeedInput**(address _address) ⇒ (uint256 _) _readonly_
+def getSeedInput(_address)
+  do_call("getSeedInput", _address)
+end
+sig "getSeedInput", inputs: ["address"], outputs: ["uint256"]
+
+end   ## class SynthNouns
+

data/lib/ethlite-contracts.rb

@@ -13,7 +13,7 @@ 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/punks_meta'
 
 require_relative 'ethlite/contracts/mooncats'
 require_relative 'ethlite/contracts/phunks_v2'
@@ -23,3 +23,9 @@ require_relative 'ethlite/contracts/moonbirds'
 require_relative 'ethlite/contracts/marcs'
 require_relative 'ethlite/contracts/mad_camels'
 
+require_relative 'ethlite/contracts/nouns'
+require_relative 'ethlite/contracts/nouns_auction_house'
+require_relative 'ethlite/contracts/nouns_seeder'
+require_relative 'ethlite/contracts/nouns_descriptor'
+require_relative 'ethlite/contracts/nouns_descriptor_v2'
+require_relative 'ethlite/contracts/synth_nouns'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ethlite-contracts
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2023-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ethlite
@@ -79,11 +79,17 @@ files:
 - lib/ethlite/contracts/marcs.rb
 - lib/ethlite/contracts/moonbirds.rb
 - lib/ethlite/contracts/mooncats.rb
+- lib/ethlite/contracts/nouns.rb
+- lib/ethlite/contracts/nouns_auction_house.rb
+- lib/ethlite/contracts/nouns_descriptor.rb
+- lib/ethlite/contracts/nouns_descriptor_v2.rb
+- lib/ethlite/contracts/nouns_seeder.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_nouns.rb
 - lib/ethlite/contracts/synth_punks.rb
 homepage: https://github.com/rubycocos/blockchain
 licenses: