ethlite-contracts 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: ca6de1c37a18e18603847fb4f34cece9177d8839e561a2e68cf1e772fbe81c81
4
- data.tar.gz: 52e07b948256fae1714ac69cf6fa3f3580638c89d41fcfdbbfe9ce84528c45d7
3
+ metadata.gz: 3ef0b4a37ea13739431d9959ac8509eedbdffe2adad9504f530f62098de2ea44
4
+ data.tar.gz: 0b559c031eca7bce44b9690b198f661f3774c9b02de0a68e7bc0d70d9c388bfe
5
5
  SHA512:
6
- metadata.gz: 7132e907281f9bd8efdabd16f337943339315d7406e05fc22f043a605616ea626d6886f9bad87ad089da5bfa6b6116f3d5edf163f69ec86cb957e81898fe5b96
7
- data.tar.gz: ff12785374324d102cb92a8ae0a6c52ec2af1d15c8925aab796a07ce9c467adb5572d03d5bb369208ad8a70462387fc2387c6e28577dfe3f14370849471e7557
6
+ metadata.gz: 3a4e36ab85ac89b933bd2ea63ba0557786384a647a377389d51eb381dbb00fd1413c576f8927883643ee615dc42f822341cc986bd3fe3e661abe5f2e5b7b19a5
7
+ data.tar.gz: 22531fef29752c98a72fd0491bac7384fab6db6f9b51b9147979b6eba8a79b88800f0be339409363ec20b7cfb4fe57c457abf9ef8ca2f42b5e08afff6abe56df
data/Manifest.txt CHANGED
@@ -5,5 +5,13 @@ Rakefile
5
5
  lib/ethlite-contracts.rb
6
6
  lib/ethlite/contract.rb
7
7
  lib/ethlite/contracts.rb
8
+ lib/ethlite/contracts/mad_camels.rb
9
+ lib/ethlite/contracts/marcs.rb
10
+ lib/ethlite/contracts/moonbirds.rb
11
+ lib/ethlite/contracts/mooncats.rb
12
+ lib/ethlite/contracts/phunks_v2.rb
8
13
  lib/ethlite/contracts/punk_blocks.rb
14
+ lib/ethlite/contracts/punks_data.rb
15
+ lib/ethlite/contracts/punks_meta.rb
9
16
  lib/ethlite/contracts/punks_v1.rb
17
+ lib/ethlite/contracts/synth_punks.rb
data/Rakefile CHANGED
@@ -3,7 +3,7 @@ require 'hoe'
3
3
 
4
4
  Hoe.spec 'ethlite-contracts' do
5
5
 
6
- self.version = '0.1.1'
6
+ self.version = '0.1.3'
7
7
  self.summary = "ethlite-contracts - ready-to-use (blockchain) contract services / function calls for ethereum & co."
8
8
  self.description = summary
9
9
 
