Smart Contract
Eternity
A.28eab429d0e72f0d.Eternity
1import FlowToken from 0x1654653399040a61
2import FungibleToken from 0xf233dcee88fe0abe
3import NonFungibleToken from 0x1d7e57aa55817448
4import MetadataViews from 0x1d7e57aa55817448
5import ViewResolver from 0x1d7e57aa55817448
6
7access(all)
8// ALL
9contract Eternity: NonFungibleToken, ViewResolver {
10 access(all)
11 fun mint(recipient: Address, description: String, image: String, payment: @{FungibleToken.Vault}) {
12 pre {
13 payment.balance == 0.25: "No Free Luigi Allowed(payment is not 0.25 FLOW) "
14 }
15 let nft <- create NFT(description: description, image: image)
16 if let recipientCollection = getAccount(recipient)
17 .capabilities.borrow<&{NonFungibleToken.Receiver}>(Eternity.CollectionPublicPath)
18 {
19 recipientCollection.deposit(token: <- nft)
20 } else {
21 destroy nft
22 }
23 let EternalTreasury = getAccount(Eternity.account.address).capabilities.borrow<&{FungibleToken.Receiver}>(/public/flowTokenReceiver)!
24 EternalTreasury.deposit(from: <- payment)
25 }
26 access(all) view fun getContractViews(resourceType: Type?): [Type] {
27 return [
28 Type<MetadataViews.NFTCollectionData>(),
29 Type<MetadataViews.NFTCollectionDisplay>(),
30 Type<MetadataViews.EVMBridgedMetadata>()
31 ]
32 }
33 access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
34 switch viewType {
35 case Type<MetadataViews.NFTCollectionData>():
36 let collectionData = MetadataViews.NFTCollectionData(
37 storagePath: self.CollectionStoragePath,
38 publicPath: self.CollectionPublicPath,
39 publicCollection: Type<&Eternity.Collection>(),
40 publicLinkedType: Type<&Eternity.Collection>(),
41 createEmptyCollectionFunction: (fun (): @{NonFungibleToken.Collection} {
42 return <-Eternity.createEmptyCollection(nftType: Type<@Eternity.NFT>())
43 })
44 )
45 return collectionData
46 case Type<MetadataViews.NFTCollectionDisplay>():
47 let media = MetadataViews.Media(
48 file: MetadataViews.HTTPFile(
49 url: "https://img.cryptokitties.co/0x06012c8cf97bead5deae237070f9587f8e7a266d/824576.png"
50 ),
51 mediaType: "image/png"
52 )
53 return MetadataViews.NFTCollectionDisplay(
54 name: "Eternity",
55 description: "Eternity and Zen governance.",
56 externalURL: MetadataViews.ExternalURL("https://Eternity.gg/"),
57 squareImage: media,
58 bannerImage: media,
59 socials: {
60 "twitter": MetadataViews.ExternalURL("https://twitter.com/Eternity")
61 }
62 )
63 }
64 return nil
65 }
66 access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} {
67 return <- create Collection()
68 }
69 access(all) resource Collection: NonFungibleToken.Collection {
70 access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
71 init () {
72 self.ownedNFTs <- {}
73 }
74 access(all) view fun getSupportedNFTTypes(): {Type: Bool} {
75 let supportedTypes: {Type: Bool} = {}
76 supportedTypes[Type<@Eternity.NFT>()] = true
77 return supportedTypes
78 }
79 access(all) view fun isSupportedNFTType(type: Type): Bool {
80 return type == Type<@Eternity.NFT>()
81 }
82 access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
83 let token <- self.ownedNFTs.remove(key: withdrawID)
84 ?? panic("This Collection doesn't own a Eternity by id: ".concat(withdrawID.toString()))
85
86 emit Withdraw(id: token.id, from: self.owner?.address)
87
88 return <-token
89 }
90 access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
91 let newEternity <- token as! @NFT
92 let id: UInt64 = newEternity.id
93 let oldEternity <- self.ownedNFTs[id] <- newEternity
94 destroy oldEternity
95
96 emit Deposit(id: id, to: self.owner?.address)
97 }
98
99 access(all) view fun getIDs(): [UInt64] {
100 return self.ownedNFTs.keys
101 }
102 access(all) view fun getLength(): Int {
103 return self.ownedNFTs.length
104 }
105
106 access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
107 return &self.ownedNFTs[id]
108 }
109
110 access(all) view fun borrowViewResolver(id: UInt64): &{ViewResolver.Resolver}? {
111 if let nft = &self.ownedNFTs[id] as &{NonFungibleToken.NFT}? {
112 return nft as &{ViewResolver.Resolver}
113 }
114 return nil
115 }
116 access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
117 return <-Eternity.createEmptyCollection(nftType: Type<@Eternity.NFT>())
118 }
119 }
120 init() {
121 let identifier = "Eternity_".concat(self.account.address.toString())
122 self.CollectionStoragePath = StoragePath(identifier: identifier)!
123 self.CollectionPublicPath = PublicPath(identifier: identifier)!
124 self.CollectionPrivatePath = PrivatePath(identifier: identifier)!
125 self.totalSupply = 0
126
127 let collection <- create Collection()
128 self.account.storage.save(<- collection, to: self.CollectionStoragePath)
129 let collectionCap = self.account.capabilities.storage.issue<&Eternity.Collection>(self.CollectionStoragePath)
130 self.account.capabilities.publish(collectionCap, at: self.CollectionPublicPath)
131 }
132
133
134 access(all) var totalSupply: UInt64
135 access(all) event ContractInitialized()
136 access(all) event Withdraw(id: UInt64, from: Address?)
137 access(all) event Deposit(id: UInt64, to: Address?)
138 access(all) event uploadedImg(id: UInt64)
139 access(all) let CollectionStoragePath: StoragePath
140 access(all) let CollectionPublicPath: PublicPath
141 access(all) let CollectionPrivatePath: PrivatePath
142
143 access(all) resource NFT: NonFungibleToken.NFT {
144 init(description: String, image: String) {
145 Eternity.totalSupply = Eternity.totalSupply + 1
146 self.id = Eternity.totalSupply
147 self.description = description
148 self.image = image
149 }
150 access(all) let id: UInt64
151 access(all) let description: String
152 access(all) let image: String
153
154
155 access(all) fun createEmptyCollection(): @{NonFungibleToken.Collection} {
156 return <- Eternity.createEmptyCollection(nftType: Type<@Eternity.NFT>())
157 }
158 access(all) view fun getViews(): [Type] {
159 return [
160 Type<MetadataViews.Display>(),
161 Type<MetadataViews.Royalties>(),
162 Type<MetadataViews.Editions>(),
163 Type<MetadataViews.ExternalURL>(),
164 Type<MetadataViews.NFTCollectionData>(),
165 Type<MetadataViews.NFTCollectionDisplay>(),
166 Type<MetadataViews.Serial>(),
167 Type<MetadataViews.Traits>(),
168 Type<MetadataViews.EVMBridgedMetadata>()
169 ]
170 }
171 access(all) fun resolveView(_ view: Type): AnyStruct? {
172 switch view {
173 case Type<MetadataViews.Display>():
174 return MetadataViews.Display(
175 name: "Eternity #".concat(self.id.toString()),
176 description: self.description,
177 thumbnail: MetadataViews.HTTPFile(
178 url: "data:image/png;base64,".concat(self.image)
179 )
180 )
181 case Type<MetadataViews.Traits>():
182 return MetadataViews.dictToTraits(dict: {}, excludedNames: nil)
183 case Type<MetadataViews.NFTView>():
184 return MetadataViews.NFTView(
185 id: self.id,
186 uuid: self.uuid,
187 display: self.resolveView(Type<MetadataViews.Display>()) as! MetadataViews.Display?,
188 externalURL: self.resolveView(Type<MetadataViews.ExternalURL>()) as! MetadataViews.ExternalURL?,
189 collectionData: self.resolveView(Type<MetadataViews.NFTCollectionData>()) as! MetadataViews.NFTCollectionData?,
190 collectionDisplay: self.resolveView(Type<MetadataViews.NFTCollectionDisplay>()) as! MetadataViews.NFTCollectionDisplay?,
191 royalties: self.resolveView(Type<MetadataViews.Royalties>()) as! MetadataViews.Royalties?,
192 traits: self.resolveView(Type<MetadataViews.Traits>()) as! MetadataViews.Traits?
193 )
194 case Type<MetadataViews.NFTCollectionData>():
195 return Eternity.resolveContractView(resourceType: Type<@Eternity.NFT>(), viewType: Type<MetadataViews.NFTCollectionData>())
196 case Type<MetadataViews.ExternalURL>():
197 return MetadataViews.ExternalURL("https://www.Eternity.flow/")
198 case Type<MetadataViews.NFTCollectionDisplay>():
199 return Eternity.resolveContractView(resourceType: Type<@Eternity.NFT>(), viewType: Type<MetadataViews.NFTCollectionDisplay>())
200 case Type<MetadataViews.Medias>():
201 let metadata = 10
202 if metadata != nil {
203 return MetadataViews.Medias(
204 [
205 MetadataViews.Media(
206 file: MetadataViews.HTTPFile(
207 url: "metadata.embededHTML"
208 ),
209 mediaType: "html"
210 )
211 ]
212 )
213 }
214 case Type<MetadataViews.Royalties>():
215 return MetadataViews.Royalties([
216 MetadataViews.Royalty(
217 receiver: getAccount(Eternity.account.address).capabilities.get<&FlowToken.Vault>(/public/flowTokenReceiver),
218 cut: 0.5,
219 description: "The deployer gets 5% of every secondary sale."
220 )
221 ])
222 case Type<MetadataViews.Serial>():
223 return MetadataViews.Serial(
224 0
225 )
226 }
227 return nil
228 }
229 }
230}
231
232// Manifested by
233// fSociety
234// fSociety
235// fSociety
236// fSociety
237// fSociety
238// fSociety
239// fSociety
240// definetly not AI generated.