@flowtyio/flow-contracts 0.0.18 → 0.1.0-beta.10

package/contracts/Burner.cdc

@@ -0,0 +1,44 @@
+/// Burner is a contract that can facilitate the destruction of any resource on flow.
+///
+/// Contributors
+/// - Austin Kline - https://twitter.com/austin_flowty
+/// - Deniz Edincik - https://twitter.com/bluesign
+/// - Bastian Müller - https://twitter.com/turbolent
+access(all) contract Burner {
+    /// When Crescendo (Cadence 1.0) is released, custom destructors will be removed from cadece.
+    /// Burnable is an interface meant to replace this lost feature, allowing anyone to add a callback
+    /// method to ensure they do not destroy something which is not meant to be,
+    /// or to add logic based on destruction such as tracking the supply of a FT Collection
+    ///
+    /// NOTE: The only way to see benefit from this interface
+    /// is to always use the burn method in this contract. Anyone who owns a resource can always elect **not**
+    /// to destroy a resource this way
+    access(all) resource interface Burnable {
+        access(contract) fun burnCallback()
+    }
+
+    /// burn is a global method which will destroy any resource it is given.
+    /// If the provided resource implements the Burnable interface,
+    /// it will call the burnCallback method and then destroy afterwards.
+    access(all) fun burn(_ r: @AnyResource) {
+        if let s <- r as? @{Burnable} {
+            s.burnCallback()
+            destroy s
+        } else if let arr <- r as? @[AnyResource] {
+            while arr.length > 0 {
+                let item <- arr.removeFirst()
+                self.burn(<-item)
+            }
+            destroy arr
+        } else if let dict <- r as? @{HashableStruct: AnyResource} {
+            let keys = dict.keys
+            while keys.length > 0 {
+                let item <- dict.remove(key: keys.removeFirst())!
+                self.burn(<-item)
+            }
+            destroy dict
+        } else {
+            destroy r
+        }
+    }
+}

package/contracts/FlowStorageFees.cdc

@@ -17,29 +17,29 @@
 import "FungibleToken"
 import "FlowToken"
 