@@ -0,0 +1,199 @@
1
+ # MadCamels contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:56 UTC
4
+ # - 31 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class MadCamels < Ethlite::Contract
9
+
10
+ address "0xad8474ba5a7f6abc52708f171f57fefc5cdc8c1c"
11
+
12
+ # function **allowListPrice**() ⇒ (uint256 _) _readonly_
13
+ def allowListPrice()
14
+ do_call("allowListPrice")
15
+ end
16
+ sig "allowListPrice", outputs: ["uint256"]
17
+
18
+ # function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
19
+ def balanceOf(owner)
20
+ do_call("balanceOf", owner)
21
+ end
22
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
23
+
24
+ # function **baseURI**() ⇒ (string _) _readonly_
25
+ def baseURI()
26
+ do_call("baseURI")
27
+ end
28
+ sig "baseURI", outputs: ["string"]
29
+
30
+ # function **contractData**() ⇒ (string name, string description, string image, string banner, string website, uint256 royalties, string royaltiesRecipient) _readonly_
31
+ def contractData()
32
+ do_call("contractData")
33
+ end
34
+ sig "contractData", outputs: ["string","string","string","string","string","uint256","string"]
35
+
36
+ # function **contractURI**() ⇒ (string _) _readonly_
37
+ def contractURI()
38
+ do_call("contractURI")
39
+ end
40
+ sig "contractURI", outputs: ["string"]
41
+
42
+ # function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
43
+ def getApproved(tokenId)
44
+ do_call("getApproved", tokenId)
45
+ end
46
+ sig "getApproved", inputs: ["uint256"], outputs: ["address"]
47
+
48
+ # function **getLinkedTraits**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (uint256[] _) _readonly_
49
+ def getLinkedTraits(_layerIndex, _traitIndex)
50
+ do_call("getLinkedTraits", _layerIndex, _traitIndex)
51
+ end
52
+ sig "getLinkedTraits", inputs: ["uint256","uint256"], outputs: ["uint256[]"]
53
+
54
+ # function **hashToMetadata**(string _hash) ⇒ (string _) _readonly_
55
+ def hashToMetadata(_hash)
56
+ do_call("hashToMetadata", _hash)
57
+ end
58
+ sig "hashToMetadata", inputs: ["string"], outputs: ["string"]
59
+
60
+ # function **hashToSVG**(string _hash) ⇒ (string _) _readonly_
61
+ def hashToSVG(_hash)
62
+ do_call("hashToSVG", _hash)
63
+ end
64
+ sig "hashToSVG", inputs: ["string"], outputs: ["string"]
65
+
66
+ # function **isAllowListActive**() ⇒ (bool _) _readonly_
67
+ def isAllowListActive()
68
+ do_call("isAllowListActive")
69
+ end
70
+ sig "isAllowListActive", outputs: ["bool"]
71
+
72
+ # function **isApprovedForAll**(address owner, address operator) ⇒ (bool _) _readonly_
73
+ def isApprovedForAll(owner, operator)
74
+ do_call("isApprovedForAll", owner, operator)
75
+ end
76
+ sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
77
+
78
+ # function **isContractSealed**() ⇒ (bool _) _readonly_
79
+ def isContractSealed()
80
+ do_call("isContractSealed")
81
+ end
82
+ sig "isContractSealed", outputs: ["bool"]
83
+
84
+ # function **isMintActive**() ⇒ (bool _) _readonly_
85
+ def isMintActive()
86
+ do_call("isMintActive")
87
+ end
88
+ sig "isMintActive", outputs: ["bool"]
89
+
90
+ # function **isPublicMintActive**() ⇒ (bool _) _readonly_
91
+ def isPublicMintActive()
92
+ do_call("isPublicMintActive")
93
+ end
94
+ sig "isPublicMintActive", outputs: ["bool"]
95
+
96
+ # function **maxPerAddress**() ⇒ (uint256 _) _readonly_
97
+ def maxPerAddress()
98
+ do_call("maxPerAddress")
99
+ end
100
+ sig "maxPerAddress", outputs: ["uint256"]
101
+
102
+ # function **maxPerAllowList**() ⇒ (uint256 _) _readonly_
103
+ def maxPerAllowList()
104
+ do_call("maxPerAllowList")
105
+ end
106
+ sig "maxPerAllowList", outputs: ["uint256"]
107
+
108
+ # function **maxSupply**() ⇒ (uint256 _) _readonly_
109
+ def maxSupply()
110
+ do_call("maxSupply")
111
+ end
112
+ sig "maxSupply", outputs: ["uint256"]
113
+
114
+ # function **name**() ⇒ (string _) _readonly_
115
+ def name()
116
+ do_call("name")
117
+ end
118
+ sig "name", outputs: ["string"]
119
+
120
+ # function **onAllowList**(address addr, bytes32[] merkleProof) ⇒ (bool _) _readonly_
121
+ def onAllowList(addr, merkleProof)
122
+ do_call("onAllowList", addr, merkleProof)
123
+ end
124
+ sig "onAllowList", inputs: ["address","bytes32[]"], outputs: ["bool"]
125
+
126
+ # function **owner**() ⇒ (address _) _readonly_
127
+ def owner()
128
+ do_call("owner")
129
+ end
130
+ sig "owner", outputs: ["address"]
131
+
132
+ # function **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
133
+ def ownerOf(tokenId)
134
+ do_call("ownerOf", tokenId)
135
+ end
136
+ sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
137
+
138
+ # function **publicMintPrice**() ⇒ (uint256 _) _readonly_
139
+ def publicMintPrice()
140
+ do_call("publicMintPrice")
141
+ end
142
+ sig "publicMintPrice", outputs: ["uint256"]
143
+
144
+ # function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
145
+ def supportsInterface(interfaceId)
146
+ do_call("supportsInterface", interfaceId)
147
+ end
148
+ sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
149
+
150
+ # function **symbol**() ⇒ (string _) _readonly_
151
+ def symbol()
152
+ do_call("symbol")
153
+ end
154
+ sig "symbol", outputs: ["string"]
155
+
156
+ # function **tokenIdToHash**(uint256 _tokenId) ⇒ (string _) _readonly_
157
+ def tokenIdToHash(_tokenId)
158
+ do_call("tokenIdToHash", _tokenId)
159
+ end
160
+ sig "tokenIdToHash", inputs: ["uint256"], outputs: ["string"]
161
+
162
+ # function **tokenIdToSVG**(uint256 _tokenId) ⇒ (string _) _readonly_
163
+ def tokenIdToSVG(_tokenId)
164
+ do_call("tokenIdToSVG", _tokenId)
165
+ end
166
+ sig "tokenIdToSVG", inputs: ["uint256"], outputs: ["string"]
167
+
168
+ # function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
169
+ def tokenURI(_tokenId)
170
+ do_call("tokenURI", _tokenId)
171
+ end
172
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
173
+
174
+ # function **tokensAreDuplicates**(uint256 tokenIdA, uint256 tokenIdB) ⇒ (bool _) _readonly_
175
+ def tokensAreDuplicates(tokenIdA, tokenIdB)
176
+ do_call("tokensAreDuplicates", tokenIdA, tokenIdB)
177
+ end
178
+ sig "tokensAreDuplicates", inputs: ["uint256","uint256"], outputs: ["bool"]
179
+
180
+ # function **totalSupply**() ⇒ (uint256 _) _readonly_
181
+ def totalSupply()
182
+ do_call("totalSupply")
183
+ end
184
+ sig "totalSupply", outputs: ["uint256"]
185
+
186
+ # function **traitData**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (string _) _readonly_
187
+ def traitData(_layerIndex, _traitIndex)
188
+ do_call("traitData", _layerIndex, _traitIndex)
189
+ end
190
+ sig "traitData", inputs: ["uint256","uint256"], outputs: ["string"]
191
+
192
+ # function **traitDetails**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (struct Indelible.Trait _) _readonly_
193
+ def traitDetails(_layerIndex, _traitIndex)
194
+ do_call("traitDetails", _layerIndex, _traitIndex)
195
+ end
196
+ sig "traitDetails", inputs: ["uint256","uint256"], outputs: ["(string,string)"]
197
+
198
+ end ## class MadCamels
199
+
@@ -0,0 +1,199 @@
1
+ # Marcs contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:53 UTC
4
+ # - 31 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class Marcs < Ethlite::Contract
9
+
10
+ address "0xe9b91d537c3aa5a3fa87275fbd2e4feaaed69bd0"
11
+
12
+ # function **allowListPrice**() ⇒ (uint256 _) _readonly_
13
+ def allowListPrice()
14
+ do_call("allowListPrice")
15
+ end
16
+ sig "allowListPrice", outputs: ["uint256"]
17
+
18
+ # function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
19
+ def balanceOf(owner)
20
+ do_call("balanceOf", owner)
21
+ end
22
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
23
+
24
+ # function **baseURI**() ⇒ (string _) _readonly_
25
+ def baseURI()
26
+ do_call("baseURI")
27
+ end
28
+ sig "baseURI", outputs: ["string"]
29
+
30
+ # function **contractData**() ⇒ (string name, string description, string image, string banner, string website, uint256 royalties, string royaltiesRecipient) _readonly_
31
+ def contractData()
32
+ do_call("contractData")
33
+ end
34
+ sig "contractData", outputs: ["string","string","string","string","string","uint256","string"]
35
+
36
+ # function **contractURI**() ⇒ (string _) _readonly_
37
+ def contractURI()
38
+ do_call("contractURI")
39
+ end
40
+ sig "contractURI", outputs: ["string"]
41
+
42
+ # function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
43
+ def getApproved(tokenId)
44
+ do_call("getApproved", tokenId)
45
+ end
46
+ sig "getApproved", inputs: ["uint256"], outputs: ["address"]
47
+
48
+ # function **hashToMetadata**(string _hash) ⇒ (string _) _readonly_
49
+ def hashToMetadata(_hash)
50
+ do_call("hashToMetadata", _hash)
51
+ end
52
+ sig "hashToMetadata", inputs: ["string"], outputs: ["string"]
53
+
54
+ # function **hashToSVG**(string _hash) ⇒ (string _) _readonly_
55
+ def hashToSVG(_hash)
56
+ do_call("hashToSVG", _hash)
57
+ end
58
+ sig "hashToSVG", inputs: ["string"], outputs: ["string"]
59
+
60
+ # function **isAllowListActive**() ⇒ (bool _) _readonly_
61
+ def isAllowListActive()
62
+ do_call("isAllowListActive")
63
+ end
64
+ sig "isAllowListActive", outputs: ["bool"]
65
+
66
+ # function **isApprovedForAll**(address owner, address operator) ⇒ (bool _) _readonly_
67
+ def isApprovedForAll(owner, operator)
68
+ do_call("isApprovedForAll", owner, operator)
69
+ end
70
+ sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
71
+
72
+ # function **isContractSealed**() ⇒ (bool _) _readonly_
73
+ def isContractSealed()
74
+ do_call("isContractSealed")
75
+ end
76
+ sig "isContractSealed", outputs: ["bool"]
77
+
78
+ # function **isMintActive**() ⇒ (bool _) _readonly_
79
+ def isMintActive()
80
+ do_call("isMintActive")
81
+ end
82
+ sig "isMintActive", outputs: ["bool"]
83
+
84
+ # function **isPublicMintActive**() ⇒ (bool _) _readonly_
85
+ def isPublicMintActive()
86
+ do_call("isPublicMintActive")
87
+ end
88
+ sig "isPublicMintActive", outputs: ["bool"]
89
+
90
+ # function **maxPerAddress**() ⇒ (uint256 _) _readonly_
91
+ def maxPerAddress()
92
+ do_call("maxPerAddress")
93
+ end
94
+ sig "maxPerAddress", outputs: ["uint256"]
95
+
96
+ # function **maxPerAllowList**() ⇒ (uint256 _) _readonly_
97
+ def maxPerAllowList()
98
+ do_call("maxPerAllowList")
99
+ end
100
+ sig "maxPerAllowList", outputs: ["uint256"]
101
+
102
+ # function **maxSupply**() ⇒ (uint256 _) _readonly_
103
+ def maxSupply()
104
+ do_call("maxSupply")
105
+ end
106
+ sig "maxSupply", outputs: ["uint256"]
107
+
108
+ # function **name**() ⇒ (string _) _readonly_
109
+ def name()
110
+ do_call("name")
111
+ end
112
+ sig "name", outputs: ["string"]
113
+
114
+ # function **ockAddress**() ⇒ (address _) _readonly_
115
+ def ockAddress()
116
+ do_call("ockAddress")
117
+ end
118
+ sig "ockAddress", outputs: ["address"]
119
+
120
+ # function **onAllowList**(address addr, bytes32[] merkleProof) ⇒ (bool _) _readonly_
121
+ def onAllowList(addr, merkleProof)
122
+ do_call("onAllowList", addr, merkleProof)
123
+ end
124
+ sig "onAllowList", inputs: ["address","bytes32[]"], outputs: ["bool"]
125
+
126
+ # function **owner**() ⇒ (address _) _readonly_
127
+ def owner()
128
+ do_call("owner")
129
+ end
130
+ sig "owner", outputs: ["address"]
131
+
132
+ # function **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
133
+ def ownerOf(tokenId)
134
+ do_call("ownerOf", tokenId)
135
+ end
136
+ sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
137
+
138
+ # function **publicMintPrice**() ⇒ (uint256 _) _readonly_
139
+ def publicMintPrice()
140
+ do_call("publicMintPrice")
141
+ end
142
+ sig "publicMintPrice", outputs: ["uint256"]
143
+
144
+ # function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
145
+ def supportsInterface(interfaceId)
146
+ do_call("supportsInterface", interfaceId)
147
+ end
148
+ sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
149
+
150
+ # function **symbol**() ⇒ (string _) _readonly_
151
+ def symbol()
152
+ do_call("symbol")
153
+ end
154
+ sig "symbol", outputs: ["string"]
155
+
156
+ # function **tokenIdToHash**(uint256 _tokenId) ⇒ (string _) _readonly_
157
+ def tokenIdToHash(_tokenId)
158
+ do_call("tokenIdToHash", _tokenId)
159
+ end
160
+ sig "tokenIdToHash", inputs: ["uint256"], outputs: ["string"]
161
+
162
+ # function **tokenIdToSVG**(uint256 _tokenId) ⇒ (string _) _readonly_
163
+ def tokenIdToSVG(_tokenId)
164
+ do_call("tokenIdToSVG", _tokenId)
165
+ end
166
+ sig "tokenIdToSVG", inputs: ["uint256"], outputs: ["string"]
167
+
168
+ # function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
169
+ def tokenURI(_tokenId)
170
+ do_call("tokenURI", _tokenId)
171
+ end
172
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
173
+
174
+ # function **tokensAreDuplicates**(uint256 tokenId1, uint256 tokenId2) ⇒ (bool _) _readonly_
175
+ def tokensAreDuplicates(tokenId1, tokenId2)
176
+ do_call("tokensAreDuplicates", tokenId1, tokenId2)
177
+ end
178
+ sig "tokensAreDuplicates", inputs: ["uint256","uint256"], outputs: ["bool"]
179
+
180
+ # function **totalSupply**() ⇒ (uint256 _) _readonly_
181
+ def totalSupply()
182
+ do_call("totalSupply")
183
+ end
184
+ sig "totalSupply", outputs: ["uint256"]
185
+
186
+ # function **traitData**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (string _) _readonly_
187
+ def traitData(_layerIndex, _traitIndex)
188
+ do_call("traitData", _layerIndex, _traitIndex)
189
+ end
190
+ sig "traitData", inputs: ["uint256","uint256"], outputs: ["string"]
191
+
192
+ # function **traitDetails**(uint256 _layerIndex, uint256 _traitIndex) ⇒ (struct IndelibleERC721A.Trait _) _readonly_
193
+ def traitDetails(_layerIndex, _traitIndex)
194
+ do_call("traitDetails", _layerIndex, _traitIndex)
195
+ end
196
+ sig "traitDetails", inputs: ["uint256","uint256"], outputs: ["(string,string)"]
197
+
198
+ end ## class Marcs
199
+
@@ -0,0 +1,211 @@
1
+ # Moonbirds contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:51 UTC
4
+ # - 33 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class Moonbirds < Ethlite::Contract
9
+
10
+ address "0x23581767a106ae21c074b2276d25e5c3e136a68b"
11
+
12
+ # function **DEFAULT_ADMIN_ROLE**() ⇒ (bytes32 _) _readonly_
13
+ def DEFAULT_ADMIN_ROLE()
14
+ do_call("DEFAULT_ADMIN_ROLE")
15
+ end
16
+ sig "DEFAULT_ADMIN_ROLE", outputs: ["bytes32"]
17
+
18
+ # function **EXPULSION_ROLE**() ⇒ (bytes32 _) _readonly_
19
+ def EXPULSION_ROLE()
20
+ do_call("EXPULSION_ROLE")
21
+ end
22
+ sig "EXPULSION_ROLE", outputs: ["bytes32"]
23
+
24
+ # function **alreadyMinted**(address to, bytes32 nonce) ⇒ (bool _) _readonly_
25
+ def alreadyMinted(to, nonce)
26
+ do_call("alreadyMinted", to, nonce)
27
+ end
28
+ sig "alreadyMinted", inputs: ["address","bytes32"], outputs: ["bool"]
29
+
30
+ # function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
31
+ def balanceOf(owner)
32
+ do_call("balanceOf", owner)
33
+ end
34
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
35
+
36
+ # function **baseTokenURI**() ⇒ (string _) _readonly_
37
+ def baseTokenURI()
38
+ do_call("baseTokenURI")
39
+ end
40
+ sig "baseTokenURI", outputs: ["string"]
41
+
42
+ # function **beneficiary**() ⇒ (address payable _) _readonly_
43
+ def beneficiary()
44
+ do_call("beneficiary")
45
+ end
46
+ sig "beneficiary", outputs: ["address"]
47
+
48
+ # function **cost**(uint256 n, uint256 _) ⇒ (uint256 _) _readonly_
49
+ def cost(n, arg1)
50
+ do_call("cost", n, arg1)
51
+ end
52
+ sig "cost", inputs: ["uint256","uint256"], outputs: ["uint256"]
53
+
54
+ # function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
55
+ def getApproved(tokenId)
56
+ do_call("getApproved", tokenId)
57
+ end
58
+ sig "getApproved", inputs: ["uint256"], outputs: ["address"]
59
+
60
+ # function **getRoleAdmin**(bytes32 role) ⇒ (bytes32 _) _readonly_
61
+ def getRoleAdmin(role)
62
+ do_call("getRoleAdmin", role)
63
+ end
64
+ sig "getRoleAdmin", inputs: ["bytes32"], outputs: ["bytes32"]
65
+
66
+ # function **getRoleMember**(bytes32 role, uint256 index) ⇒ (address _) _readonly_
67
+ def getRoleMember(role, index)
68
+ do_call("getRoleMember", role, index)
69
+ end
70
+ sig "getRoleMember", inputs: ["bytes32","uint256"], outputs: ["address"]
71
+
72
+ # function **getRoleMemberCount**(bytes32 role) ⇒ (uint256 _) _readonly_
73
+ def getRoleMemberCount(role)
74
+ do_call("getRoleMemberCount", role)
75
+ end
76
+ sig "getRoleMemberCount", inputs: ["bytes32"], outputs: ["uint256"]
77
+
78
+ # function **hasRole**(bytes32 role, address account) ⇒ (bool _) _readonly_
79
+ def hasRole(role, account)
80
+ do_call("hasRole", role, account)
81
+ end
82
+ sig "hasRole", inputs: ["bytes32","address"], outputs: ["bool"]
83
+
84
+ # function **isApprovedForAll**(address owner, address operator) ⇒ (bool _) _readonly_
85
+ def isApprovedForAll(owner, operator)
86
+ do_call("isApprovedForAll", owner, operator)
87
+ end
88
+ sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
89
+
90
+ # function **name**() ⇒ (string _) _readonly_
91
+ def name()
92
+ do_call("name")
93
+ end
94
+ sig "name", outputs: ["string"]
95
+
96
+ # function **nestingOpen**() ⇒ (bool _) _readonly_
97
+ def nestingOpen()
98
+ do_call("nestingOpen")
99
+ end
100
+ sig "nestingOpen", outputs: ["bool"]
101
+
102
+ # function **nestingPeriod**(uint256 tokenId) ⇒ (bool nesting, uint256 current, uint256 total) _readonly_
103
+ def nestingPeriod(tokenId)
104
+ do_call("nestingPeriod", tokenId)
105
+ end
106
+ sig "nestingPeriod", inputs: ["uint256"], outputs: ["bool","uint256","uint256"]
107
+
108
+ # function **owner**() ⇒ (address _) _readonly_
109
+ def owner()
110
+ do_call("owner")
111
+ end
112
+ sig "owner", outputs: ["address"]
113
+
114
+ # function **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
115
+ def ownerOf(tokenId)
116
+ do_call("ownerOf", tokenId)
117
+ end
118
+ sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
119
+
120
+ # function **paused**() ⇒ (bool _) _readonly_
121
+ def paused()
122
+ do_call("paused")
123
+ end
124
+ sig "paused", outputs: ["bool"]
125
+
126
+ # function **price**() ⇒ (uint256 _) _readonly_
127
+ def price()
128
+ do_call("price")
129
+ end
130
+ sig "price", outputs: ["uint256"]
131
+
132
+ # function **proof**() ⇒ (contract IERC721 _) _readonly_
133
+ def proof()
134
+ do_call("proof")
135
+ end
136
+ sig "proof", outputs: ["address"]
137
+
138
+ # function **proofClaimsRemaining**(uint256 tokenId) ⇒ (uint256 _) _readonly_
139
+ def proofClaimsRemaining(tokenId)
140
+ do_call("proofClaimsRemaining", tokenId)
141
+ end
142
+ sig "proofClaimsRemaining", inputs: ["uint256"], outputs: ["uint256"]
143
+
144
+ # function **proofMintingOpen**() ⇒ (bool _) _readonly_
145
+ def proofMintingOpen()
146
+ do_call("proofMintingOpen")
147
+ end
148
+ sig "proofMintingOpen", outputs: ["bool"]
149
+
150
+ # function **proofPoolRemaining**() ⇒ (uint256 _) _readonly_
151
+ def proofPoolRemaining()
152
+ do_call("proofPoolRemaining")
153
+ end
154
+ sig "proofPoolRemaining", outputs: ["uint256"]
155
+
156
+ # function **renderingContract**() ⇒ (contract ITokenURIGenerator _) _readonly_
157
+ def renderingContract()
158
+ do_call("renderingContract")
159
+ end
160
+ sig "renderingContract", outputs: ["address"]
161
+
162
+ # function **royaltyInfo**(uint256 _tokenId, uint256 _salePrice) ⇒ (address _, uint256 _) _readonly_
163
+ def royaltyInfo(_tokenId, _salePrice)
164
+ do_call("royaltyInfo", _tokenId, _salePrice)
165
+ end
166
+ sig "royaltyInfo", inputs: ["uint256","uint256"], outputs: ["address","uint256"]
167
+
168
+ # function **sellerConfig**() ⇒ (uint256 totalInventory, uint256 maxPerAddress, uint256 maxPerTx, uint248 freeQuota, bool reserveFreeQuota, bool lockFreeQuota, bool lockTotalInventory) _readonly_
169
+ def sellerConfig()
170
+ do_call("sellerConfig")
171
+ end
172
+ sig "sellerConfig", outputs: ["uint256","uint256","uint256","uint248","bool","bool","bool"]
173
+
174
+ # function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
175
+ def supportsInterface(interfaceId)
176
+ do_call("supportsInterface", interfaceId)
177
+ end
178
+ sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
179
+
180
+ # function **symbol**() ⇒ (string _) _readonly_
181
+ def symbol()
182
+ do_call("symbol")
183
+ end
184
+ sig "symbol", outputs: ["string"]
185
+
186
+ # function **tokenURI**(uint256 tokenId) ⇒ (string _) _readonly_
187
+ def tokenURI(tokenId)
188
+ do_call("tokenURI", tokenId)
189
+ end
190
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
191
+
192
+ # function **totalSold**() ⇒ (uint256 _) _readonly_
193
+ def totalSold()
194
+ do_call("totalSold")
195
+ end
196
+ sig "totalSold", outputs: ["uint256"]
197
+
198
+ # function **totalSupply**() ⇒ (uint256 _) _readonly_
199
+ def totalSupply()
200
+ do_call("totalSupply")
201
+ end
202
+ sig "totalSupply", outputs: ["uint256"]
203
+
204
+ # function **usedMessages**(bytes32 _) ⇒ (bool _) _readonly_
205
+ def usedMessages(arg0)
206
+ do_call("usedMessages", arg0)
207
+ end
208
+ sig "usedMessages", inputs: ["bytes32"], outputs: ["bool"]
209
+
210
+ end ## class Moonbirds
211
+
@@ -0,0 +1,151 @@
1
+ # Mooncats contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:44 UTC
4
+ # - 23 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class Mooncats < Ethlite::Contract
9
+
10
+ address "0x60cd862c9c687a9de49aecdc3a99b74a4fc54ab6"
11
+
12
+ # function **name**() ⇒ (string _) _readonly_
13
+ def name()
14
+ do_call("name")
15
+ end
16
+ sig "name", outputs: ["string"]
17
+
18
+ # function **remainingGenesisCats**() ⇒ (uint16 _) _readonly_
19
+ def remainingGenesisCats()
20
+ do_call("remainingGenesisCats")
21
+ end
22
+ sig "remainingGenesisCats", outputs: ["uint16"]
23
+
24
+ # function **totalSupply**() ⇒ (uint256 _) _readonly_
25
+ def totalSupply()
26
+ do_call("totalSupply")
27
+ end
28
+ sig "totalSupply", outputs: ["uint256"]
29
+
30
+ # function **remainingCats**() ⇒ (uint16 _) _readonly_
31
+ def remainingCats()
32
+ do_call("remainingCats")
33
+ end
34
+ sig "remainingCats", outputs: ["uint16"]
35
+
36
+ # function **mode**() ⇒ (uint8 _) _readonly_
37
+ def mode()
38
+ do_call("mode")
39
+ end
40
+ sig "mode", outputs: ["uint8"]
41
+
42
+ # function **getCatDetails**(bytes5 catId) ⇒ (bytes5 id, address owner, bytes32 name, address onlyOfferTo, uint256 offerPrice, address requester, uint256 requestPrice) _readonly_
43
+ def getCatDetails(catId)
44
+ do_call("getCatDetails", catId)
45
+ end
46
+ sig "getCatDetails", inputs: ["bytes5"], outputs: ["bytes5","address","bytes32","address","uint256","address","uint256"]
47
+
48
+ # function **decimals**() ⇒ (uint8 _) _readonly_
49
+ def decimals()
50
+ do_call("decimals")
51
+ end
52
+ sig "decimals", outputs: ["uint8"]
53
+
54
+ # function **getCatOwners**() ⇒ (address[] _) _readonly_
55
+ def getCatOwners()
56
+ do_call("getCatOwners")
57
+ end
58
+ sig "getCatOwners", outputs: ["address[]"]
59
+
60
+ # function **catOwners**(bytes5 _) ⇒ (address _) _readonly_
61
+ def catOwners(arg0)
62
+ do_call("catOwners", arg0)
63
+ end
64
+ sig "catOwners", inputs: ["bytes5"], outputs: ["address"]
65
+
66
+ # function **rescueOrder**(uint256 _) ⇒ (bytes5 _) _readonly_
67
+ def rescueOrder(arg0)
68
+ do_call("rescueOrder", arg0)
69
+ end
70
+ sig "rescueOrder", inputs: ["uint256"], outputs: ["bytes5"]
71
+
72
+ # function **getCatIds**() ⇒ (bytes5[] _) _readonly_
73
+ def getCatIds()
74
+ do_call("getCatIds")
75
+ end
76
+ sig "getCatIds", outputs: ["bytes5[]"]
77
+
78
+ # function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
79
+ def balanceOf(arg0)
80
+ do_call("balanceOf", arg0)
81
+ end
82
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
83
+
84
+ # function **getCatNames**() ⇒ (bytes32[] _) _readonly_
85
+ def getCatNames()
86
+ do_call("getCatNames")
87
+ end
88
+ sig "getCatNames", outputs: ["bytes32[]"]
89
+
90
+ # function **adoptionOffers**(bytes5 _) ⇒ (bool exists, bytes5 catId, address seller, uint256 price, address onlyOfferTo) _readonly_
91
+ def adoptionOffers(arg0)
92
+ do_call("adoptionOffers", arg0)
93
+ end
94
+ sig "adoptionOffers", inputs: ["bytes5"], outputs: ["bool","bytes5","address","uint256","address"]
95
+
96
+ # function **catNames**(bytes5 _) ⇒ (bytes32 _) _readonly_
97
+ def catNames(arg0)
98
+ do_call("catNames", arg0)
99
+ end
100
+ sig "catNames", inputs: ["bytes5"], outputs: ["bytes32"]
101
+
102
+ # function **symbol**() ⇒ (string _) _readonly_
103
+ def symbol()
104
+ do_call("symbol")
105
+ end
106
+ sig "symbol", outputs: ["string"]
107
+
108
+ # function **getCatRequestPrices**() ⇒ (uint256[] _) _readonly_
109
+ def getCatRequestPrices()
110
+ do_call("getCatRequestPrices")
111
+ end
112
+ sig "getCatRequestPrices", outputs: ["uint256[]"]
113
+
114
+ # function **searchSeed**() ⇒ (bytes32 _) _readonly_
115
+ def searchSeed()
116
+ do_call("searchSeed")
117
+ end
118
+ sig "searchSeed", outputs: ["bytes32"]
119
+
120
+ # function **imageGenerationCodeMD5**() ⇒ (bytes16 _) _readonly_
121
+ def imageGenerationCodeMD5()
122
+ do_call("imageGenerationCodeMD5")
123
+ end
124
+ sig "imageGenerationCodeMD5", outputs: ["bytes16"]
125
+
126
+ # function **adoptionRequests**(bytes5 _) ⇒ (bool exists, bytes5 catId, address requester, uint256 price) _readonly_
127
+ def adoptionRequests(arg0)
128
+ do_call("adoptionRequests", arg0)
129
+ end
130
+ sig "adoptionRequests", inputs: ["bytes5"], outputs: ["bool","bytes5","address","uint256"]
131
+
132
+ # function **getCatOfferPrices**() ⇒ (uint256[] _) _readonly_
133
+ def getCatOfferPrices()
134
+ do_call("getCatOfferPrices")
135
+ end
136
+ sig "getCatOfferPrices", outputs: ["uint256[]"]
137
+
138
+ # function **rescueIndex**() ⇒ (uint16 _) _readonly_
139
+ def rescueIndex()
140
+ do_call("rescueIndex")
141
+ end
142
+ sig "rescueIndex", outputs: ["uint16"]
143
+
144
+ # function **pendingWithdrawals**(address _) ⇒ (uint256 _) _readonly_
145
+ def pendingWithdrawals(arg0)
146
+ do_call("pendingWithdrawals", arg0)
147
+ end
148
+ sig "pendingWithdrawals", inputs: ["address"], outputs: ["uint256"]
149
+
150
+ end ## class Mooncats
151
+
@@ -0,0 +1,145 @@
1
+ # PhunksV2 contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:46 UTC
4
+ # - 22 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class PhunksV2 < Ethlite::Contract
9
+
10
+ address "0xf07468ead8cf26c752c676e43c814fee9c8cf402"
11
+
12
+ # function **MAX_MINTABLE_AT_ONCE**() ⇒ (uint256 _) _readonly_
13
+ def MAX_MINTABLE_AT_ONCE()
14
+ do_call("MAX_MINTABLE_AT_ONCE")
15
+ end
16
+ sig "MAX_MINTABLE_AT_ONCE", outputs: ["uint256"]
17
+
18
+ # function **balanceOf**(address owner) ⇒ (uint256 _) _readonly_
19
+ def balanceOf(owner)
20
+ do_call("balanceOf", owner)
21
+ end
22
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
23
+
24
+ # function **contractURI**() ⇒ (string _) _readonly_
25
+ def contractURI()
26
+ do_call("contractURI")
27
+ end
28
+ sig "contractURI", outputs: ["string"]
29
+
30
+ # function **freeRollPhunks**(address _) ⇒ (uint256 _) _readonly_
31
+ def freeRollPhunks(arg0)
32
+ do_call("freeRollPhunks", arg0)
33
+ end
34
+ sig "freeRollPhunks", inputs: ["address"], outputs: ["uint256"]
35
+
36
+ # function **getApproved**(uint256 tokenId) ⇒ (address _) _readonly_
37
+ def getApproved(tokenId)
38
+ do_call("getApproved", tokenId)
39
+ end
40
+ sig "getApproved", inputs: ["uint256"], outputs: ["address"]
41
+
42
+ # function **getCostForMintingPhunks**(uint256 _numToMint) ⇒ (uint256 _) _readonly_
43
+ def getCostForMintingPhunks(_numToMint)
44
+ do_call("getCostForMintingPhunks", _numToMint)
45
+ end
46
+ sig "getCostForMintingPhunks", inputs: ["uint256"], outputs: ["uint256"]
47
+
48
+ # function **getNumFreeRollPhunks**(address owner) ⇒ (uint256 _) _readonly_
49
+ def getNumFreeRollPhunks(owner)
50
+ do_call("getNumFreeRollPhunks", owner)
51
+ end
52
+ sig "getNumFreeRollPhunks", inputs: ["address"], outputs: ["uint256"]
53
+
54
+ # function **getPhunksBelongingToOwner**(address _owner) ⇒ (uint256[] _) _readonly_
55
+ def getPhunksBelongingToOwner(_owner)
56
+ do_call("getPhunksBelongingToOwner", _owner)
57
+ end
58
+ sig "getPhunksBelongingToOwner", inputs: ["address"], outputs: ["uint256[]"]
59
+
60
+ # function **imageHash**() ⇒ (string _) _readonly_
61
+ def imageHash()
62
+ do_call("imageHash")
63
+ end
64
+ sig "imageHash", outputs: ["string"]
65
+
66
+ # function **isApprovedForAll**(address owner, address operator) ⇒ (bool _) _readonly_
67
+ def isApprovedForAll(owner, operator)
68
+ do_call("isApprovedForAll", owner, operator)
69
+ end
70
+ sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
71
+
72
+ # function **isSaleOn**() ⇒ (bool _) _readonly_
73
+ def isSaleOn()
74
+ do_call("isSaleOn")
75
+ end
76
+ sig "isSaleOn", outputs: ["bool"]
77
+
78
+ # function **name**() ⇒ (string _) _readonly_
79
+ def name()
80
+ do_call("name")
81
+ end
82
+ sig "name", outputs: ["string"]
83
+
84
+ # function **numTotalPhunks**() ⇒ (uint256 _) _readonly_
85
+ def numTotalPhunks()
86
+ do_call("numTotalPhunks")
87
+ end
88
+ sig "numTotalPhunks", outputs: ["uint256"]
89
+
90
+ # function **owner**() ⇒ (address _) _readonly_
91
+ def owner()
92
+ do_call("owner")
93
+ end
94
+ sig "owner", outputs: ["address"]
95
+
96
+ # function **ownerOf**(uint256 tokenId) ⇒ (address _) _readonly_
97
+ def ownerOf(tokenId)
98
+ do_call("ownerOf", tokenId)
99
+ end
100
+ sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
101
+
102
+ # function **saleHasBeenStarted**() ⇒ (bool _) _readonly_
103
+ def saleHasBeenStarted()
104
+ do_call("saleHasBeenStarted")
105
+ end
106
+ sig "saleHasBeenStarted", outputs: ["bool"]
107
+
108
+ # function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
109
+ def supportsInterface(interfaceId)
110
+ do_call("supportsInterface", interfaceId)
111
+ end
112
+ sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
113
+
114
+ # function **symbol**() ⇒ (string _) _readonly_
115
+ def symbol()
116
+ do_call("symbol")
117
+ end
118
+ sig "symbol", outputs: ["string"]
119
+
120
+ # function **tokenByIndex**(uint256 index) ⇒ (uint256 _) _readonly_
121
+ def tokenByIndex(index)
122
+ do_call("tokenByIndex", index)
123
+ end
124
+ sig "tokenByIndex", inputs: ["uint256"], outputs: ["uint256"]
125
+
126
+ # function **tokenOfOwnerByIndex**(address owner, uint256 index) ⇒ (uint256 _) _readonly_
127
+ def tokenOfOwnerByIndex(owner, index)
128
+ do_call("tokenOfOwnerByIndex", owner, index)
129
+ end
130
+ sig "tokenOfOwnerByIndex", inputs: ["address","uint256"], outputs: ["uint256"]
131
+
132
+ # function **tokenURI**(uint256 _tokenId) ⇒ (string _) _readonly_
133
+ def tokenURI(_tokenId)
134
+ do_call("tokenURI", _tokenId)
135
+ end
136
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
137
+
138
+ # function **totalSupply**() ⇒ (uint256 _) _readonly_
139
+ def totalSupply()
140
+ do_call("totalSupply")
141
+ end
142
+ sig "totalSupply", outputs: ["uint256"]
143
+
144
+ end ## class PhunksV2
145
+
@@ -1,7 +1,8 @@
1
- #########################
2
1
  # PunkBlocks contract / (blockchain) services / function calls
