import MetadataViews from 0x1d7e57aa55817448 import FungibleToken from 0xf233dcee88fe0abe import FungibleTokenMetadataViews from 0xf233dcee88fe0abe access(all) contract Karat: FungibleToken { // 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?) // TokensBurned // // The event that is emitted when tokens are destroyed access(all) event TokensBurned(amount: UFix64) /// The event that is emitted when new tokens are minted access(all) event TokensMinted(amount: UFix64, type: String) /// Total supply of ExampleTokens in existence access(all) var totalSupply: UFix64 /// Storage and Public Paths access(all) let VaultStoragePath: StoragePath access(all) let BalancePublicPath: PublicPath access(all) let ReceiverPublicPath: PublicPath access(all) let AdminStoragePath: StoragePath 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(): return FungibleTokenMetadataViews.FTDisplay( name: "Karat Token", symbol: "Karat", description: "Karat Token", externalURL: MetadataViews.ExternalURL("https://market.24karat.io"), logos: MetadataViews.Medias([]), socials: {} ) case Type(): return FungibleTokenMetadataViews.FTVaultData( storagePath: self.VaultStoragePath, receiverPath: self.ReceiverPublicPath, metadataPath: self.BalancePublicPath, receiverLinkedType: Type<&Karat.Vault>(), metadataLinkedType: Type<&Karat.Vault>(), createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} { return <-Karat.createEmptyVault(vaultType: Type<@Karat.Vault>()) }) ) case Type(): return FungibleTokenMetadataViews.TotalSupply( totalSupply: Karat.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 } /// Called when a fungible token is burned via the `Burner.burn()` method access(contract) fun burnCallback() { if self.balance > 0.0 { Karat.totalSupply = Karat.totalSupply - self.balance } self.balance = 0.0 } access(all) view fun getViews(): [Type] { return Karat.getContractViews(resourceType: nil) } access(all) fun resolveView(_ view: Type): AnyStruct? { return Karat.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 } /// Asks if the amount can be withdrawn from this vault access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool { return amount <= self.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 tokens that are 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): @Karat.Vault { self.balance = self.balance - amount 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! @Karat.Vault self.balance = self.balance + vault.balance vault.balance = 0.0 destroy vault } /// 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(): @Karat.Vault { return <-create Vault(balance: 0.0) } } /// 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): @Karat.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(): @Minter { return <-create Minter() } } /// Minter /// /// Resource object that token admin accounts can hold to mint new tokens. /// access(all) resource Minter { /// 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): @Karat.Vault { Karat.totalSupply = Karat.totalSupply + amount emit TokensMinted(amount: amount, type: self.getType().identifier) return <-create Vault(balance: amount) } } init() { // Set our named paths. self.VaultStoragePath = /storage/karatVault self.ReceiverPublicPath = /public/karatReceiver self.BalancePublicPath = /public/karatBalance self.AdminStoragePath = /storage/karatAdmin // Initialize contract state. self.totalSupply = 0.0 // Create the Vault with the total supply of tokens and save it in storage // let vault <- create Vault(balance: self.totalSupply) // Create a public capability to the stored Vault that exposes // the `deposit` method and getAcceptedTypes method through the `Receiver` interface // and the `balance` method through the `Balance` interface // let tokenCap = self.account.capabilities.storage.issue<&Karat.Vault>(self.VaultStoragePath) self.account.capabilities.publish(tokenCap, at: self.BalancePublicPath) let receiverCap = self.account.capabilities.storage.issue<&Karat.Vault>(self.VaultStoragePath) self.account.capabilities.publish(receiverCap, at: self.ReceiverPublicPath) self.account.storage.save(<-vault, to: self.VaultStoragePath) let admin <- create Administrator() self.account.storage.save(<-admin, to: self.AdminStoragePath) } }