fluence_marketplace_api_draft/
ierc721errors.rs

1/**
2
3Generated by the following Solidity interface...
4```solidity
5interface IERC721Errors {
6    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
7    error ERC721InsufficientApproval(address operator, uint256 tokenId);
8    error ERC721InvalidApprover(address approver);
9    error ERC721InvalidOperator(address operator);
10    error ERC721InvalidOwner(address owner);
11    error ERC721InvalidReceiver(address receiver);
12    error ERC721InvalidSender(address sender);
13    error ERC721NonexistentToken(uint256 tokenId);
14}
15```
16
17...which was generated by the following JSON ABI:
18```json
19[
20  {
21    "type": "error",
22    "name": "ERC721IncorrectOwner",
23    "inputs": [
24      {
25        "name": "sender",
26        "type": "address",
27        "internalType": "address"
28      },
29      {
30        "name": "tokenId",
31        "type": "uint256",
32        "internalType": "uint256"
33      },
34      {
35        "name": "owner",
36        "type": "address",
37        "internalType": "address"
38      }
39    ]
40  },
41  {
42    "type": "error",
43    "name": "ERC721InsufficientApproval",
44    "inputs": [
45      {
46        "name": "operator",
47        "type": "address",
48        "internalType": "address"
49      },
50      {
51        "name": "tokenId",
52        "type": "uint256",
53        "internalType": "uint256"
54      }
55    ]
56  },
57  {
58    "type": "error",
59    "name": "ERC721InvalidApprover",
60    "inputs": [
61      {
62        "name": "approver",
63        "type": "address",
64        "internalType": "address"
65      }
66    ]
67  },
68  {
69    "type": "error",
70    "name": "ERC721InvalidOperator",
71    "inputs": [
72      {
73        "name": "operator",
74        "type": "address",
75        "internalType": "address"
76      }
77    ]
78  },
79  {
80    "type": "error",
81    "name": "ERC721InvalidOwner",
82    "inputs": [
83      {
84        "name": "owner",
85        "type": "address",
86        "internalType": "address"
87      }
88    ]
89  },
90  {
91    "type": "error",
92    "name": "ERC721InvalidReceiver",
93    "inputs": [
94      {
95        "name": "receiver",
96        "type": "address",
97        "internalType": "address"
98      }
99    ]
100  },
101  {
102    "type": "error",
103    "name": "ERC721InvalidSender",
104    "inputs": [
105      {
106        "name": "sender",
107        "type": "address",
108        "internalType": "address"
109      }
110    ]
111  },
112  {
113    "type": "error",
114    "name": "ERC721NonexistentToken",
115    "inputs": [
116      {
117        "name": "tokenId",
118        "type": "uint256",
119        "internalType": "uint256"
120      }
121    ]
122  }
123]
124```*/
125#[allow(
126    non_camel_case_types,
127    non_snake_case,
128    clippy::pub_underscore_fields,
129    clippy::style,
130    clippy::empty_structs_with_brackets
131)]
132pub mod IERC721Errors {
133    use super::*;
134    use alloy::sol_types as alloy_sol_types;
135    /// The creation / init bytecode of the contract.
136    ///
137    /// ```text
138    ///0x
139    /// ```
140    #[rustfmt::skip]
141    #[allow(clippy::all)]
142    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
143        b"",
144    );
145    /// The runtime bytecode of the contract, as deployed on the network.
146    ///
147    /// ```text
148    ///0x
149    /// ```
150    #[rustfmt::skip]
151    #[allow(clippy::all)]
152    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
153        b"",
154    );
155    /**Custom error with signature `ERC721IncorrectOwner(address,uint256,address)` and selector `0x64283d7b`.
156```solidity
157error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
158```*/
159    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
160    #[derive(Clone)]
161    pub struct ERC721IncorrectOwner {
162        #[allow(missing_docs)]
163        pub sender: alloy::sol_types::private::Address,
164        #[allow(missing_docs)]
165        pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
166        #[allow(missing_docs)]
167        pub owner: alloy::sol_types::private::Address,
168    }
169    #[allow(
170        non_camel_case_types,
171        non_snake_case,
172        clippy::pub_underscore_fields,
173        clippy::style
174    )]
175    const _: () = {
176        use alloy::sol_types as alloy_sol_types;
177        #[doc(hidden)]
178        type UnderlyingSolTuple<'a> = (
179            alloy::sol_types::sol_data::Address,
180            alloy::sol_types::sol_data::Uint<256>,
181            alloy::sol_types::sol_data::Address,
182        );
183        #[doc(hidden)]
184        type UnderlyingRustTuple<'a> = (
185            alloy::sol_types::private::Address,
186            alloy::sol_types::private::primitives::aliases::U256,
187            alloy::sol_types::private::Address,
188        );
189        #[cfg(test)]
190        #[allow(dead_code, unreachable_patterns)]
191        fn _type_assertion(
192            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
193        ) {
194            match _t {
195                alloy_sol_types::private::AssertTypeEq::<
196                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
197                >(_) => {}
198            }
199        }
200        #[automatically_derived]
201        #[doc(hidden)]
202        impl ::core::convert::From<ERC721IncorrectOwner> for UnderlyingRustTuple<'_> {
203            fn from(value: ERC721IncorrectOwner) -> Self {
204                (value.sender, value.tokenId, value.owner)
205            }
206        }
207        #[automatically_derived]
208        #[doc(hidden)]
209        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721IncorrectOwner {
210            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
211                Self {
212                    sender: tuple.0,
213                    tokenId: tuple.1,
214                    owner: tuple.2,
215                }
216            }
217        }
218        #[automatically_derived]
219        impl alloy_sol_types::SolError for ERC721IncorrectOwner {
220            type Parameters<'a> = UnderlyingSolTuple<'a>;
221            type Token<'a> = <Self::Parameters<
222                'a,
223            > as alloy_sol_types::SolType>::Token<'a>;
224            const SIGNATURE: &'static str = "ERC721IncorrectOwner(address,uint256,address)";
225            const SELECTOR: [u8; 4] = [100u8, 40u8, 61u8, 123u8];
226            #[inline]
227            fn new<'a>(
228                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
229            ) -> Self {
230                tuple.into()
231            }
232            #[inline]
233            fn tokenize(&self) -> Self::Token<'_> {
234                (
235                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
236                        &self.sender,
237                    ),
238                    <alloy::sol_types::sol_data::Uint<
239                        256,
240                    > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
241                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
242                        &self.owner,
243                    ),
244                )
245            }
246        }
247    };
248    /**Custom error with signature `ERC721InsufficientApproval(address,uint256)` and selector `0x177e802f`.
249```solidity
250error ERC721InsufficientApproval(address operator, uint256 tokenId);
251```*/
252    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
253    #[derive(Clone)]
254    pub struct ERC721InsufficientApproval {
255        #[allow(missing_docs)]
256        pub operator: alloy::sol_types::private::Address,
257        #[allow(missing_docs)]
258        pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
259    }
260    #[allow(
261        non_camel_case_types,
262        non_snake_case,
263        clippy::pub_underscore_fields,
264        clippy::style
265    )]
266    const _: () = {
267        use alloy::sol_types as alloy_sol_types;
268        #[doc(hidden)]
269        type UnderlyingSolTuple<'a> = (
270            alloy::sol_types::sol_data::Address,
271            alloy::sol_types::sol_data::Uint<256>,
272        );
273        #[doc(hidden)]
274        type UnderlyingRustTuple<'a> = (
275            alloy::sol_types::private::Address,
276            alloy::sol_types::private::primitives::aliases::U256,
277        );
278        #[cfg(test)]
279        #[allow(dead_code, unreachable_patterns)]
280        fn _type_assertion(
281            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
282        ) {
283            match _t {
284                alloy_sol_types::private::AssertTypeEq::<
285                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
286                >(_) => {}
287            }
288        }
289        #[automatically_derived]
290        #[doc(hidden)]
291        impl ::core::convert::From<ERC721InsufficientApproval>
292        for UnderlyingRustTuple<'_> {
293            fn from(value: ERC721InsufficientApproval) -> Self {
294                (value.operator, value.tokenId)
295            }
296        }
297        #[automatically_derived]
298        #[doc(hidden)]
299        impl ::core::convert::From<UnderlyingRustTuple<'_>>
300        for ERC721InsufficientApproval {
301            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
302                Self {
303                    operator: tuple.0,
304                    tokenId: tuple.1,
305                }
306            }
307        }
308        #[automatically_derived]
309        impl alloy_sol_types::SolError for ERC721InsufficientApproval {
310            type Parameters<'a> = UnderlyingSolTuple<'a>;
311            type Token<'a> = <Self::Parameters<
312                'a,
313            > as alloy_sol_types::SolType>::Token<'a>;
314            const SIGNATURE: &'static str = "ERC721InsufficientApproval(address,uint256)";
315            const SELECTOR: [u8; 4] = [23u8, 126u8, 128u8, 47u8];
316            #[inline]
317            fn new<'a>(
318                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
319            ) -> Self {
320                tuple.into()
321            }
322            #[inline]
323            fn tokenize(&self) -> Self::Token<'_> {
324                (
325                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
326                        &self.operator,
327                    ),
328                    <alloy::sol_types::sol_data::Uint<
329                        256,
330                    > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
331                )
332            }
333        }
334    };
335    /**Custom error with signature `ERC721InvalidApprover(address)` and selector `0xa9fbf51f`.
336```solidity
337error ERC721InvalidApprover(address approver);
338```*/
339    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
340    #[derive(Clone)]
341    pub struct ERC721InvalidApprover {
342        #[allow(missing_docs)]
343        pub approver: alloy::sol_types::private::Address,
344    }
345    #[allow(
346        non_camel_case_types,
347        non_snake_case,
348        clippy::pub_underscore_fields,
349        clippy::style
350    )]
351    const _: () = {
352        use alloy::sol_types as alloy_sol_types;
353        #[doc(hidden)]
354        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
355        #[doc(hidden)]
356        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
357        #[cfg(test)]
358        #[allow(dead_code, unreachable_patterns)]
359        fn _type_assertion(
360            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
361        ) {
362            match _t {
363                alloy_sol_types::private::AssertTypeEq::<
364                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
365                >(_) => {}
366            }
367        }
368        #[automatically_derived]
369        #[doc(hidden)]
370        impl ::core::convert::From<ERC721InvalidApprover> for UnderlyingRustTuple<'_> {
371            fn from(value: ERC721InvalidApprover) -> Self {
372                (value.approver,)
373            }
374        }
375        #[automatically_derived]
376        #[doc(hidden)]
377        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidApprover {
378            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
379                Self { approver: tuple.0 }
380            }
381        }
382        #[automatically_derived]
383        impl alloy_sol_types::SolError for ERC721InvalidApprover {
384            type Parameters<'a> = UnderlyingSolTuple<'a>;
385            type Token<'a> = <Self::Parameters<
386                'a,
387            > as alloy_sol_types::SolType>::Token<'a>;
388            const SIGNATURE: &'static str = "ERC721InvalidApprover(address)";
389            const SELECTOR: [u8; 4] = [169u8, 251u8, 245u8, 31u8];
390            #[inline]
391            fn new<'a>(
392                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
393            ) -> Self {
394                tuple.into()
395            }
396            #[inline]
397            fn tokenize(&self) -> Self::Token<'_> {
398                (
399                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
400                        &self.approver,
401                    ),
402                )
403            }
404        }
405    };
406    /**Custom error with signature `ERC721InvalidOperator(address)` and selector `0x5b08ba18`.
407```solidity
408error ERC721InvalidOperator(address operator);
409```*/
410    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
411    #[derive(Clone)]
412    pub struct ERC721InvalidOperator {
413        #[allow(missing_docs)]
414        pub operator: alloy::sol_types::private::Address,
415    }
416    #[allow(
417        non_camel_case_types,
418        non_snake_case,
419        clippy::pub_underscore_fields,
420        clippy::style
421    )]
422    const _: () = {
423        use alloy::sol_types as alloy_sol_types;
424        #[doc(hidden)]
425        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
426        #[doc(hidden)]
427        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
428        #[cfg(test)]
429        #[allow(dead_code, unreachable_patterns)]
430        fn _type_assertion(
431            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
432        ) {
433            match _t {
434                alloy_sol_types::private::AssertTypeEq::<
435                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
436                >(_) => {}
437            }
438        }
439        #[automatically_derived]
440        #[doc(hidden)]
441        impl ::core::convert::From<ERC721InvalidOperator> for UnderlyingRustTuple<'_> {
442            fn from(value: ERC721InvalidOperator) -> Self {
443                (value.operator,)
444            }
445        }
446        #[automatically_derived]
447        #[doc(hidden)]
448        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidOperator {
449            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
450                Self { operator: tuple.0 }
451            }
452        }
453        #[automatically_derived]
454        impl alloy_sol_types::SolError for ERC721InvalidOperator {
455            type Parameters<'a> = UnderlyingSolTuple<'a>;
456            type Token<'a> = <Self::Parameters<
457                'a,
458            > as alloy_sol_types::SolType>::Token<'a>;
459            const SIGNATURE: &'static str = "ERC721InvalidOperator(address)";
460            const SELECTOR: [u8; 4] = [91u8, 8u8, 186u8, 24u8];
461            #[inline]
462            fn new<'a>(
463                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
464            ) -> Self {
465                tuple.into()
466            }
467            #[inline]
468            fn tokenize(&self) -> Self::Token<'_> {
469                (
470                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
471                        &self.operator,
472                    ),
473                )
474            }
475        }
476    };
477    /**Custom error with signature `ERC721InvalidOwner(address)` and selector `0x89c62b64`.
478```solidity
479error ERC721InvalidOwner(address owner);
480```*/
481    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
482    #[derive(Clone)]
483    pub struct ERC721InvalidOwner {
484        #[allow(missing_docs)]
485        pub owner: alloy::sol_types::private::Address,
486    }
487    #[allow(
488        non_camel_case_types,
489        non_snake_case,
490        clippy::pub_underscore_fields,
491        clippy::style
492    )]
493    const _: () = {
494        use alloy::sol_types as alloy_sol_types;
495        #[doc(hidden)]
496        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
497        #[doc(hidden)]
498        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
499        #[cfg(test)]
500        #[allow(dead_code, unreachable_patterns)]
501        fn _type_assertion(
502            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
503        ) {
504            match _t {
505                alloy_sol_types::private::AssertTypeEq::<
506                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
507                >(_) => {}
508            }
509        }
510        #[automatically_derived]
511        #[doc(hidden)]
512        impl ::core::convert::From<ERC721InvalidOwner> for UnderlyingRustTuple<'_> {
513            fn from(value: ERC721InvalidOwner) -> Self {
514                (value.owner,)
515            }
516        }
517        #[automatically_derived]
518        #[doc(hidden)]
519        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidOwner {
520            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
521                Self { owner: tuple.0 }
522            }
523        }
524        #[automatically_derived]
525        impl alloy_sol_types::SolError for ERC721InvalidOwner {
526            type Parameters<'a> = UnderlyingSolTuple<'a>;
527            type Token<'a> = <Self::Parameters<
528                'a,
529            > as alloy_sol_types::SolType>::Token<'a>;
530            const SIGNATURE: &'static str = "ERC721InvalidOwner(address)";
531            const SELECTOR: [u8; 4] = [137u8, 198u8, 43u8, 100u8];
532            #[inline]
533            fn new<'a>(
534                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
535            ) -> Self {
536                tuple.into()
537            }
538            #[inline]
539            fn tokenize(&self) -> Self::Token<'_> {
540                (
541                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
542                        &self.owner,
543                    ),
544                )
545            }
546        }
547    };
548    /**Custom error with signature `ERC721InvalidReceiver(address)` and selector `0x64a0ae92`.
549```solidity
550error ERC721InvalidReceiver(address receiver);
551```*/
552    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
553    #[derive(Clone)]
554    pub struct ERC721InvalidReceiver {
555        #[allow(missing_docs)]
556        pub receiver: alloy::sol_types::private::Address,
557    }
558    #[allow(
559        non_camel_case_types,
560        non_snake_case,
561        clippy::pub_underscore_fields,
562        clippy::style
563    )]
564    const _: () = {
565        use alloy::sol_types as alloy_sol_types;
566        #[doc(hidden)]
567        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
568        #[doc(hidden)]
569        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
570        #[cfg(test)]
571        #[allow(dead_code, unreachable_patterns)]
572        fn _type_assertion(
573            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
574        ) {
575            match _t {
576                alloy_sol_types::private::AssertTypeEq::<
577                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
578                >(_) => {}
579            }
580        }
581        #[automatically_derived]
582        #[doc(hidden)]
583        impl ::core::convert::From<ERC721InvalidReceiver> for UnderlyingRustTuple<'_> {
584            fn from(value: ERC721InvalidReceiver) -> Self {
585                (value.receiver,)
586            }
587        }
588        #[automatically_derived]
589        #[doc(hidden)]
590        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidReceiver {
591            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
592                Self { receiver: tuple.0 }
593            }
594        }
595        #[automatically_derived]
596        impl alloy_sol_types::SolError for ERC721InvalidReceiver {
597            type Parameters<'a> = UnderlyingSolTuple<'a>;
598            type Token<'a> = <Self::Parameters<
599                'a,
600            > as alloy_sol_types::SolType>::Token<'a>;
601            const SIGNATURE: &'static str = "ERC721InvalidReceiver(address)";
602            const SELECTOR: [u8; 4] = [100u8, 160u8, 174u8, 146u8];
603            #[inline]
604            fn new<'a>(
605                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
606            ) -> Self {
607                tuple.into()
608            }
609            #[inline]
610            fn tokenize(&self) -> Self::Token<'_> {
611                (
612                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
613                        &self.receiver,
614                    ),
615                )
616            }
617        }
618    };
619    /**Custom error with signature `ERC721InvalidSender(address)` and selector `0x73c6ac6e`.
620```solidity
621error ERC721InvalidSender(address sender);
622```*/
623    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
624    #[derive(Clone)]
625    pub struct ERC721InvalidSender {
626        #[allow(missing_docs)]
627        pub sender: alloy::sol_types::private::Address,
628    }
629    #[allow(
630        non_camel_case_types,
631        non_snake_case,
632        clippy::pub_underscore_fields,
633        clippy::style
634    )]
635    const _: () = {
636        use alloy::sol_types as alloy_sol_types;
637        #[doc(hidden)]
638        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
639        #[doc(hidden)]
640        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
641        #[cfg(test)]
642        #[allow(dead_code, unreachable_patterns)]
643        fn _type_assertion(
644            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
645        ) {
646            match _t {
647                alloy_sol_types::private::AssertTypeEq::<
648                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
649                >(_) => {}
650            }
651        }
652        #[automatically_derived]
653        #[doc(hidden)]
654        impl ::core::convert::From<ERC721InvalidSender> for UnderlyingRustTuple<'_> {
655            fn from(value: ERC721InvalidSender) -> Self {
656                (value.sender,)
657            }
658        }
659        #[automatically_derived]
660        #[doc(hidden)]
661        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721InvalidSender {
662            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
663                Self { sender: tuple.0 }
664            }
665        }
666        #[automatically_derived]
667        impl alloy_sol_types::SolError for ERC721InvalidSender {
668            type Parameters<'a> = UnderlyingSolTuple<'a>;
669            type Token<'a> = <Self::Parameters<
670                'a,
671            > as alloy_sol_types::SolType>::Token<'a>;
672            const SIGNATURE: &'static str = "ERC721InvalidSender(address)";
673            const SELECTOR: [u8; 4] = [115u8, 198u8, 172u8, 110u8];
674            #[inline]
675            fn new<'a>(
676                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
677            ) -> Self {
678                tuple.into()
679            }
680            #[inline]
681            fn tokenize(&self) -> Self::Token<'_> {
682                (
683                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
684                        &self.sender,
685                    ),
686                )
687            }
688        }
689    };
690    /**Custom error with signature `ERC721NonexistentToken(uint256)` and selector `0x7e273289`.
691```solidity
692error ERC721NonexistentToken(uint256 tokenId);
693```*/
694    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
695    #[derive(Clone)]
696    pub struct ERC721NonexistentToken {
697        #[allow(missing_docs)]
698        pub tokenId: alloy::sol_types::private::primitives::aliases::U256,
699    }
700    #[allow(
701        non_camel_case_types,
702        non_snake_case,
703        clippy::pub_underscore_fields,
704        clippy::style
705    )]
706    const _: () = {
707        use alloy::sol_types as alloy_sol_types;
708        #[doc(hidden)]
709        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
710        #[doc(hidden)]
711        type UnderlyingRustTuple<'a> = (
712            alloy::sol_types::private::primitives::aliases::U256,
713        );
714        #[cfg(test)]
715        #[allow(dead_code, unreachable_patterns)]
716        fn _type_assertion(
717            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
718        ) {
719            match _t {
720                alloy_sol_types::private::AssertTypeEq::<
721                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
722                >(_) => {}
723            }
724        }
725        #[automatically_derived]
726        #[doc(hidden)]
727        impl ::core::convert::From<ERC721NonexistentToken> for UnderlyingRustTuple<'_> {
728            fn from(value: ERC721NonexistentToken) -> Self {
729                (value.tokenId,)
730            }
731        }
732        #[automatically_derived]
733        #[doc(hidden)]
734        impl ::core::convert::From<UnderlyingRustTuple<'_>> for ERC721NonexistentToken {
735            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
736                Self { tokenId: tuple.0 }
737            }
738        }
739        #[automatically_derived]
740        impl alloy_sol_types::SolError for ERC721NonexistentToken {
741            type Parameters<'a> = UnderlyingSolTuple<'a>;
742            type Token<'a> = <Self::Parameters<
743                'a,
744            > as alloy_sol_types::SolType>::Token<'a>;
745            const SIGNATURE: &'static str = "ERC721NonexistentToken(uint256)";
746            const SELECTOR: [u8; 4] = [126u8, 39u8, 50u8, 137u8];
747            #[inline]
748            fn new<'a>(
749                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
750            ) -> Self {
751                tuple.into()
752            }
753            #[inline]
754            fn tokenize(&self) -> Self::Token<'_> {
755                (
756                    <alloy::sol_types::sol_data::Uint<
757                        256,
758                    > as alloy_sol_types::SolType>::tokenize(&self.tokenId),
759                )
760            }
761        }
762    };
763    ///Container for all the [`IERC721Errors`](self) custom errors.
764    pub enum IERC721ErrorsErrors {
765        #[allow(missing_docs)]
766        ERC721IncorrectOwner(ERC721IncorrectOwner),
767        #[allow(missing_docs)]
768        ERC721InsufficientApproval(ERC721InsufficientApproval),
769        #[allow(missing_docs)]
770        ERC721InvalidApprover(ERC721InvalidApprover),
771        #[allow(missing_docs)]
772        ERC721InvalidOperator(ERC721InvalidOperator),
773        #[allow(missing_docs)]
774        ERC721InvalidOwner(ERC721InvalidOwner),
775        #[allow(missing_docs)]
776        ERC721InvalidReceiver(ERC721InvalidReceiver),
777        #[allow(missing_docs)]
778        ERC721InvalidSender(ERC721InvalidSender),
779        #[allow(missing_docs)]
780        ERC721NonexistentToken(ERC721NonexistentToken),
781    }
782    #[automatically_derived]
783    impl IERC721ErrorsErrors {
784        /// All the selectors of this enum.
785        ///
786        /// Note that the selectors might not be in the same order as the variants.
787        /// No guarantees are made about the order of the selectors.
788        ///
789        /// Prefer using `SolInterface` methods instead.
790        pub const SELECTORS: &'static [[u8; 4usize]] = &[
791            [23u8, 126u8, 128u8, 47u8],
792            [91u8, 8u8, 186u8, 24u8],
793            [100u8, 40u8, 61u8, 123u8],
794            [100u8, 160u8, 174u8, 146u8],
795            [115u8, 198u8, 172u8, 110u8],
796            [126u8, 39u8, 50u8, 137u8],
797            [137u8, 198u8, 43u8, 100u8],
798            [169u8, 251u8, 245u8, 31u8],
799        ];
800    }
801    #[automatically_derived]
802    impl alloy_sol_types::SolInterface for IERC721ErrorsErrors {
803        const NAME: &'static str = "IERC721ErrorsErrors";
804        const MIN_DATA_LENGTH: usize = 32usize;
805        const COUNT: usize = 8usize;
806        #[inline]
807        fn selector(&self) -> [u8; 4] {
808            match self {
809                Self::ERC721IncorrectOwner(_) => {
810                    <ERC721IncorrectOwner as alloy_sol_types::SolError>::SELECTOR
811                }
812                Self::ERC721InsufficientApproval(_) => {
813                    <ERC721InsufficientApproval as alloy_sol_types::SolError>::SELECTOR
814                }
815                Self::ERC721InvalidApprover(_) => {
816                    <ERC721InvalidApprover as alloy_sol_types::SolError>::SELECTOR
817                }
818                Self::ERC721InvalidOperator(_) => {
819                    <ERC721InvalidOperator as alloy_sol_types::SolError>::SELECTOR
820                }
821                Self::ERC721InvalidOwner(_) => {
822                    <ERC721InvalidOwner as alloy_sol_types::SolError>::SELECTOR
823                }
824                Self::ERC721InvalidReceiver(_) => {
825                    <ERC721InvalidReceiver as alloy_sol_types::SolError>::SELECTOR
826                }
827                Self::ERC721InvalidSender(_) => {
828                    <ERC721InvalidSender as alloy_sol_types::SolError>::SELECTOR
829                }
830                Self::ERC721NonexistentToken(_) => {
831                    <ERC721NonexistentToken as alloy_sol_types::SolError>::SELECTOR
832                }
833            }
834        }
835        #[inline]
836        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
837            Self::SELECTORS.get(i).copied()
838        }
839        #[inline]
840        fn valid_selector(selector: [u8; 4]) -> bool {
841            Self::SELECTORS.binary_search(&selector).is_ok()
842        }
843        #[inline]
844        #[allow(non_snake_case)]
845        fn abi_decode_raw(
846            selector: [u8; 4],
847            data: &[u8],
848            validate: bool,
849        ) -> alloy_sol_types::Result<Self> {
850            static DECODE_SHIMS: &[fn(
851                &[u8],
852                bool,
853            ) -> alloy_sol_types::Result<IERC721ErrorsErrors>] = &[
854                {
855                    fn ERC721InsufficientApproval(
856                        data: &[u8],
857                        validate: bool,
858                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
859                        <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_decode_raw(
860                                data,
861                                validate,
862                            )
863                            .map(IERC721ErrorsErrors::ERC721InsufficientApproval)
864                    }
865                    ERC721InsufficientApproval
866                },
867                {
868                    fn ERC721InvalidOperator(
869                        data: &[u8],
870                        validate: bool,
871                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
872                        <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw(
873                                data,
874                                validate,
875                            )
876                            .map(IERC721ErrorsErrors::ERC721InvalidOperator)
877                    }
878                    ERC721InvalidOperator
879                },
880                {
881                    fn ERC721IncorrectOwner(
882                        data: &[u8],
883                        validate: bool,
884                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
885                        <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_decode_raw(
886                                data,
887                                validate,
888                            )
889                            .map(IERC721ErrorsErrors::ERC721IncorrectOwner)
890                    }
891                    ERC721IncorrectOwner
892                },
893                {
894                    fn ERC721InvalidReceiver(
895                        data: &[u8],
896                        validate: bool,
897                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
898                        <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_decode_raw(
899                                data,
900                                validate,
901                            )
902                            .map(IERC721ErrorsErrors::ERC721InvalidReceiver)
903                    }
904                    ERC721InvalidReceiver
905                },
906                {
907                    fn ERC721InvalidSender(
908                        data: &[u8],
909                        validate: bool,
910                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
911                        <ERC721InvalidSender as alloy_sol_types::SolError>::abi_decode_raw(
912                                data,
913                                validate,
914                            )
915                            .map(IERC721ErrorsErrors::ERC721InvalidSender)
916                    }
917                    ERC721InvalidSender
918                },
919                {
920                    fn ERC721NonexistentToken(
921                        data: &[u8],
922                        validate: bool,
923                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
924                        <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_decode_raw(
925                                data,
926                                validate,
927                            )
928                            .map(IERC721ErrorsErrors::ERC721NonexistentToken)
929                    }
930                    ERC721NonexistentToken
931                },
932                {
933                    fn ERC721InvalidOwner(
934                        data: &[u8],
935                        validate: bool,
936                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
937                        <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
938                                data,
939                                validate,
940                            )
941                            .map(IERC721ErrorsErrors::ERC721InvalidOwner)
942                    }
943                    ERC721InvalidOwner
944                },
945                {
946                    fn ERC721InvalidApprover(
947                        data: &[u8],
948                        validate: bool,
949                    ) -> alloy_sol_types::Result<IERC721ErrorsErrors> {
950                        <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_decode_raw(
951                                data,
952                                validate,
953                            )
954                            .map(IERC721ErrorsErrors::ERC721InvalidApprover)
955                    }
956                    ERC721InvalidApprover
957                },
958            ];
959            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
960                return Err(
961                    alloy_sol_types::Error::unknown_selector(
962                        <Self as alloy_sol_types::SolInterface>::NAME,
963                        selector,
964                    ),
965                );
966            };
967            DECODE_SHIMS[idx](data, validate)
968        }
969        #[inline]
970        fn abi_encoded_size(&self) -> usize {
971            match self {
972                Self::ERC721IncorrectOwner(inner) => {
973                    <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_encoded_size(
974                        inner,
975                    )
976                }
977                Self::ERC721InsufficientApproval(inner) => {
978                    <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_encoded_size(
979                        inner,
980                    )
981                }
982                Self::ERC721InvalidApprover(inner) => {
983                    <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_encoded_size(
984                        inner,
985                    )
986                }
987                Self::ERC721InvalidOperator(inner) => {
988                    <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_encoded_size(
989                        inner,
990                    )
991                }
992                Self::ERC721InvalidOwner(inner) => {
993                    <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
994                        inner,
995                    )
996                }
997                Self::ERC721InvalidReceiver(inner) => {
998                    <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_encoded_size(
999                        inner,
1000                    )
1001                }
1002                Self::ERC721InvalidSender(inner) => {
1003                    <ERC721InvalidSender as alloy_sol_types::SolError>::abi_encoded_size(
1004                        inner,
1005                    )
1006                }
1007                Self::ERC721NonexistentToken(inner) => {
1008                    <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_encoded_size(
1009                        inner,
1010                    )
1011                }
1012            }
1013        }
1014        #[inline]
1015        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1016            match self {
1017                Self::ERC721IncorrectOwner(inner) => {
1018                    <ERC721IncorrectOwner as alloy_sol_types::SolError>::abi_encode_raw(
1019                        inner,
1020                        out,
1021                    )
1022                }
1023                Self::ERC721InsufficientApproval(inner) => {
1024                    <ERC721InsufficientApproval as alloy_sol_types::SolError>::abi_encode_raw(
1025                        inner,
1026                        out,
1027                    )
1028                }
1029                Self::ERC721InvalidApprover(inner) => {
1030                    <ERC721InvalidApprover as alloy_sol_types::SolError>::abi_encode_raw(
1031                        inner,
1032                        out,
1033                    )
1034                }
1035                Self::ERC721InvalidOperator(inner) => {
1036                    <ERC721InvalidOperator as alloy_sol_types::SolError>::abi_encode_raw(
1037                        inner,
1038                        out,
1039                    )
1040                }
1041                Self::ERC721InvalidOwner(inner) => {
1042                    <ERC721InvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
1043                        inner,
1044                        out,
1045                    )
1046                }
1047                Self::ERC721InvalidReceiver(inner) => {
1048                    <ERC721InvalidReceiver as alloy_sol_types::SolError>::abi_encode_raw(
1049                        inner,
1050                        out,
1051                    )
1052                }
1053                Self::ERC721InvalidSender(inner) => {
1054                    <ERC721InvalidSender as alloy_sol_types::SolError>::abi_encode_raw(
1055                        inner,
1056                        out,
1057                    )
1058                }
1059                Self::ERC721NonexistentToken(inner) => {
1060                    <ERC721NonexistentToken as alloy_sol_types::SolError>::abi_encode_raw(
1061                        inner,
1062                        out,
1063                    )
1064                }
1065            }
1066        }
1067    }
1068    use alloy::contract as alloy_contract;
1069    /**Creates a new wrapper around an on-chain [`IERC721Errors`](self) contract instance.
1070
1071See the [wrapper's documentation](`IERC721ErrorsInstance`) for more details.*/
1072    #[inline]
1073    pub const fn new<
1074        T: alloy_contract::private::Transport + ::core::clone::Clone,
1075        P: alloy_contract::private::Provider<T, N>,
1076        N: alloy_contract::private::Network,
1077    >(
1078        address: alloy_sol_types::private::Address,
1079        provider: P,
1080    ) -> IERC721ErrorsInstance<T, P, N> {
1081        IERC721ErrorsInstance::<T, P, N>::new(address, provider)
1082    }
1083    /**Deploys this contract using the given `provider` and constructor arguments, if any.
1084
1085Returns a new instance of the contract, if the deployment was successful.
1086
1087For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1088    #[inline]
1089    pub fn deploy<
1090        T: alloy_contract::private::Transport + ::core::clone::Clone,
1091        P: alloy_contract::private::Provider<T, N>,
1092        N: alloy_contract::private::Network,
1093    >(
1094        provider: P,
1095    ) -> impl ::core::future::Future<
1096        Output = alloy_contract::Result<IERC721ErrorsInstance<T, P, N>>,
1097    > {
1098        IERC721ErrorsInstance::<T, P, N>::deploy(provider)
1099    }
1100    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1101and constructor arguments, if any.
1102
1103This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1104the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1105    #[inline]
1106    pub fn deploy_builder<
1107        T: alloy_contract::private::Transport + ::core::clone::Clone,
1108        P: alloy_contract::private::Provider<T, N>,
1109        N: alloy_contract::private::Network,
1110    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
1111        IERC721ErrorsInstance::<T, P, N>::deploy_builder(provider)
1112    }
1113    /**A [`IERC721Errors`](self) instance.
1114
1115Contains type-safe methods for interacting with an on-chain instance of the
1116[`IERC721Errors`](self) contract located at a given `address`, using a given
1117provider `P`.
1118
1119If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1120documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1121be used to deploy a new instance of the contract.
1122
1123See the [module-level documentation](self) for all the available methods.*/
1124    #[derive(Clone)]
1125    pub struct IERC721ErrorsInstance<T, P, N = alloy_contract::private::Ethereum> {
1126        address: alloy_sol_types::private::Address,
1127        provider: P,
1128        _network_transport: ::core::marker::PhantomData<(N, T)>,
1129    }
1130    #[automatically_derived]
1131    impl<T, P, N> ::core::fmt::Debug for IERC721ErrorsInstance<T, P, N> {
1132        #[inline]
1133        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1134            f.debug_tuple("IERC721ErrorsInstance").field(&self.address).finish()
1135        }
1136    }
1137    /// Instantiation and getters/setters.
1138    #[automatically_derived]
1139    impl<
1140        T: alloy_contract::private::Transport + ::core::clone::Clone,
1141        P: alloy_contract::private::Provider<T, N>,
1142        N: alloy_contract::private::Network,
1143    > IERC721ErrorsInstance<T, P, N> {
1144        /**Creates a new wrapper around an on-chain [`IERC721Errors`](self) contract instance.
1145
1146See the [wrapper's documentation](`IERC721ErrorsInstance`) for more details.*/
1147        #[inline]
1148        pub const fn new(
1149            address: alloy_sol_types::private::Address,
1150            provider: P,
1151        ) -> Self {
1152            Self {
1153                address,
1154                provider,
1155                _network_transport: ::core::marker::PhantomData,
1156            }
1157        }
1158        /**Deploys this contract using the given `provider` and constructor arguments, if any.
1159
1160Returns a new instance of the contract, if the deployment was successful.
1161
1162For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1163        #[inline]
1164        pub async fn deploy(
1165            provider: P,
1166        ) -> alloy_contract::Result<IERC721ErrorsInstance<T, P, N>> {
1167            let call_builder = Self::deploy_builder(provider);
1168            let contract_address = call_builder.deploy().await?;
1169            Ok(Self::new(contract_address, call_builder.provider))
1170        }
1171        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1172and constructor arguments, if any.
1173
1174This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1175the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1176        #[inline]
1177        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
1178            alloy_contract::RawCallBuilder::new_raw_deploy(
1179                provider,
1180                ::core::clone::Clone::clone(&BYTECODE),
1181            )
1182        }
1183        /// Returns a reference to the address.
1184        #[inline]
1185        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1186            &self.address
1187        }
1188        /// Sets the address.
1189        #[inline]
1190        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1191            self.address = address;
1192        }
1193        /// Sets the address and returns `self`.
1194        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1195            self.set_address(address);
1196            self
1197        }
1198        /// Returns a reference to the provider.
1199        #[inline]
1200        pub const fn provider(&self) -> &P {
1201            &self.provider
1202        }
1203    }
1204    impl<T, P: ::core::clone::Clone, N> IERC721ErrorsInstance<T, &P, N> {
1205        /// Clones the provider and returns a new instance with the cloned provider.
1206        #[inline]
1207        pub fn with_cloned_provider(self) -> IERC721ErrorsInstance<T, P, N> {
1208            IERC721ErrorsInstance {
1209                address: self.address,
1210                provider: ::core::clone::Clone::clone(&self.provider),
1211                _network_transport: ::core::marker::PhantomData,
1212            }
1213        }
1214    }
1215    /// Function calls.
1216    #[automatically_derived]
1217    impl<
1218        T: alloy_contract::private::Transport + ::core::clone::Clone,
1219        P: alloy_contract::private::Provider<T, N>,
1220        N: alloy_contract::private::Network,
1221    > IERC721ErrorsInstance<T, P, N> {
1222        /// Creates a new call builder using this contract instance's provider and address.
1223        ///
1224        /// Note that the call can be any function call, not just those defined in this
1225        /// contract. Prefer using the other methods for building type-safe contract calls.
1226        pub fn call_builder<C: alloy_sol_types::SolCall>(
1227            &self,
1228            call: &C,
1229        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
1230            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1231        }
1232    }
1233    /// Event filters.
1234    #[automatically_derived]
1235    impl<
1236        T: alloy_contract::private::Transport + ::core::clone::Clone,
1237        P: alloy_contract::private::Provider<T, N>,
1238        N: alloy_contract::private::Network,
1239    > IERC721ErrorsInstance<T, P, N> {
1240        /// Creates a new event filter using this contract instance's provider and address.
1241        ///
1242        /// Note that the type can be any event, not just those defined in this contract.
1243        /// Prefer using the other methods for building type-safe event filters.
1244        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1245            &self,
1246        ) -> alloy_contract::Event<T, &P, E, N> {
1247            alloy_contract::Event::new_sol(&self.provider, &self.address)
1248        }
1249    }
1250}
fluence_marketplace_api_draft/ierc721errors.rs

fluence_marketplace_api_draft/
ierc721errors.rs