3
- # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-13 15:31:38 UTC
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:58 UTC
4
4
  # - 8 query functions(s)
5
+ # - 0 helper functions(s)
5
6
  #
6
7
  #
7
8
  # - Author: tycoon.eth, thanks to @geraldb & @samwilsn on Github for inspiration!
@@ -0,0 +1,31 @@
1
+ # PunksData contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:46 UTC
4
+ # - 3 query functions(s)
5
+ # - 0 helper functions(s)
6
+
7
+
8
+ class PunksData < Ethlite::Contract
9
+
10
+ address "0x16f5a35647d6f03d5d3da7b35409d65ba03af3b2"
11
+
12
+ # function **punkAttributes**(uint16 index) ⇒ (string text) _readonly_
13
+ def punkAttributes(index)
14
+ do_call("punkAttributes", index)
15
+ end
16
+ sig "punkAttributes", inputs: ["uint16"], outputs: ["string"]
17
+
18
+ # function **punkImage**(uint16 index) ⇒ (bytes _) _readonly_
19
+ def punkImage(index)
20
+ do_call("punkImage", index)
21
+ end
22
+ sig "punkImage", inputs: ["uint16"], outputs: ["bytes"]
23
+
24
+ # function **punkImageSvg**(uint16 index) ⇒ (string svg) _readonly_
25
+ def punkImageSvg(index)
26
+ do_call("punkImageSvg", index)
27
+ end
28
+ sig "punkImageSvg", inputs: ["uint16"], outputs: ["string"]
29
+
30
+ end ## class PunksData
31
+
@@ -0,0 +1,80 @@
1
+ # PunksMeta contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:56 UTC
4
+ # - 3 query functions(s)
5
+ # - 1 helper functions(s)
6
+ #
7
+ #
8
+ # - 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
9
+ # - Version: 0.0.2
10
+ # - Pragma: solidity ^0.8.17
11
+ #
12
+ #
13
+ # █████ ██████
14
+ # █ █ █████ █ █ █████ █████ ████ █ █ █ █ █ █ █ █ ████
15
+ # █ █ █ █ █ █ █ █ █ █ █ █ █ █ ██ █ █ █ █
16
+ # █ █ █ █ █ █ █ █ █ ██████ █ █ █ █ █ ████ ████
17
+ # █ █████ █ █████ █ █ █ █ █ █ █ █ █ █ █ █
18
+ # █ █ █ █ █ █ █ █ █ █ █ █ █ ██ █ █ █ █
19
+ # █████ █ █ █ █ █ ████ █ ████ █ █ █ █ ████
20
+ #
21
+ # ███████ █ █
22
+ # █ ████ █ █ ██████ █ █ █ █ █████ █
23
+ # █ █ █ █ █ █ ██ █ █ █ █ █ █
24
+ # █ █ █ ████ █████ █ █ █ █ █ █ █ █
25
+ # █ █ █ █ █ █ █ █ █ █ █ █████ █
26
+ # █ █ █ █ █ █ █ ██ █ █ █ █ █
27
+ # █ ████ █ █ ██████ █ █ █████ █ █ █
28
+ #
29
+ #
30
+ # Punks's missing tokenURI function
31
+
32
+
33
+ class PunksMeta < Ethlite::Contract
34
+
35
+ address "0xd8e916c3016be144eb2907778cf972c4b01645fC"
36
+
37
+ # function getAttributes(uint256 _tokenId) returns (string)
38
+ #
39
+ # getAttributes calls parseAttributes and returns the result as JSON
40
+ # @param _tokenId the punk id
41
+ def getAttributes(_tokenId)
42
+ do_call("getAttributes", _tokenId)
43
+ end
44
+ sig "getAttributes", inputs: ["uint256"], outputs: ["string"]
45
+
46
+ # function parseAttributes(uint256 _tokenId) returns (string[8])
47
+ #
48
+ # parseAttributes returns an array of punk attributes. 8 rows in total
49
+ # The first row is the Type, and next seven rows are the attributes.
50
+ # The values are fetched form the CryptoPunksData contract and then the
51
+ # string is parsed.
52
+ # @param _tokenId the punk id
53
+ def parseAttributes(_tokenId)
54
+ do_call("parseAttributes", _tokenId)
55
+ end
56
+ sig "parseAttributes", inputs: ["uint256"], outputs: ["string[8]"]
57
+
58
+ # function tokenURI(uint256 _tokenId) returns (string)
59
+ #
60
+ # tokenURI gets the metadata about a punk and returns as a JSON
61
+ # formatted string, according to the ERC721 schema and market
62
+ # recommendations. It also embeds the SVG data.
63
+ # The attributes and SVG data are fetched form the CryptoPunksData
64
+ # contract, which stores all the CryptoPunks metadata on-chain.
65
+ # @param _tokenId the punk id
66
+ def tokenURI(_tokenId)
67
+ do_call("tokenURI", _tokenId)
68
+ end
69
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
70
+
71
+
72
+ # function intToString(uint256 value) returns (string)
73
+ #
74
+ def intToString(value)
75
+ do_call("intToString", value)
76
+ end
77
+ sig "intToString", inputs: ["uint256"], outputs: ["string"]
78
+
79
+ end ## class PunksMeta
80
+
@@ -1,7 +1,8 @@
1
- #########################
2
1
  # PunksV1 contract / (blockchain) services / function calls
