import FungibleToken from 0xf233dcee88fe0abe import Toucans from 0x577a3c409c5dcb5e import FungibleTokenMetadataViews from 0xf233dcee88fe0abe import MetadataViews from 0x1d7e57aa55817448 access(all) contract FlovatarDustToken: FungibleToken{ /// Total supply of FlovatarDustTokens in existence access(all) var totalSupply: UFix64 /// Name of the path access(all) let VaultReceiverPath: PublicPath access(all) let VaultBalancePath: PublicPath access(all) let VaultStoragePath: StoragePath access(all) let AdminStoragePath: StoragePath /// TokensInitialized /// /// The event that is emitted when the contract is created access(all) event TokensInitialized(initialSupply: UFix64) /// TokensWithdrawn /// /// The event that is emitted when tokens are withdrawn from a Vault access(all) event TokensWithdrawn(amount: UFix64, from: Address?) /// TokensDeposited /// /// The event that is emitted when tokens are deposited to a Vault access(all) event TokensDeposited(amount: UFix64, to: Address?) /// TokensMinted /// /// The event that is emitted when new tokens are minted access(all) event TokensMinted(amount: UFix64) /// TokensBurned /// /// The event that is emitted when tokens are destroyed access(all) event TokensBurned(amount: UFix64) /// MinterCreated /// /// The event that is emitted when a new minter resource is created access(all) event MinterCreated(allowedAmount: UFix64) /// BurnerCreated /// /// The event that is emitted when a new burner resource is created access(all) event BurnerCreated() access(all) view fun getContractViews(resourceType: Type?): [Type] { return [ Type(), Type(), Type(), Type() ] } access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? { switch viewType { case Type(): return FungibleTokenMetadataViews.FTView( ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTDisplay?, ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? ) case Type(): let media = MetadataViews.Media( file: MetadataViews.HTTPFile( url: "https://images.flovatar.com/logo.svg" ), mediaType: "image/svg+xml" ) let medias = MetadataViews.Medias([media]) return FungibleTokenMetadataViews.FTDisplay( name: "Flovatar Dust Token", symbol: "DUST", description: "Flovatar is pioneering a new way to unleash community creativity in Web3 by allowing users to be co-creators of their prized NFTs, instead of just being passive collectors.", externalURL: MetadataViews.ExternalURL("https://flovatar.com"), logos: medias, socials: { "discord": MetadataViews.ExternalURL("https://discord.gg/flovatar"), "twitter": MetadataViews.ExternalURL("https://x.com/flovatar"), "instagram": MetadataViews.ExternalURL("https://instagram.com/flovatar_nft"), "tiktok": MetadataViews.ExternalURL("https://www.tiktok.com/@flovatar") } ) case Type(): return FungibleTokenMetadataViews.FTVaultData( storagePath: self.VaultStoragePath, receiverPath: self.VaultReceiverPath, metadataPath: self.VaultBalancePath, receiverLinkedType: Type<&FlovatarDustToken.Vault>(), metadataLinkedType: Type<&FlovatarDustToken.Vault>(), createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} { return <-FlovatarDustToken.createEmptyVault(vaultType: Type<@FlovatarDustToken.Vault>()) }) ) case Type(): return FungibleTokenMetadataViews.TotalSupply( totalSupply: FlovatarDustToken.totalSupply ) } return nil } /// Vault /// /// Each user stores an instance of only the Vault in their storage /// The functions in the Vault and governed by the pre and post conditions /// in FungibleToken when they are called. /// The checks happen at runtime whenever a function is called. /// /// Resources can only be created in the context of the contract that they /// are defined in, so there is no way for a malicious user to create Vaults /// out of thin air. A special Minter resource needs to be defined to mint /// new tokens. /// access(all) resource Vault: FungibleToken.Vault { /// The total balance of this vault access(all) var balance: UFix64 // initialize the balance at resource creation time init(balance: UFix64){ self.balance = balance } /// withdraw /// /// Function that takes an amount as an argument /// and withdraws that amount from the Vault. /// /// It creates a new temporary Vault that is used to hold /// the money that is being transferred. It returns the newly /// created Vault to the context that called so it can be deposited /// elsewhere. /// access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault}{ self.balance = self.balance - amount emit TokensWithdrawn(amount: amount, from: self.owner?.address) return <-create Vault(balance: amount) } /// deposit /// /// Function that takes a Vault object as an argument and adds /// its balance to the balance of the owners Vault. /// /// It is allowed to destroy the sent Vault because the Vault /// was a temporary holder of the tokens. The Vault's balance has /// been consumed and therefore can be destroyed. /// access(all) fun deposit(from: @{FungibleToken.Vault}){ let vault <- from as! @FlovatarDustToken.Vault self.balance = self.balance + vault.balance emit TokensDeposited(amount: vault.balance, to: self.owner?.address) vault.balance = 0.0 destroy vault } access(all) fun createEmptyVault(): @{FungibleToken.Vault}{ return <-create Vault(balance: 0.0) } access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool{ return self.balance >= amount } access(contract) fun burnCallback() { if self.balance > 0.0 { FlovatarDustToken.totalSupply = FlovatarDustToken.totalSupply - self.balance emit TokensBurned(amount: self.balance) } self.balance = 0.0 } access(all) view fun getViews(): [Type] { return FlovatarDustToken.getContractViews(resourceType: nil) } access(all) fun resolveView(_ view: Type): AnyStruct? { return FlovatarDustToken.resolveContractView(resourceType: nil, viewType: view) } /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts access(all) view fun getSupportedVaultTypes(): {Type: Bool} { let supportedTypes: {Type: Bool} = {} supportedTypes[self.getType()] = true return supportedTypes } access(all) view fun isSupportedVaultType(type: Type): Bool { return self.getSupportedVaultTypes()[type] ?? false } } /// createEmptyVault /// /// Function that creates a new Vault with a balance of zero /// and returns it to the calling context. A user must call this function /// and store the returned Vault in their storage in order to allow their /// account to be able to receive deposits of this token type. /// access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault}{ return <-create Vault(balance: 0.0) } access(all) fun createEmptyDustVault(): @FlovatarDustToken.Vault { return <-create Vault(balance: 0.0) } access(all) resource Administrator{ /// createNewMinter /// /// Function that creates and returns a new minter resource /// access(all) fun createNewMinter(allowedAmount: UFix64): @Minter{ emit MinterCreated(allowedAmount: allowedAmount) return <-create Minter(allowedAmount: allowedAmount) } /// createNewBurner /// /// Function that creates and returns a new burner resource /// access(all) fun createNewBurner(): @Burner{ emit BurnerCreated() return <-create Burner() } } /// Minter /// /// Resource object that token admin accounts can hold to mint new tokens. /// access(all) resource Minter: Toucans.Minter{ /// The amount of tokens that the minter is allowed to mint access(all) var allowedAmount: UFix64 /// mintTokens /// /// Function that mints new tokens, adds them to the total supply, /// and returns them to the calling context. /// access(all) fun mintTokens(amount: UFix64): @FlovatarDustToken.Vault{ pre{ amount > 0.0: "Amount minted must be greater than zero" amount <= self.allowedAmount: "Amount minted must be less than the allowed amount" } FlovatarDustToken.totalSupply = FlovatarDustToken.totalSupply + amount self.allowedAmount = self.allowedAmount - amount emit TokensMinted(amount: amount) return <-create Vault(balance: amount) } access(all) fun mint(amount: UFix64): @Vault{ let vault <- self.mintTokens(amount: amount) as @Vault return <-vault } init(allowedAmount: UFix64){ self.allowedAmount = allowedAmount } } /// Burner /// /// Resource object that token admin accounts can hold to burn tokens. /// access(all) resource Burner{ /// burnTokens /// /// Function that destroys a Vault instance, effectively burning the tokens. /// /// Note: the burned tokens are automatically subtracted from the /// total supply in the Vault destructor. /// access(all) fun burnTokens(from: @{FungibleToken.Vault}){ let vault <- from as! @FlovatarDustToken.Vault let amount = vault.balance destroy vault emit TokensBurned(amount: amount) } } init(){ self.totalSupply = 500000000.0 self.VaultReceiverPath = /public/FlovatarDustTokenReceiver self.VaultBalancePath = /public/FlovatarDustTokenBalance self.VaultStoragePath = /storage/FlovatarDustTokenVault self.AdminStoragePath = /storage/FlovatarDustTokenAdmin // Create the Vault with the total supply of tokens and save it in storage // let vault <- create Vault(balance: self.totalSupply) self.account.storage.save(<-vault, to: self.VaultStoragePath) // Create a public capability to the stored Vault that only exposes // the `deposit` method through the `Receiver` interface // var capability_1 = self.account.capabilities.storage.issue<&{FungibleToken.Receiver, FungibleToken.Balance}>(self.VaultStoragePath) self.account.capabilities.publish(capability_1, at: self.VaultReceiverPath) // Create a public capability to the stored Vault that only exposes // the `balance` field through the `Balance` interface // var capability_2 = self.account.capabilities.storage.issue<&FlovatarDustToken.Vault>(self.VaultStoragePath) self.account.capabilities.publish(capability_2, at: self.VaultBalancePath) let admin <- create Administrator() self.account.storage.save(<-admin, to: self.AdminStoragePath) // Emit an event that shows that the contract was initialized // emit TokensInitialized(initialSupply: self.totalSupply) } }