git.delta.rocks / unique-network / refs/commits / ac37b714b860

10}10}
1111
12contract ContractHelpers is Dummy {12contract ContractHelpers is Dummy {
13	// Selector: contractOwner(address) 5152b14c
13	function contractOwner(address contractAddress)14	function contractOwner(address contractAddress)
14		public15		public
15		view16		view
21		return 0x0000000000000000000000000000000000000000;22		return 0x0000000000000000000000000000000000000000;
22	}23	}
2324
25	// Selector: sponsoringEnabled(address) 6027dc61
24	function sponsoringEnabled(address contractAddress)26	function sponsoringEnabled(address contractAddress)
25		public27		public
26		view28		view
32		return false;34		return false;
33	}35	}
3436
37	// Selector: toggleSponsoring(address,bool) fcac6d86
35	function toggleSponsoring(address contractAddress, bool enabled) public {38	function toggleSponsoring(address contractAddress, bool enabled) public {
36		require(false, stub_error);39		require(false, stub_error);
37		contractAddress;40		contractAddress;
38		enabled;41		enabled;
39		dummy = 0;42		dummy = 0;
40	}43	}
4144
45	// Selector: setSponsoringRateLimit(address,uint32) 77b6c908
42	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)46	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
43		public47		public
44	{48	{
48		dummy = 0;52		dummy = 0;
49	}53	}
5054
55	// Selector: allowed(address,address) 5c658165
51	function allowed(address contractAddress, address user)56	function allowed(address contractAddress, address user)
52		public57		public
53		view58		view
60		return false;65		return false;
61	}66	}
6267
68	// Selector: allowlistEnabled(address) c772ef6c
63	function allowlistEnabled(address contractAddress)69	function allowlistEnabled(address contractAddress)
64		public70		public
65		view71		view
71		return false;77		return false;
72	}78	}
7379
80	// Selector: toggleAllowlist(address,bool) 36de20f5
74	function toggleAllowlist(address contractAddress, bool enabled) public {81	function toggleAllowlist(address contractAddress, bool enabled) public {
75		require(false, stub_error);82		require(false, stub_error);
76		contractAddress;83		contractAddress;
77		enabled;84		enabled;
78		dummy = 0;85		dummy = 0;
79	}86	}
8087
88	// Selector: toggleAllowed(address,address,bool) 4706cc1c
81	function toggleAllowed(89	function toggleAllowed(
82		address contractAddress,90		address contractAddress,
83		address user,91		address user,

2121
22// Inline22// Inline
23contract InlineNameSymbol is Dummy {23contract InlineNameSymbol is Dummy {
24	// Selector: name() 06fdde03
24	function name() public view returns (string memory) {25	function name() public view returns (string memory) {
25		require(false, stub_error);26		require(false, stub_error);
26		dummy;27		dummy;
27		return "";28		return "";
28	}29	}
2930
31	// Selector: symbol() 95d89b41
30	function symbol() public view returns (string memory) {32	function symbol() public view returns (string memory) {
31		require(false, stub_error);33		require(false, stub_error);
32		dummy;34		dummy;
3638
37// Inline39// Inline
38contract InlineTotalSupply is Dummy {40contract InlineTotalSupply is Dummy {
41	// Selector: totalSupply() 18160ddd
39	function totalSupply() public view returns (uint256) {42	function totalSupply() public view returns (uint256) {
40		require(false, stub_error);43		require(false, stub_error);
41		dummy;44		dummy;
44}47}
4548
46contract ERC165 is Dummy {49contract ERC165 is Dummy {
50	// Selector: supportsInterface(bytes4) 01ffc9a7
47	function supportsInterface(uint32 interfaceId) public view returns (bool) {51	function supportsInterface(uint32 interfaceId) public view returns (bool) {
48		require(false, stub_error);52		require(false, stub_error);
49		interfaceId;53		interfaceId;
53}57}
5458
55contract ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {59contract ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {
60	// Selector: decimals() 313ce567
56	function decimals() public view returns (uint8) {61	function decimals() public view returns (uint8) {
57		require(false, stub_error);62		require(false, stub_error);
58		dummy;63		dummy;
59		return 0;64		return 0;
60	}65	}
6166
67	// Selector: balanceOf(address) 70a08231
62	function balanceOf(address owner) public view returns (uint256) {68	function balanceOf(address owner) public view returns (uint256) {
63		require(false, stub_error);69		require(false, stub_error);
64		owner;70		owner;
65		dummy;71		dummy;
66		return 0;72		return 0;
67	}73	}
6874
75	// Selector: transfer(address,uint256) a9059cbb
69	function transfer(address to, uint256 amount) public returns (bool) {76	function transfer(address to, uint256 amount) public returns (bool) {
70		require(false, stub_error);77		require(false, stub_error);
71		to;78		to;
74		return false;81		return false;
75	}82	}
7683
84	// Selector: transferFrom(address,address,uint256) 23b872dd
77	function transferFrom(85	function transferFrom(
78		address from,86		address from,
79		address to,87		address to,
87		return false;95		return false;
88	}96	}
8997
98	// Selector: approve(address,uint256) 095ea7b3
90	function approve(address spender, uint256 amount) public returns (bool) {99	function approve(address spender, uint256 amount) public returns (bool) {
91		require(false, stub_error);100		require(false, stub_error);
92		spender;101		spender;
95		return false;104		return false;
96	}105	}
97106
107	// Selector: allowance(address,address) dd62ed3e
98	function allowance(address owner, address spender)108	function allowance(address owner, address spender)
99		public109		public
100		view110		view

4141
42// Inline42// Inline
43contract InlineNameSymbol is Dummy {43contract InlineNameSymbol is Dummy {
44	// Selector: name() 06fdde03
44	function name() public view returns (string memory) {45	function name() public view returns (string memory) {
45		require(false, stub_error);46		require(false, stub_error);
46		dummy;47		dummy;
47		return "";48		return "";
48	}49	}
4950
51	// Selector: symbol() 95d89b41
50	function symbol() public view returns (string memory) {52	function symbol() public view returns (string memory) {
51		require(false, stub_error);53		require(false, stub_error);
52		dummy;54		dummy;
5658
57// Inline59// Inline
58contract InlineTotalSupply is Dummy {60contract InlineTotalSupply is Dummy {
61	// Selector: totalSupply() 18160ddd
59	function totalSupply() public view returns (uint256) {62	function totalSupply() public view returns (uint256) {
60		require(false, stub_error);63		require(false, stub_error);
61		dummy;64		dummy;
64}67}
6568
66contract ERC165 is Dummy {69contract ERC165 is Dummy {
70	// Selector: supportsInterface(bytes4) 01ffc9a7
67	function supportsInterface(uint32 interfaceId) public view returns (bool) {71	function supportsInterface(uint32 interfaceId) public view returns (bool) {
68		require(false, stub_error);72		require(false, stub_error);
69		interfaceId;73		interfaceId;
73}77}
7478
75contract ERC721 is Dummy, ERC165, ERC721Events {79contract ERC721 is Dummy, ERC165, ERC721Events {
80	// Selector: balanceOf(address) 70a08231
76	function balanceOf(address owner) public view returns (uint256) {81	function balanceOf(address owner) public view returns (uint256) {
77		require(false, stub_error);82		require(false, stub_error);
78		owner;83		owner;
79		dummy;84		dummy;
80		return 0;85		return 0;
81	}86	}
8287
88	// Selector: ownerOf(uint256) 6352211e
83	function ownerOf(uint256 tokenId) public view returns (address) {89	function ownerOf(uint256 tokenId) public view returns (address) {
84		require(false, stub_error);90		require(false, stub_error);
85		tokenId;91		tokenId;
86		dummy;92		dummy;
87		return 0x0000000000000000000000000000000000000000;93		return 0x0000000000000000000000000000000000000000;
88	}94	}
8995
96	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
90	function safeTransferFromWithData(97	function safeTransferFromWithData(
91		address from,98		address from,
92		address to,99		address to,
101		dummy = 0;108		dummy = 0;
102	}109	}
103110
111	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
104	function safeTransferFrom(112	function safeTransferFrom(
105		address from,113		address from,
106		address to,114		address to,
113		dummy = 0;121		dummy = 0;
114	}122	}
115123
124	// Selector: transferFrom(address,address,uint256) 23b872dd
116	function transferFrom(125	function transferFrom(
117		address from,126		address from,
118		address to,127		address to,
125		dummy = 0;134		dummy = 0;
126	}135	}
127136
137	// Selector: approve(address,uint256) 095ea7b3
128	function approve(address approved, uint256 tokenId) public {138	function approve(address approved, uint256 tokenId) public {
129		require(false, stub_error);139		require(false, stub_error);
130		approved;140		approved;
131		tokenId;141		tokenId;
132		dummy = 0;142		dummy = 0;
133	}143	}
134144
145	// Selector: setApprovalForAll(address,bool) a22cb465
135	function setApprovalForAll(address operator, bool approved) public {146	function setApprovalForAll(address operator, bool approved) public {
136		require(false, stub_error);147		require(false, stub_error);
137		operator;148		operator;
138		approved;149		approved;
139		dummy = 0;150		dummy = 0;
140	}151	}
141152
153	// Selector: getApproved(uint256) 081812fc
142	function getApproved(uint256 tokenId) public view returns (address) {154	function getApproved(uint256 tokenId) public view returns (address) {
143		require(false, stub_error);155		require(false, stub_error);
144		tokenId;156		tokenId;
145		dummy;157		dummy;
146		return 0x0000000000000000000000000000000000000000;158		return 0x0000000000000000000000000000000000000000;
147	}159	}
148160
161	// Selector: isApprovedForAll(address,address) e985e9c5
149	function isApprovedForAll(address owner, address operator)162	function isApprovedForAll(address owner, address operator)
150		public163		public
151		view164		view
160}173}
161174
162contract ERC721Burnable is Dummy {175contract ERC721Burnable is Dummy {
176	// Selector: burn(uint256) 42966c68
163	function burn(uint256 tokenId) public {177	function burn(uint256 tokenId) public {
164		require(false, stub_error);178		require(false, stub_error);
165		tokenId;179		tokenId;
168}182}
169183
170contract ERC721Enumerable is Dummy, InlineTotalSupply {184contract ERC721Enumerable is Dummy, InlineTotalSupply {
185	// Selector: tokenByIndex(uint256) 4f6ccce7
171	function tokenByIndex(uint256 index) public view returns (uint256) {186	function tokenByIndex(uint256 index) public view returns (uint256) {
172		require(false, stub_error);187		require(false, stub_error);
173		index;188		index;
174		dummy;189		dummy;
175		return 0;190		return 0;
176	}191	}
177192
193	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
178	function tokenOfOwnerByIndex(address owner, uint256 index)194	function tokenOfOwnerByIndex(address owner, uint256 index)
179		public195		public
180		view196		view
189}205}
190206
191contract ERC721Metadata is Dummy, InlineNameSymbol {207contract ERC721Metadata is Dummy, InlineNameSymbol {
208	// Selector: tokenURI(uint256) c87b56dd
192	function tokenURI(uint256 tokenId) public view returns (string memory) {209	function tokenURI(uint256 tokenId) public view returns (string memory) {
193		require(false, stub_error);210		require(false, stub_error);
194		tokenId;211		tokenId;
198}215}
199216
200contract ERC721Mintable is Dummy, ERC721MintableEvents {217contract ERC721Mintable is Dummy, ERC721MintableEvents {
218	// Selector: mintingFinished() 05d2035b
201	function mintingFinished() public view returns (bool) {219	function mintingFinished() public view returns (bool) {
202		require(false, stub_error);220		require(false, stub_error);
203		dummy;221		dummy;
204		return false;222		return false;
205	}223	}
206224
225	// Selector: mint(address,uint256) 40c10f19
207	function mint(address to, uint256 tokenId) public returns (bool) {226	function mint(address to, uint256 tokenId) public returns (bool) {
208		require(false, stub_error);227		require(false, stub_error);
209		to;228		to;
212		return false;231		return false;
213	}232	}
214233
234	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
215	function mintWithTokenURI(235	function mintWithTokenURI(
216		address to,236		address to,
217		uint256 tokenId,237		uint256 tokenId,
225		return false;245		return false;
226	}246	}
227247
248	// Selector: finishMinting() 7d64bcb4
228	function finishMinting() public returns (bool) {249	function finishMinting() public returns (bool) {
229		require(false, stub_error);250		require(false, stub_error);
230		dummy = 0;251		dummy = 0;
233}254}
234255
235contract ERC721UniqueExtensions is Dummy {256contract ERC721UniqueExtensions is Dummy {
257	// Selector: transfer(address,uint256) a9059cbb
236	function transfer(address to, uint256 tokenId) public {258	function transfer(address to, uint256 tokenId) public {
237		require(false, stub_error);259		require(false, stub_error);
238		to;260		to;
239		tokenId;261		tokenId;
240		dummy = 0;262		dummy = 0;
241	}263	}
242264
265	// Selector: nextTokenId() 75794a3c
243	function nextTokenId() public view returns (uint256) {266	function nextTokenId() public view returns (uint256) {
244		require(false, stub_error);267		require(false, stub_error);
245		dummy;268		dummy;

9}9}
1010
11interface ContractHelpers is Dummy {11interface ContractHelpers is Dummy {
12	// Selector: contractOwner(address) 5152b14c
12	function contractOwner(address contractAddress)13	function contractOwner(address contractAddress)
13		external14		external
14		view15		view
15		returns (address);16		returns (address);
1617
18	// Selector: sponsoringEnabled(address) 6027dc61
17	function sponsoringEnabled(address contractAddress)19	function sponsoringEnabled(address contractAddress)
18		external20		external
19		view21		view
20		returns (bool);22		returns (bool);
2123
24	// Selector: toggleSponsoring(address,bool) fcac6d86
22	function toggleSponsoring(address contractAddress, bool enabled) external;25	function toggleSponsoring(address contractAddress, bool enabled) external;
2326
27	// Selector: setSponsoringRateLimit(address,uint32) 77b6c908
24	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)28	function setSponsoringRateLimit(address contractAddress, uint32 rateLimit)
25		external;29		external;
2630
31	// Selector: allowed(address,address) 5c658165
27	function allowed(address contractAddress, address user)32	function allowed(address contractAddress, address user)
28		external33		external
29		view34		view
30		returns (bool);35		returns (bool);
3136
37	// Selector: allowlistEnabled(address) c772ef6c
32	function allowlistEnabled(address contractAddress)38	function allowlistEnabled(address contractAddress)
33		external39		external
34		view40		view
35		returns (bool);41		returns (bool);
3642
43	// Selector: toggleAllowlist(address,bool) 36de20f5
37	function toggleAllowlist(address contractAddress, bool enabled) external;44	function toggleAllowlist(address contractAddress, bool enabled) external;
3845
46	// Selector: toggleAllowed(address,address,bool) 4706cc1c
39	function toggleAllowed(47	function toggleAllowed(
40		address contractAddress,48		address contractAddress,
41		address user,49		address user,

2020
21// Inline21// Inline
22interface InlineNameSymbol is Dummy {22interface InlineNameSymbol is Dummy {
23	// Selector: name() 06fdde03
23	function name() external view returns (string memory);24	function name() external view returns (string memory);
2425
26	// Selector: symbol() 95d89b41
25	function symbol() external view returns (string memory);27	function symbol() external view returns (string memory);
26}28}
2729
28// Inline30// Inline
29interface InlineTotalSupply is Dummy {31interface InlineTotalSupply is Dummy {
32	// Selector: totalSupply() 18160ddd
30	function totalSupply() external view returns (uint256);33	function totalSupply() external view returns (uint256);
31}34}
3235
33interface ERC165 is Dummy {36interface ERC165 is Dummy {
37	// Selector: supportsInterface(bytes4) 01ffc9a7
34	function supportsInterface(uint32 interfaceId) external view returns (bool);38	function supportsInterface(uint32 interfaceId) external view returns (bool);
35}39}
3640
37interface ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {41interface ERC20 is Dummy, InlineNameSymbol, InlineTotalSupply, ERC20Events {
42	// Selector: decimals() 313ce567
38	function decimals() external view returns (uint8);43	function decimals() external view returns (uint8);
3944
45	// Selector: balanceOf(address) 70a08231
40	function balanceOf(address owner) external view returns (uint256);46	function balanceOf(address owner) external view returns (uint256);
4147
48	// Selector: transfer(address,uint256) a9059cbb
42	function transfer(address to, uint256 amount) external returns (bool);49	function transfer(address to, uint256 amount) external returns (bool);
4350
51	// Selector: transferFrom(address,address,uint256) 23b872dd
44	function transferFrom(52	function transferFrom(
45		address from,53		address from,
46		address to,54		address to,
47		uint256 amount55		uint256 amount
48	) external returns (bool);56	) external returns (bool);
4957
58	// Selector: approve(address,uint256) 095ea7b3
50	function approve(address spender, uint256 amount) external returns (bool);59	function approve(address spender, uint256 amount) external returns (bool);
5160
61	// Selector: allowance(address,address) dd62ed3e
52	function allowance(address owner, address spender)62	function allowance(address owner, address spender)
53		external63		external
54		view64		view

4040
41// Inline41// Inline
42interface InlineNameSymbol is Dummy {42interface InlineNameSymbol is Dummy {
43	// Selector: name() 06fdde03
43	function name() external view returns (string memory);44	function name() external view returns (string memory);
4445
46	// Selector: symbol() 95d89b41
45	function symbol() external view returns (string memory);47	function symbol() external view returns (string memory);
46}48}
4749
48// Inline50// Inline
49interface InlineTotalSupply is Dummy {51interface InlineTotalSupply is Dummy {
52	// Selector: totalSupply() 18160ddd
50	function totalSupply() external view returns (uint256);53	function totalSupply() external view returns (uint256);
51}54}
5255
53interface ERC165 is Dummy {56interface ERC165 is Dummy {
57	// Selector: supportsInterface(bytes4) 01ffc9a7
54	function supportsInterface(uint32 interfaceId) external view returns (bool);58	function supportsInterface(uint32 interfaceId) external view returns (bool);
55}59}
5660
57interface ERC721 is Dummy, ERC165, ERC721Events {61interface ERC721 is Dummy, ERC165, ERC721Events {
62	// Selector: balanceOf(address) 70a08231
58	function balanceOf(address owner) external view returns (uint256);63	function balanceOf(address owner) external view returns (uint256);
5964
65	// Selector: ownerOf(uint256) 6352211e
60	function ownerOf(uint256 tokenId) external view returns (address);66	function ownerOf(uint256 tokenId) external view returns (address);
6167
68	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
62	function safeTransferFromWithData(69	function safeTransferFromWithData(
63		address from,70		address from,
64		address to,71		address to,
65		uint256 tokenId,72		uint256 tokenId,
66		bytes memory data73		bytes memory data
67	) external;74	) external;
6875
76	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
69	function safeTransferFrom(77	function safeTransferFrom(
70		address from,78		address from,
71		address to,79		address to,
72		uint256 tokenId80		uint256 tokenId
73	) external;81	) external;
7482
83	// Selector: transferFrom(address,address,uint256) 23b872dd
75	function transferFrom(84	function transferFrom(
76		address from,85		address from,
77		address to,86		address to,
78		uint256 tokenId87		uint256 tokenId
79	) external;88	) external;
8089
90	// Selector: approve(address,uint256) 095ea7b3
81	function approve(address approved, uint256 tokenId) external;91	function approve(address approved, uint256 tokenId) external;
8292
93	// Selector: setApprovalForAll(address,bool) a22cb465
83	function setApprovalForAll(address operator, bool approved) external;94	function setApprovalForAll(address operator, bool approved) external;
8495
96	// Selector: getApproved(uint256) 081812fc
85	function getApproved(uint256 tokenId) external view returns (address);97	function getApproved(uint256 tokenId) external view returns (address);
8698
99	// Selector: isApprovedForAll(address,address) e985e9c5
87	function isApprovedForAll(address owner, address operator)100	function isApprovedForAll(address owner, address operator)
88		external101		external
89		view102		view
90		returns (address);103		returns (address);
91}104}
92105
93interface ERC721Burnable is Dummy {106interface ERC721Burnable is Dummy {
107	// Selector: burn(uint256) 42966c68
94	function burn(uint256 tokenId) external;108	function burn(uint256 tokenId) external;
95}109}
96110
97interface ERC721Enumerable is Dummy, InlineTotalSupply {111interface ERC721Enumerable is Dummy, InlineTotalSupply {
112	// Selector: tokenByIndex(uint256) 4f6ccce7
98	function tokenByIndex(uint256 index) external view returns (uint256);113	function tokenByIndex(uint256 index) external view returns (uint256);
99114
115	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
100	function tokenOfOwnerByIndex(address owner, uint256 index)116	function tokenOfOwnerByIndex(address owner, uint256 index)
101		external117		external
102		view118		view
103		returns (uint256);119		returns (uint256);
104}120}
105121
106interface ERC721Metadata is Dummy, InlineNameSymbol {122interface ERC721Metadata is Dummy, InlineNameSymbol {
123	// Selector: tokenURI(uint256) c87b56dd
107	function tokenURI(uint256 tokenId) external view returns (string memory);124	function tokenURI(uint256 tokenId) external view returns (string memory);
108}125}
109126
110interface ERC721Mintable is Dummy, ERC721MintableEvents {127interface ERC721Mintable is Dummy, ERC721MintableEvents {
128	// Selector: mintingFinished() 05d2035b
111	function mintingFinished() external view returns (bool);129	function mintingFinished() external view returns (bool);
112130
131	// Selector: mint(address,uint256) 40c10f19
113	function mint(address to, uint256 tokenId) external returns (bool);132	function mint(address to, uint256 tokenId) external returns (bool);
114133
134	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
115	function mintWithTokenURI(135	function mintWithTokenURI(
116		address to,136		address to,
117		uint256 tokenId,137		uint256 tokenId,
118		string memory tokenUri138		string memory tokenUri
119	) external returns (bool);139	) external returns (bool);
120140
141	// Selector: finishMinting() 7d64bcb4
121	function finishMinting() external returns (bool);142	function finishMinting() external returns (bool);
122}143}
123144
124interface ERC721UniqueExtensions is Dummy {145interface ERC721UniqueExtensions is Dummy {
146	// Selector: transfer(address,uint256) a9059cbb
125	function transfer(address to, uint256 tokenId) external;147	function transfer(address to, uint256 tokenId) external;
126148
149	// Selector: nextTokenId() 75794a3c
127	function nextTokenId() external view returns (uint256);150	function nextTokenId() external view returns (uint256);
128151
129	// Selector: setVariableMetadata(uint256,bytes) d4eac26d152	// Selector: setVariableMetadata(uint256,bytes) d4eac26d