3
- # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-13 15:31:37 UTC
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:57 UTC
4
4
  # - 14 query functions(s)
5
+ # - 0 helper functions(s)
5
6
  #
6
7
  #
7
8
  # - Pragma: solidity ^0.4.8
@@ -0,0 +1,182 @@
1
+ # SynthPunks contract / (blockchain) services / function calls
2
+ #
3
+ # auto-generated via abigen (see https://rubygems.org/gems/abigen) on 2023-01-15 16:36:48 UTC
4
+ # - 20 query functions(s)
5
+ # - 8 helper functions(s)
6
+
7
+
8
+ class SynthPunks < Ethlite::Contract
9
+
10
+ address "0xaf9ce4b327a3b690abea6f78eccbfefffbea9fdf"
11
+
12
+ # function **_getAttributes**(address _address) ⇒ (uint256[] _) _readonly_
13
+ def _getAttributes(_address)
14
+ do_call("_getAttributes", _address)
15
+ end
16
+ sig "_getAttributes", inputs: ["address"], outputs: ["uint256[]"]
17
+
18
+ # function **_tokenURI**(address _address) ⇒ (string _) _readonly_
19
+ def _tokenURI(_address)
20
+ do_call("_tokenURI", _address)
21
+ end
22
+ sig "_tokenURI", inputs: ["address"], outputs: ["string"]
23
+
24
+ # function **assets**() ⇒ (contract ISyntheticPunksAssets _) _readonly_
25
+ def assets()
26
+ do_call("assets")
27
+ end
28
+ sig "assets", outputs: ["address"]
29
+
30
+ # function **balanceOf**(address _) ⇒ (uint256 _) _readonly_
31
+ def balanceOf(arg0)
32
+ do_call("balanceOf", arg0)
33
+ end
34
+ sig "balanceOf", inputs: ["address"], outputs: ["uint256"]
35
+
36
+ # function **claimMessage**() ⇒ (string _) _readonly_
37
+ def claimMessage()
38
+ do_call("claimMessage")
39
+ end
40
+ sig "claimMessage", outputs: ["string"]
41
+
42
+ # function **claimPrice**() ⇒ (uint256 _) _readonly_
43
+ def claimPrice()
44
+ do_call("claimPrice")
45
+ end
46
+ sig "claimPrice", outputs: ["uint256"]
47
+
48
+ # function **claimed**(address _) ⇒ (bool _) _readonly_
49
+ def claimed(arg0)
50
+ do_call("claimed", arg0)
51
+ end
52
+ sig "claimed", inputs: ["address"], outputs: ["bool"]
53
+
54
+ # function **generatePunkSVG**(uint256[] layers) ⇒ (string _) _readonly_
55
+ def generatePunkSVG(layers)
56
+ do_call("generatePunkSVG", layers)
57
+ end
58
+ sig "generatePunkSVG", inputs: ["uint256[]"], outputs: ["string"]
59
+
60
+ # function **getApproved**(uint256 _) ⇒ (address _) _readonly_
61
+ def getApproved(arg0)
62
+ do_call("getApproved", arg0)
63
+ end
64
+ sig "getApproved", inputs: ["uint256"], outputs: ["address"]
65
+
66
+ # function **getAttribute**(uint256 id, uint256 _attributeId) ⇒ (uint256 _) _readonly_
67
+ def getAttribute(id, _attributeId)
68
+ do_call("getAttribute", id, _attributeId)
69
+ end
70
+ sig "getAttribute", inputs: ["uint256","uint256"], outputs: ["uint256"]
71
+
72
+ # function **getAttributeCategories**(uint256 id) ⇒ (uint256[] _) _readonly_
73
+ def getAttributeCategories(id)
74
+ do_call("getAttributeCategories", id)
75
+ end
76
+ sig "getAttributeCategories", inputs: ["uint256"], outputs: ["uint256[]"]
77
+
78
+ # function **getAttributes**(uint256 id) ⇒ (uint256[] _) _readonly_
79
+ def getAttributes(id)
80
+ do_call("getAttributes", id)
81
+ end
82
+ sig "getAttributes", inputs: ["uint256"], outputs: ["uint256[]"]
83
+
84
+ # function **getGender**(uint256 id) ⇒ (enum SyntheticPunks.Gender _) _readonly_
85
+ def getGender(id)
86
+ do_call("getGender", id)
87
+ end
88
+ sig "getGender", inputs: ["uint256"], outputs: ["uint8"]
89
+
90
+ # function **isApprovedForAll**(address _, address _) ⇒ (bool _) _readonly_
91
+ def isApprovedForAll(arg0, arg1)
92
+ do_call("isApprovedForAll", arg0, arg1)
93
+ end
94
+ sig "isApprovedForAll", inputs: ["address","address"], outputs: ["bool"]
95
+
96
+ # function **name**() ⇒ (string _) _readonly_
97
+ def name()
98
+ do_call("name")
99
+ end
100
+ sig "name", outputs: ["string"]
101
+
102
+ # function **ownerOf**(uint256 _) ⇒ (address _) _readonly_
103
+ def ownerOf(arg0)
104
+ do_call("ownerOf", arg0)
105
+ end
106
+ sig "ownerOf", inputs: ["uint256"], outputs: ["address"]
107
+
108
+ # function **randomUint**(uint256 seed, uint256 offset) ⇒ (uint256 _) _readonly_
109
+ def randomUint(seed, offset)
110
+ do_call("randomUint", seed, offset)
111
+ end
112
+ sig "randomUint", inputs: ["uint256","uint256"], outputs: ["uint256"]
113
+
114
+ # function **symbol**() ⇒ (string _) _readonly_
115
+ def symbol()
116
+ do_call("symbol")
117
+ end
118
+ sig "symbol", outputs: ["string"]
119
+
120
+ # function **tokenURI**(uint256 id) ⇒ (string _) _readonly_
121
+ def tokenURI(id)
122
+ do_call("tokenURI", id)
123
+ end
124
+ sig "tokenURI", inputs: ["uint256"], outputs: ["string"]
125
+
126
+ # function **withdrawAddress**() ⇒ (address _) _readonly_
127
+ def withdrawAddress()
128
+ do_call("withdrawAddress")
129
+ end
130
+ sig "withdrawAddress", outputs: ["address"]
131
+
132
+
133
+ # function **getAddress**(uint256 id) ⇒ (address _) _readonly_
134
+ def getAddress(id)
135
+ do_call("getAddress", id)
136
+ end
137
+ sig "getAddress", inputs: ["uint256"], outputs: ["address"]
138
+
139
+ # function **getEthSignedMessageHash**(bytes32 _messageHash) ⇒ (bytes32 _) _readonly_
140
+ def getEthSignedMessageHash(_messageHash)
141
+ do_call("getEthSignedMessageHash", _messageHash)
142
+ end
143
+ sig "getEthSignedMessageHash", inputs: ["bytes32"], outputs: ["bytes32"]
144
+
145
+ # function **getMessageHash**(string _message) ⇒ (bytes32 _) _readonly_
146
+ def getMessageHash(_message)
147
+ do_call("getMessageHash", _message)
148
+ end
149
+ sig "getMessageHash", inputs: ["string"], outputs: ["bytes32"]
150
+
151
+ # function **getTokenID**(address _address) ⇒ (uint256 _) _readonly_
152
+ def getTokenID(_address)
153
+ do_call("getTokenID", _address)
154
+ end
155
+ sig "getTokenID", inputs: ["address"], outputs: ["uint256"]
156
+
157
+ # function **recoverSigner**(bytes32 _ethSignedMessageHash, bytes _signature) ⇒ (address _) _readonly_
158
+ def recoverSigner(_ethSignedMessageHash, _signature)
159
+ do_call("recoverSigner", _ethSignedMessageHash, _signature)
160
+ end
161
+ sig "recoverSigner", inputs: ["bytes32","bytes"], outputs: ["address"]
162
+
163
+ # function **splitSignature**(bytes sig) ⇒ (bytes32 r, bytes32 s, uint8 v) _readonly_
164
+ def splitSignature(sig)
165
+ do_call("splitSignature", sig)
166
+ end
167
+ sig "splitSignature", inputs: ["bytes"], outputs: ["bytes32","bytes32","uint8"]
168
+
169
+ # function **supportsInterface**(bytes4 interfaceId) ⇒ (bool _) _readonly_
170
+ def supportsInterface(interfaceId)
171
+ do_call("supportsInterface", interfaceId)
172
+ end
173
+ sig "supportsInterface", inputs: ["bytes4"], outputs: ["bool"]
174
+
175
+ # function **verify**(address _signer, string _message, bytes signature) ⇒ (bool _) _readonly_
176
+ def verify(_signer, _message, signature)
177
+ do_call("verify", _signer, _message, signature)
178
+ end
179
+ sig "verify", inputs: ["address","string","bytes"], outputs: ["bool"]
180
+
181
+ end ## class SynthPunks
182
+
@@ -4,7 +4,7 @@ require 'ethlite'
4
4
 
