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

package/contracts/FlowStorageFees.cdc

@@ -1,45 +1,45 @@
 /*
  * The FlowStorageFees smart contract
  *
- * An account's storage capacity determines up to how much storage on chain it can use. 
+ * An account's storage capacity determines up to how much storage on chain it can use.
  * A storage capacity is calculated by multiplying the amount of reserved flow with `StorageFee.storageMegaBytesPerReservedFLOW`
  * The minimum amount of flow tokens reserved for storage capacity is `FlowStorageFees.minimumStorageReservation` this is paid during account creation, by the creator.
- * 
- * At the end of all transactions, any account that had any value changed in their storage 
+ *
+ * At the end of all transactions, any account that had any value changed in their storage
  * has their storage capacity checked against their storage used and their main flow token vault against the minimum reservation.
  * If any account fails this check the transaction wil fail.
- * 
- * An account moving/deleting its `FlowToken.Vault` resource will result 
+ *
+ * An account moving/deleting its `FlowToken.Vault` resource will result
  * in the transaction failing because the account will have no storage capacity.
- * 
+ *
  */
 
 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, 
+    // 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.getBalance()
         }
 
         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)
@@ -86,52 +86,52 @@ pub contract FlowStorageFees {
 
     // getAccountsCapacityForTransactionStorageCheck returns the storage capacity of a batch of accounts
     // 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 
+    // 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.getBalance().saturatingSubtract(maxTxFees)
+                } else {
+                    balance = balanceRef.getBalance()
+                }
             }
 
-            capacities.append(self.accountBalanceToAccountStorageCapacity(balance)) 
+            capacities.append(self.accountBalanceToAccountStorageCapacity(balance))
         }
         return capacities
     }
 
     // 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
             return 0.0
         }
 
-        // return balance multiplied with megabytes per flow 
+        // return balance multiplied with megabytes per flow
         return self.flowToStorageCapacity(balance)
     }
 
     // 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,14 +151,13 @@ 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}>() {
-            balance = balanceRef.balance
+
+        if let balanceRef = acct.capabilities.borrow<&FlowToken.Vault>(/public/flowTokenBalance) {
+            balance = balanceRef.getBalance()
         }
 
         // get how much should be reserved for storage
@@ -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

@@ -3,31 +3,31 @@ import "MetadataViews"
 import "FungibleTokenMetadataViews"
 import "ViewResolver"
 
-pub contract FlowToken: FungibleToken, ViewResolver {
+access(all) contract FlowToken: ViewResolver {
 
     // Total supply of Flow tokens in existence
-    pub var totalSupply: UFix64
+    access(all) var totalSupply: UFix64
 
     // Event that is emitted when the contract is created
-    pub event TokensInitialized(initialSupply: UFix64)
+    access(all) event TokensInitialized(initialSupply: 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)
+    access(all) event TokensMinted(amount: UFix64)
 
     // Event that is emitted when tokens are destroyed
-    pub event TokensBurned(amount: UFix64)
+    access(all) event TokensBurned(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 +41,39 @@ 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, FungibleToken.Provider, FungibleToken.Receiver, ViewResolver.Resolver {
 
         // holds the balance of a users tokens
-        pub var balance: UFix64
+        access(all) var balance: UFix64
+
+        access(all) view fun getBalance(): UFix64 {
+            return self.balance
+        }
 
         // initialize the balance at resource creation time
         init(balance: UFix64) {
             self.balance = balance
         }
 
+        /// 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 }
+        }
+
+        /// Returns the storage path where the vault should typically be stored
+        access(all) view fun getDefaultStoragePath(): StoragePath? {
+            return /storage/flowTokenVault
+        }
+
+        /// Returns the public path where this vault should have a public capability
+        access(all) view fun getDefaultPublicPath(): PublicPath? {
+            return /public/flowTokenReceiver
+        }
+
         // withdraw
         //
         // Function that takes an integer amount as an argument
@@ -60,7 +83,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.Withdrawable) 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 +96,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,18 +104,12 @@ 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]{
+        access(all) view fun getViews(): [Type]{
             return FlowToken.getViews()
         }
 
@@ -101,9 +118,13 @@ 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? {
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
             return FlowToken.resolveView(view)
         }
+
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <-create Vault(balance: 0.0)
+        }
     }
 
     // createEmptyVault
@@ -113,14 +134,15 @@ 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(): @FlowToken.Vault {
         return <-create Vault(balance: 0.0)
     }
 
-    pub fun getViews(): [Type] {
+    access(all) view fun getViews(): [Type] {
         return [Type<FungibleTokenMetadataViews.FTView>(),
                 Type<FungibleTokenMetadataViews.FTDisplay>(),
-                Type<FungibleTokenMetadataViews.FTVaultData>()]
+                Type<FungibleTokenMetadataViews.FTVaultData>(),
+                Type<FungibleTokenMetadataViews.TotalSupply>()]
     }
 
     /// Get a Metadata View from FlowToken
@@ -128,7 +150,7 @@ 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? {
+    access(all) fun resolveView(_ view: Type): AnyStruct? {
         switch view {
             case Type<FungibleTokenMetadataViews.FTView>():
                 return FungibleTokenMetadataViews.FTView(
@@ -138,7 +160,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
             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 +168,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: {
@@ -159,23 +181,25 @@ pub contract FlowToken: FungibleToken, ViewResolver {
                     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 {
+                    receiverLinkedType: Type<&FlowToken.Vault>(),
+                    metadataLinkedType: Type<&FlowToken.Vault>(),
+                    providerLinkedType: Type<&FlowToken.Vault>(),
+                    createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
                         return <-FlowToken.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)
         }
@@ -184,7 +208,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         //
         // Function that creates and returns a new burner resource
         //
-        pub fun createNewBurner(): @Burner {
+        access(all) fun createNewBurner(): @Burner {
             emit BurnerCreated()
             return <-create Burner()
         }
@@ -194,17 +218,17 @@ pub contract FlowToken: FungibleToken, ViewResolver {
     //
     // 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"
@@ -224,7 +248,7 @@ pub contract FlowToken: FungibleToken, ViewResolver {
     //
     // Resource object that token admin accounts can hold to burn tokens.
     //
-    pub resource Burner {
+    access(all) resource Burner {
 
         // burnTokens
         //
@@ -233,42 +257,55 @@ pub contract FlowToken: FungibleToken, ViewResolver {
         // 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
+        access(all) fun burnTokens(from: @FlowToken.Vault) {
+            FlowToken.burnTokens(from: <-from)
+        }
+    }
+
+    access(all) fun burnTokens(from: @FlowToken.Vault) {
+        let vault <- from as! @FlowToken.Vault
+        let amount = vault.balance
+        destroy vault
+        if amount > 0.0 {
+            FlowToken.totalSupply = FlowToken.totalSupply - amount
             emit TokensBurned(amount: amount)
         }
     }
 
-    init(adminAccount: AuthAccount) {
+    /// Gets the Flow Logo XML URI from storage
+    access(all) fun getLogoURI(): String {
+        return FlowToken.account.storage.copy<String>(from: /storage/flowTokenLogoURI) ?? ""
+    }
+
+    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)
+
+        // Example of how to resolve a metadata view for a Vault
+        let ftView = vault.resolveView(Type<FungibleTokenMetadataViews.FTView>())
+
+        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)
+
     }
 }