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