VroomToken

1/// "There was once a dream that was Rome. You could only whisper it. 
2/// Anything more than a whisper and it would vanish, it was so fragile. 
3/// (Marcus Aurelius)
4
5/// Gladiator (2000), directed by Ridley Scott
6
7/// Testnet
8/// import FungibleToken from 0xf233dcee88fe0abe
9
10/// Mainnet
11import FungibleToken from 0xf233dcee88fe0abe
12import MetadataViews from 0x1d7e57aa55817448
13import FungibleTokenMetadataViews from 0xf233dcee88fe0abe
14
15access(all) contract VroomToken: FungibleToken {
16
17    access(all) var totalSupply: UFix64
18
19    access(all) let VaultReceiverPath: PublicPath
20    access(all) let VaultBalancePath: PublicPath
21    access(all) let VaultStoragePath: StoragePath
22    access(all) let AdminStoragePath: StoragePath
23
24    access(all) event TokensMinted(amount: UFix64)
25    access(all) event TokensBurned(amount: UFix64)
26    access(all) event MinterCreated(allowedAmount: UFix64)
27    access(all) event BurnerCreated()
28
29    access(all) view fun getContractViews(resourceType: Type?): [Type] {
30        return [
31            Type<FungibleTokenMetadataViews.FTView>(),
32            Type<FungibleTokenMetadataViews.FTDisplay>(),
33            Type<FungibleTokenMetadataViews.FTVaultData>(),
34            Type<FungibleTokenMetadataViews.TotalSupply>()
35        ]
36    }
37
38    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
39        switch viewType {
40            case Type<FungibleTokenMetadataViews.FTView>():
41                return FungibleTokenMetadataViews.FTView(
42                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
43                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
44                )
45            case Type<FungibleTokenMetadataViews.FTDisplay>():
46                let media = MetadataViews.Media(
47                        file: MetadataViews.HTTPFile(
48                        url: "https://i.imgur.com/YpAYTaN.png"
49                    ),
50                    mediaType: "image/png+xml"
51                )
52                let medias = MetadataViews.Medias([media])
53                return FungibleTokenMetadataViews.FTDisplay(
54                    name: "Vroom Token",
55                    symbol: "VROOM",
56                    description: "Vroom Token",
57                    externalURL: MetadataViews.ExternalURL("https://driverz.world/"),
58                    logos: medias,
59                    socials: {
60                        "twitter": MetadataViews.ExternalURL("https://twitter.com/DriverzWorld"),
61                        "discord": MetadataViews.ExternalURL("https://discord.gg/driverz"),
62                        "instagram": MetadataViews.ExternalURL("https://www.instagram.com/driverzworld")
63                    }
64                )
65            case Type<FungibleTokenMetadataViews.FTVaultData>():
66                return FungibleTokenMetadataViews.FTVaultData(
67                    storagePath: self.VaultStoragePath,
68                    receiverPath: self.VaultReceiverPath,
69                    metadataPath: self.VaultBalancePath,
70                    receiverLinkedType: Type<&Vault>(),
71                    metadataLinkedType: Type<&Vault>(),
72                    createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} {
73                        return <- VroomToken.createEmptyVault(vaultType: Type<@Vault>())
74                    })
75                )
76            case Type<FungibleTokenMetadataViews.TotalSupply>():
77                return FungibleTokenMetadataViews.TotalSupply(
78                    totalSupply: VroomToken.totalSupply
79                )
80        }
81        return nil
82    }
83
84    access(all) resource Vault: FungibleToken.Vault {
85
86        access(all) var balance: UFix64
87
88        init(balance: UFix64) {
89            self.balance = balance
90        }
91
92        access(contract) fun burnCallback() {
93            if self.balance > 0.0 {
94                VroomToken.totalSupply = VroomToken.totalSupply - self.balance
95            }
96            self.balance = 0.0
97        }
98
99        access(all) view fun getViews(): [Type] {
100            return VroomToken.getContractViews(resourceType: nil)
101        }
102
103        access(all) fun resolveView(_ view: Type): AnyStruct? {
104            return VroomToken.resolveContractView(resourceType: nil, viewType: view)
105        }
106
107        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
108            let supportedTypes: {Type: Bool} = {}
109            supportedTypes[self.getType()] = true
110            return supportedTypes
111        }
112
113        access(all) view fun isSupportedVaultType(type: Type): Bool {
114            return self.getSupportedVaultTypes()[type] ?? false
115        }
116
117        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
118            return amount <= self.balance
119        }
120
121        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @Vault {
122            self.balance = self.balance - amount
123            return <- create Vault(balance: amount)
124        }
125
126        access(all) fun deposit(from: @{FungibleToken.Vault}) {
127            let vault <- from as! @VroomToken.Vault
128            self.balance = self.balance + vault.balance
129            vault.balance = 0.0
130            destroy vault
131        }
132
133        access(all) fun createEmptyVault(): @Vault {
134            return <-create Vault(balance: 0.0)
135        }
136    }
137
138    access(all) fun createEmptyVault(vaultType: Type): @Vault {
139        return <- create Vault(balance: 0.0)
140    }
141
142    access(all) resource Minter {
143
144        access(all) var allowedAmount: UFix64
145
146        access(all) fun mintTokens(amount: UFix64): @VroomToken.Vault {
147            pre {
148                amount > 0.0: "Amount minted must be greater than zero"
149                amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
150            }
151            VroomToken.totalSupply = VroomToken.totalSupply + amount
152            self.allowedAmount = self.allowedAmount - amount
153            emit TokensMinted(amount: amount)
154            return <- create Vault(balance: amount)
155        }
156
157        init(allowedAmount: UFix64) {
158            self.allowedAmount = allowedAmount
159        }
160
161    }
162
163    access(all) resource Burner {}
164
165    access(all) resource Administrator {
166
167        access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
168            emit MinterCreated(allowedAmount: allowedAmount)
169            return <- create Minter(allowedAmount: allowedAmount)
170        }
171
172    }
173
174    init() {
175        self.totalSupply = 7777777777.0
176
177        self.VaultReceiverPath = /public/VroomTokenReceiver
178        self.VaultBalancePath = /public/VroomTokenBalance
179        self.VaultStoragePath = /storage/VroomTokenVault
180        self.AdminStoragePath = /storage/VroomTokenAdmin
181
182        let vault <- create Vault(balance: self.totalSupply)
183        emit TokensMinted(amount: vault.balance)
184
185        let exampleTokenCap = self.account.capabilities.storage.issue<&Vault>(self.VaultStoragePath)
186        self.account.capabilities.publish(exampleTokenCap, at: self.VaultBalancePath)
187        let receiverCap = self.account.capabilities.storage.issue<&Vault>(self.VaultStoragePath)
188        self.account.capabilities.publish(receiverCap, at: self.VaultReceiverPath)
189
190        self.account.storage.save(<-vault, to: self.VaultStoragePath)
191
192        let admin <- create Administrator()
193        self.account.storage.save(<-admin, to: self.AdminStoragePath)
194    }
195}