-pub contract FlowStorageFees {
+access(all) contract FlowStorageFees {
 
     // Emitted when the amount of storage capacity an account has per reserved Flow token changes
-    pub event StorageMegaBytesPerReservedFLOWChanged(_ storageMegaBytesPerReservedFLOW: UFix64)
+    access(all) event StorageMegaBytesPerReservedFLOWChanged(_ storageMegaBytesPerReservedFLOW: UFix64)
 
     // Emitted when the minimum amount of Flow tokens that an account needs to have reserved for storage capacity changes.
-    pub event MinimumStorageReservationChanged(_ minimumStorageReservation: UFix64)
+    access(all) event MinimumStorageReservationChanged(_ minimumStorageReservation: UFix64)
 
     // Defines how much storage capacity every account has per reserved Flow token.
     // definition is written per unit of flow instead of the inverse, 
     // so there is no loss of precision calculating storage from flow, 
     // but there is loss of precision when calculating flow per storage.
-    pub var storageMegaBytesPerReservedFLOW: UFix64
+    access(all) var storageMegaBytesPerReservedFLOW: UFix64
 
     // Defines the minimum amount of Flow tokens that every account needs to have reserved for storage capacity.
     // If an account has less then this amount reserved by the end of any transaction it participated in, the transaction will fail.
-    pub var minimumStorageReservation: UFix64
+    access(all) var minimumStorageReservation: UFix64
 
     // An administrator resource that can change the parameters of the FlowStorageFees smart contract.
-    pub resource Administrator {
+    access(all) resource Administrator {
 
         // Changes the amount of storage capacity an account has per accounts' reserved storage FLOW.
-        pub fun setStorageMegaBytesPerReservedFLOW(_ storageMegaBytesPerReservedFLOW: UFix64) {
+        access(all) fun setStorageMegaBytesPerReservedFLOW(_ storageMegaBytesPerReservedFLOW: UFix64) {
             if FlowStorageFees.storageMegaBytesPerReservedFLOW == storageMegaBytesPerReservedFLOW {
               return
             }
@@ -48,7 +48,7 @@ pub contract FlowStorageFees {
         }
 
         // Changes the minimum amount of FLOW an account has to have reserved.
-        pub fun setMinimumStorageReservation(_ minimumStorageReservation: UFix64) {
+        access(all) fun setMinimumStorageReservation(_ minimumStorageReservation: UFix64) {
             if FlowStorageFees.minimumStorageReservation == minimumStorageReservation {
               return
             }
@@ -63,19 +63,19 @@ pub contract FlowStorageFees {
     ///
     /// Returns megabytes
     /// If the account has no default balance it is counted as a balance of 0.0 FLOW
-    pub fun calculateAccountCapacity(_ accountAddress: Address): UFix64 {
+    access(all) fun calculateAccountCapacity(_ accountAddress: Address): UFix64 {
         var balance = 0.0
-        if let balanceRef = getAccount(accountAddress)
-            .getCapability<&FlowToken.Vault{FungibleToken.Balance}>(/public/flowTokenBalance)!
-            .borrow() {
-                balance = balanceRef.balance
+        let acct = getAccount(accountAddress)
+
+        if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
+            balance = balanceRef.balance
         }
 
         return self.accountBalanceToAccountStorageCapacity(balance)
     }
 
     /// calculateAccountsCapacity returns the storage capacity of a batch of accounts
-    pub fun calculateAccountsCapacity(_ accountAddresses: [Address]): [UFix64] {
+    access(all) fun calculateAccountsCapacity(_ accountAddresses: [Address]): [UFix64] {
         let capacities: [UFix64] = []
         for accountAddress in accountAddresses {
             let capacity = self.calculateAccountCapacity(accountAddress)
@@ -88,19 +88,19 @@ pub contract FlowStorageFees {
     // This is used to check if a transaction will fail because of any account being over the storage capacity
     // The payer is an exception as its storage capacity is derived from its balance minus the maximum possible transaction fees 
     // (transaction fees if the execution effort is at the execution efort limit, a.k.a.: computation limit, a.k.a.: gas limit)
-    pub fun getAccountsCapacityForTransactionStorageCheck(accountAddresses: [Address], payer: Address, maxTxFees: UFix64): [UFix64] {
+    access(all) fun getAccountsCapacityForTransactionStorageCheck(accountAddresses: [Address], payer: Address, maxTxFees: UFix64): [UFix64] {
         let capacities: [UFix64] = []
         for accountAddress in accountAddresses {
             var balance = 0.0
-            if let balanceRef = getAccount(accountAddress)
-                .getCapability<&FlowToken.Vault{FungibleToken.Balance}>(/public/flowTokenBalance)!
-                .borrow() {
-                    if accountAddress == payer {
-                        // if the account is the payer, deduct the maximum possible transaction fees from the balance
-                        balance = balanceRef.balance.saturatingSubtract(maxTxFees)
-                    } else {
-                        balance = balanceRef.balance
-                    }
+            let acct = getAccount(accountAddress)
+
+            if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
+                if accountAddress == payer {
+                    // if the account is the payer, deduct the maximum possible transaction fees from the balance
+                    balance = balanceRef.balance.saturatingSubtract(maxTxFees)
+                } else {
+                    balance = balanceRef.balance
+                }
             }
 
             capacities.append(self.accountBalanceToAccountStorageCapacity(balance)) 
@@ -110,7 +110,7 @@ pub contract FlowStorageFees {
 
     // accountBalanceToAccountStorageCapacity returns the storage capacity
     // an account would have with given the flow balance of the account.
-    pub fun accountBalanceToAccountStorageCapacity(_ balance: UFix64): UFix64 {
+    access(all) view fun accountBalanceToAccountStorageCapacity(_ balance: UFix64): UFix64 {
         // get address token balance
         if balance < self.minimumStorageReservation {
             // if < then minimum return 0
@@ -123,15 +123,15 @@ pub contract FlowStorageFees {
 
     // Amount in Flow tokens
     // Returns megabytes
-    pub fun flowToStorageCapacity(_ amount: UFix64): UFix64 {
+    access(all) view fun flowToStorageCapacity(_ amount: UFix64): UFix64 {
         return amount.saturatingMultiply(FlowStorageFees.storageMegaBytesPerReservedFLOW)
     }
 
     // Amount in megabytes
     // Returns Flow tokens
-    pub fun storageCapacityToFlow(_ amount: UFix64): UFix64 {
-        if FlowStorageFees.storageMegaBytesPerReservedFLOW == 0.0 as UFix64 {
-            return 0.0 as UFix64
+    access(all) view fun storageCapacityToFlow(_ amount: UFix64): UFix64 {
+        if FlowStorageFees.storageMegaBytesPerReservedFLOW == 0.0 {
+            return 0.0
         }
         // possible loss of precision
         // putting the result back into `flowToStorageCapacity` might not yield the same result
@@ -139,9 +139,9 @@ pub contract FlowStorageFees {
     }
 
     // converts storage used from UInt64 Bytes to UFix64 Megabytes.
-    pub fun convertUInt64StorageBytesToUFix64Megabytes(_ storage: UInt64): UFix64 {
+    access(all) view fun convertUInt64StorageBytesToUFix64Megabytes(_ storage: UInt64): UFix64 {
         // safe convert UInt64 to UFix64 (without overflow)
-        let f = UFix64(storage % 100000000 as UInt64) * 0.00000001 as UFix64 + UFix64(storage / 100000000 as UInt64)
+        let f = UFix64(storage % 100000000) * 0.00000001 + UFix64(storage / 100000000)
         // decimal point correction. Megabytes to bytes have a conversion of 10^-6 while UFix64 minimum value is 10^-8
         let storageMb = f.saturatingMultiply(100.0)
         return storageMb
@@ -151,13 +151,12 @@ pub contract FlowStorageFees {
     ///
     /// The available balance of an account is its default token balance minus what is reserved for storage.
     /// If the account has no default balance it is counted as a balance of 0.0 FLOW
-    pub fun defaultTokenAvailableBalance(_ accountAddress: Address): UFix64 {
+    access(all) fun defaultTokenAvailableBalance(_ accountAddress: Address): UFix64 {
         //get balance of account
         let acct = getAccount(accountAddress)
         var balance = 0.0
-        if let balanceRef = acct
-            .getCapability(/public/flowTokenBalance)
-            .borrow<&FlowToken.Vault{FungibleToken.Balance}>() {
+
+        if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
             balance = balanceRef.balance
         }
 
@@ -171,9 +170,9 @@ pub contract FlowStorageFees {
     ///
     /// The reserved balance of an account is its storage used multiplied by the storage cost per flow token.
     /// The reserved balance is at least the minimum storage reservation.
-    pub fun defaultTokenReservedBalance(_ accountAddress: Address): UFix64 {
+    access(all) view fun defaultTokenReservedBalance(_ accountAddress: Address): UFix64 {
         let acct = getAccount(accountAddress)
-        var reserved = self.storageCapacityToFlow(self.convertUInt64StorageBytesToUFix64Megabytes(acct.storageUsed))
+        var reserved = self.storageCapacityToFlow(self.convertUInt64StorageBytesToUFix64Megabytes(acct.storage.used))
         // at least self.minimumStorageReservation should be reserved
         if reserved < self.minimumStorageReservation {
             reserved = self.minimumStorageReservation
@@ -187,7 +186,6 @@ pub contract FlowStorageFees {
         self.minimumStorageReservation = 0.0 // or 0 kb of minimum storage reservation
 
         let admin <- create Administrator()
-        self.account.save(<-admin, to: /storage/storageFeesAdmin)
+        self.account.storage.save(<-admin, to: /storage/storageFeesAdmin)
     }
 }
- 

package/contracts/FlowToken.cdc

@@ -1,33 +1,27 @@
 import "FungibleToken"
 import "MetadataViews"
 import "FungibleTokenMetadataViews"
-import "ViewResolver"
+import "Burner"
 
-pub contract FlowToken: FungibleToken, ViewResolver {
+access(all) contract FlowToken: FungibleToken {
 
     // Total supply of Flow tokens in existence
-    pub var totalSupply: UFix64
-
-    // Event that is emitted when the contract is created
-    pub event TokensInitialized(initialSupply: UFix64)
+    access(all) var totalSupply: UFix64
 
     // Event that is emitted when tokens are withdrawn from a Vault
-    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
 
     // Event that is emitted when tokens are deposited to a Vault
-    pub event TokensDeposited(amount: UFix64, to: Address?)
+    access(all) event TokensDeposited(amount: UFix64, to: Address?)
 
     // Event that is emitted when new tokens are minted
-    pub event TokensMinted(amount: UFix64)
-
-    // Event that is emitted when tokens are destroyed
-    pub event TokensBurned(amount: UFix64)
+    access(all) event TokensMinted(amount: UFix64)
 
     // Event that is emitted when a new minter resource is created
-    pub event MinterCreated(allowedAmount: UFix64)
+    access(all) event MinterCreated(allowedAmount: UFix64)
 
     // Event that is emitted when a new burner resource is created
-    pub event BurnerCreated()
+    access(all) event BurnerCreated()
 
     // Vault
     //
@@ -41,16 +35,38 @@ pub contract FlowToken: FungibleToken, ViewResolver {
     // out of thin air. A special Minter resource needs to be defined to mint
     // new tokens.
     //
-    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance, MetadataViews.Resolver {
+    access(all) resource Vault: FungibleToken.Vault {
 
         // holds the balance of a users tokens
-        pub var balance: UFix64
+        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 {
+                FlowToken.totalSupply = FlowToken.totalSupply - self.balance
+            }
+            self.balance = 0.0
+        }
+
+        /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {self.getType(): true}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            if (type == self.getType()) { return true } else { return 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 integer amount as an argument
@@ -60,7 +76,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         // created Vault to the context that called so it can be deposited
         // elsewhere.
         //
-        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+        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)
@@ -73,7 +89,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         // 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.
-        pub fun deposit(from: @FungibleToken.Vault) {
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let vault <- from as! @FlowToken.Vault
             self.balance = self.balance + vault.balance
             emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
@@ -81,19 +97,13 @@ pub contract FlowToken: FungibleToken, ViewResolver {
             destroy vault
         }
 
-        destroy() {
-            if self.balance > 0.0 {
-                FlowToken.totalSupply = FlowToken.totalSupply - self.balance
-            }
-        }
-
         /// Get all the Metadata Views implemented by FlowToken
         ///
         /// @return An array of Types defining the implemented views. This value will be used by
         ///         developers to know which parameter to pass to the resolveView() method.
         ///
-        pub fun getViews(): [Type]{
-            return FlowToken.getViews()
+        access(all) view fun getViews(): [Type]{
+            return FlowToken.getContractViews(resourceType: nil)
         }
 
         /// Get a Metadata View from FlowToken
@@ -101,8 +111,12 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         /// @param view: The Type of the desired view.
         /// @return A structure representing the requested view.
         ///
-        pub fun resolveView(_ view: Type): AnyStruct? {
-            return FlowToken.resolveView(view)
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return FlowToken.resolveContractView(resourceType: nil, viewType: view)
+        }
+
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <-create Vault(balance: 0.0)
         }
     }
 
@@ -113,14 +127,16 @@ pub contract FlowToken: FungibleToken, ViewResolver {
     // and store the returned Vault in their storage in order to allow their
     // account to be able to receive deposits of this token type.
     //
-    pub fun createEmptyVault(): @FungibleToken.Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @FlowToken.Vault {
         return <-create Vault(balance: 0.0)
     }
 
-    pub fun getViews(): [Type] {
+    /// Gets a list of the metadata views that this contract supports
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
         return [Type<FungibleTokenMetadataViews.FTView>(),
                 Type<FungibleTokenMetadataViews.FTDisplay>(),
-                Type<FungibleTokenMetadataViews.FTVaultData>()]
+                Type<FungibleTokenMetadataViews.FTVaultData>(),
+                Type<FungibleTokenMetadataViews.TotalSupply>()]
     }
 
     /// Get a Metadata View from FlowToken
@@ -128,17 +144,17 @@ pub contract FlowToken: FungibleToken, ViewResolver {
     /// @param view: The Type of the desired view.
     /// @return A structure representing the requested view.
     ///
-    pub fun resolveView(_ view: Type): AnyStruct? {
-        switch view {
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
             case Type<FungibleTokenMetadataViews.FTView>():
                 return FungibleTokenMetadataViews.FTView(
-                    ftDisplay: self.resolveView(Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
-                    ftVaultData: self.resolveView(Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
+                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
                 )
             case Type<FungibleTokenMetadataViews.FTDisplay>():
                 let media = MetadataViews.Media(
                         file: MetadataViews.HTTPFile(
-                        url: "https://assets.website-files.com/5f6294c0c7a8cdd643b1c820/5f6294c0c7a8cda55cb1c936_Flow_Wordmark.svg"
+                        url: FlowToken.getLogoURI()
                     ),
                     mediaType: "image/svg+xml"
                 )
@@ -146,7 +162,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
                 return FungibleTokenMetadataViews.FTDisplay(
                     name: "FLOW Network Token",
                     symbol: "FLOW",
-                    description: "FLOW is the protocol token that is required for transaction fees, storage fees, staking, and many applications built on the Flow Blockchain",
+                    description: "FLOW is the native token for the Flow blockchain. It is required for securing the network, transaction fees, storage fees, staking, FLIP voting and may be used by applications built on the Flow Blockchain",
                     externalURL: MetadataViews.ExternalURL("https://flow.com"),
                     logos: medias,
                     socials: {
@@ -154,57 +170,50 @@ pub contract FlowToken: FungibleToken, ViewResolver {
                     }
                 )
             case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = FlowToken.account.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: /storage/flowTokenVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
                 return FungibleTokenMetadataViews.FTVaultData(
                     storagePath: /storage/flowTokenVault,
                     receiverPath: /public/flowTokenReceiver,
                     metadataPath: /public/flowTokenBalance,
-                    providerPath: /private/flowTokenVault,
-                    receiverLinkedType: Type<&FlowToken.Vault{FungibleToken.Receiver, FungibleToken.Balance, MetadataViews.Resolver}>(),
-                    metadataLinkedType: Type<&FlowToken.Vault{FungibleToken.Balance, MetadataViews.Resolver}>(),
-                    providerLinkedType: Type<&FlowToken.Vault{FungibleToken.Provider}>(),
-                    createEmptyVaultFunction: (fun (): @FungibleToken.Vault {
-                        return <-FlowToken.createEmptyVault()
+                    receiverLinkedType: Type<&{FungibleToken.Receiver, FungibleToken.Vault}>(),
+                    metadataLinkedType: Type<&{FungibleToken.Balance, FungibleToken.Vault}>(),
+                    createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
+                        return <-vaultRef.createEmptyVault()
                     })
                 )
+            case Type<FungibleTokenMetadataViews.TotalSupply>():
+                return FungibleTokenMetadataViews.TotalSupply(totalSupply: FlowToken.totalSupply)
         }
         return nil
     }
 
-    pub resource Administrator {
+    access(all) resource Administrator {
         // createNewMinter
         //
         // Function that creates and returns a new minter resource
         //
-        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+        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
-        //
-        pub fun createNewBurner(): @Burner {
-            emit BurnerCreated()
-            return <-create Burner()
-        }
     }
 
     // Minter
     //
     // Resource object that token admin accounts can hold to mint new tokens.
     //
-    pub resource Minter {
+    access(all) resource Minter {
 
         // the amount of tokens that the minter is allowed to mint
-        pub var allowedAmount: UFix64
+        access(all) var allowedAmount: UFix64
 
         // mintTokens
         //
         // Function that mints new tokens, adds them to the total supply,
         // and returns them to the calling context.
         //
-        pub fun mintTokens(amount: UFix64): @FlowToken.Vault {
+        access(all) fun mintTokens(amount: UFix64): @FlowToken.Vault {
             pre {
                 amount > UFix64(0): "Amount minted must be greater than zero"
                 amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
@@ -220,55 +229,34 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         }
     }
 
-    // Burner
-    //
-    // Resource object that token admin accounts can hold to burn tokens.
-    //
-    pub 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.
-        //
-        pub fun burnTokens(from: @FungibleToken.Vault) {
-            let vault <- from as! @FlowToken.Vault
-            let amount = vault.balance
-            destroy vault
-            emit TokensBurned(amount: amount)
-        }
+    /// Gets the Flow Logo XML URI from storage
+    access(all) fun getLogoURI(): String {
+        return FlowToken.account.storage.copy<String>(from: /storage/flowTokenLogoURI) ?? ""
     }
 
-    init(adminAccount: AuthAccount) {
+    init(adminAccount: auth(Storage, Capabilities) &Account) {
         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)
-        adminAccount.save(<-vault, to: /storage/flowTokenVault)
+
+        adminAccount.storage.save(<-vault, to: /storage/flowTokenVault)
 
         // Create a public capability to the stored Vault that only exposes
         // the `deposit` method through the `Receiver` interface
         //
-        adminAccount.link<&FlowToken.Vault{FungibleToken.Receiver, FungibleToken.Balance, MetadataViews.Resolver}>(
-            /public/flowTokenReceiver,
-            target: /storage/flowTokenVault
-        )
+        let receiverCapability = adminAccount.capabilities.storage.issue<&FlowToken.Vault>(/storage/flowTokenVault)
+        adminAccount.capabilities.publish(receiverCapability, at: /public/flowTokenReceiver)
 
         // Create a public capability to the stored Vault that only exposes
         // the `balance` field through the `Balance` interface
         //
-        adminAccount.link<&FlowToken.Vault{FungibleToken.Balance, MetadataViews.Resolver}>(
-            /public/flowTokenBalance,
-            target: /storage/flowTokenVault
-        )
+        let balanceCapability = adminAccount.capabilities.storage.issue<&FlowToken.Vault>(/storage/flowTokenVault)
+        adminAccount.capabilities.publish(balanceCapability, at: /public/flowTokenBalance)
 
         let admin <- create Administrator()
-        adminAccount.save(<-admin, to: /storage/flowTokenAdmin)
+        adminAccount.storage.save(<-admin, to: /storage/flowTokenAdmin)
 
-        // Emit an event that shows that the contract was initialized
-        emit TokensInitialized(initialSupply: self.totalSupply)
     }
 }