5
5
 
6
6
 
7
- ## out own code
7
+ ## our own code
8
8
 
9
9
  # shared base contract machinery - keep here
10
10
  ## or rename to Base or such - why? why not?
@@ -13,5 +13,13 @@ require_relative 'ethlite/contract'
13
13
  ### generated contracts via abigen
14
14
  require_relative 'ethlite/contracts/punks_v1'
15
15
  require_relative 'ethlite/contracts/punk_blocks'
16
-
16
+ require_relative 'ethlite/contracts/punks_meta'
17
+
18
+ require_relative 'ethlite/contracts/mooncats'
19
+ require_relative 'ethlite/contracts/phunks_v2'
20
+ require_relative 'ethlite/contracts/punks_data'
21
+ require_relative 'ethlite/contracts/synth_punks'
22
+ require_relative 'ethlite/contracts/moonbirds'
23
+ require_relative 'ethlite/contracts/marcs'
24
+ require_relative 'ethlite/contracts/mad_camels'
17
25
 
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: ethlite-contracts
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.1
4
+ version: 0.1.3
5
5
  platform: ruby
6
6
  authors:
7
7
  - Gerald Bauer
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2023-01-13 00:00:00.000000000 Z
11
+ date: 2023-01-15 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: ethlite
@@ -75,8 +75,16 @@ files:
75
75
  - lib/ethlite-contracts.rb
76
76
  - lib/ethlite/contract.rb
77
77
  - lib/ethlite/contracts.rb
78
+ - lib/ethlite/contracts/mad_camels.rb
79
+ - lib/ethlite/contracts/marcs.rb
80
+ - lib/ethlite/contracts/moonbirds.rb
81
+ - lib/ethlite/contracts/mooncats.rb
82
+ - lib/ethlite/contracts/phunks_v2.rb
78
83
  - lib/ethlite/contracts/punk_blocks.rb
84
+ - lib/ethlite/contracts/punks_data.rb
85
+ - lib/ethlite/contracts/punks_meta.rb
79
86
  - lib/ethlite/contracts/punks_v1.rb
87
+ - lib/ethlite/contracts/synth_punks.rb
80
88
  homepage: https://github.com/rubycocos/blockchain
81
89
  licenses:
82
90
  - Public Domain