Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update to newest Stable Cadence Preview #371

Merged
merged 8 commits into from
Jul 5, 2023
Merged

Update to newest Stable Cadence Preview #371

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
3ac018c
update to view functions for stable cadence
joshuahannan Nov 2, 2022
7b5540c
remove unreachable code
turbolent Nov 5, 2022
f8d357b
update templates to Stable Cadence
turbolent Nov 10, 2022
7479ccf
update to Stable Cadence preview 4
turbolent Nov 10, 2022
22348b1
Merge branch 'master' of github.com:onflow/flow-core-contracts into m…
dsainati1 Jun 28, 2023
e4bd248
update for stable cadence
dsainati1 Jun 28, 2023
72da91c
fix parse error
dsainati1 Jun 28, 2023
3ea1de4
merge from feature branch
joshuahannan Jul 5, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
64 changes: 32 additions & 32 deletions contracts/FlowContractAudits.cdc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,47 +4,47 @@
/// deployed to the Service Account, so it is documented here
/// for reference

pub contract FlowContractAudits {
access(all) contract FlowContractAudits {

// Event that is emitted when a new Auditor resource is created
pub event AuditorCreated()
access(all) event AuditorCreated()

// Event that is emitted when a new contract audit voucher is created
pub event VoucherCreated(address: Address?, recurrent: Bool, expiryBlockHeight: UInt64?, codeHash: String)
access(all) event VoucherCreated(address: Address?, recurrent: Bool, expiryBlockHeight: UInt64?, codeHash: String)

// Event that is emitted when a contract audit voucher is used
pub event VoucherUsed(address: Address, key: String, recurrent: Bool, expiryBlockHeight: UInt64?)
access(all) event VoucherUsed(address: Address, key: String, recurrent: Bool, expiryBlockHeight: UInt64?)

// Event that is emitted when a contract audit voucher is removed
pub event VoucherRemoved(key: String, recurrent: Bool, expiryBlockHeight: UInt64?)
access(all) event VoucherRemoved(key: String, recurrent: Bool, expiryBlockHeight: UInt64?)

// Dictionary of all vouchers
access(contract) var vouchers: {String: AuditVoucher}

// The storage path for the admin resource
pub let AdminStoragePath: StoragePath
access(all) let AdminStoragePath: StoragePath

// The storage Path for auditors' AuditorProxy
pub let AuditorProxyStoragePath: StoragePath
access(all) let AuditorProxyStoragePath: StoragePath

// The public path for auditors' AuditorProxy capability
pub let AuditorProxyPublicPath: PublicPath
access(all) let AuditorProxyPublicPath: PublicPath

// Single audit voucher that is used for contract deployment
pub struct AuditVoucher {
access(all) struct AuditVoucher {

// Address of the account the voucher is intended for
// If nil, the contract can be deployed to any account
pub let address: Address?
access(all) let address: Address?

// If false, the voucher will be removed after first use
pub let recurrent: Bool
access(all) let recurrent: Bool

// If non-nil, the voucher won't be valid after the expiry block height
pub let expiryBlockHeight: UInt64?
access(all) let expiryBlockHeight: UInt64?

// Hash of contract code
pub let codeHash: String
access(all) let codeHash: String

init(address: Address?, recurrent: Bool, expiryBlockHeight: UInt64?, codeHash: String) {
self.address = address
Expand All @@ -55,33 +55,33 @@ pub contract FlowContractAudits {
}

// Returns all current vouchers
pub fun getAllVouchers(): {String: AuditVoucher} {
access(all) fun getAllVouchers(): {String: AuditVoucher} {
return self.vouchers
}

// Get the associated dictionary key for given address and codeHash
pub fun generateVoucherKey(address: Address?, codeHash: String): String {
access(all) fun generateVoucherKey(address: Address?, codeHash: String): String {
if address != nil {
return address!.toString().concat("-").concat(codeHash)
}
return "any-".concat(codeHash)
}

pub fun hashContractCode(_ code: String): String {
access(all) fun hashContractCode(_ code: String): String {
return String.encodeHex(HashAlgorithm.SHA3_256.hash(code.utf8))
}

// Auditors can create new vouchers and remove them
pub resource Auditor {
access(all) resource Auditor {

// Create new voucher with contract code
pub fun addVoucher(address: Address?, recurrent: Bool, expiryOffset: UInt64?, code: String) {
access(all) fun addVoucher(address: Address?, recurrent: Bool, expiryOffset: UInt64?, code: String) {
let codeHash = FlowContractAudits.hashContractCode(code)
self.addVoucherHashed(address: address, recurrent: recurrent, expiryOffset: expiryOffset, codeHash: codeHash)
}

// Create new voucher with hashed contract code
pub fun addVoucherHashed(address: Address?, recurrent: Bool, expiryOffset: UInt64?, codeHash: String) {
access(all) fun addVoucherHashed(address: Address?, recurrent: Bool, expiryOffset: UInt64?, codeHash: String) {

// calculate expiry block height based on expiryOffset
var expiryBlockHeight: UInt64? = nil
Expand All @@ -102,35 +102,35 @@ pub contract FlowContractAudits {
}

// Remove a voucher with given key
pub fun deleteVoucher(key: String) {
access(all) fun deleteVoucher(key: String) {
FlowContractAudits.deleteVoucher(key)
}
}

// Used by admin to set the Auditor capability
pub resource interface AuditorProxyPublic {
pub fun setAuditorCapability(_ cap: Capability<&Auditor>)
access(all) resource interface AuditorProxyPublic {
access(all) fun setAuditorCapability(_ cap: Capability<&Auditor>)
}

// The auditor account will have audit access through AuditorProxy
// This enables the admin account to revoke access
// See https://docs.onflow.org/cadence/design-patterns/#capability-revocation
pub resource AuditorProxy: AuditorProxyPublic {
access(all) resource AuditorProxy: AuditorProxyPublic {
access(self) var auditorCapability: Capability<&Auditor>?

pub fun setAuditorCapability(_ cap: Capability<&Auditor>) {
access(all) fun setAuditorCapability(_ cap: Capability<&Auditor>) {
self.auditorCapability = cap
}

pub fun addVoucher(address: Address?, recurrent: Bool, expiryOffset: UInt64?, code: String) {
access(all) fun addVoucher(address: Address?, recurrent: Bool, expiryOffset: UInt64?, code: String) {
self.auditorCapability!.borrow()!.addVoucher(address: address, recurrent: recurrent, expiryOffset: expiryOffset, code: code)
}

pub fun addVoucherHashed(address: Address?, recurrent: Bool, expiryOffset: UInt64?, codeHash: String) {
access(all) fun addVoucherHashed(address: Address?, recurrent: Bool, expiryOffset: UInt64?, codeHash: String) {
self.auditorCapability!.borrow()!.addVoucherHashed(address: address, recurrent: recurrent, expiryOffset: expiryOffset, codeHash: codeHash)
}

pub fun deleteVoucher(key: String) {
access(all) fun deleteVoucher(key: String) {
self.auditorCapability!.borrow()!.deleteVoucher(key: key)
}

Expand All @@ -141,20 +141,20 @@ pub contract FlowContractAudits {
}

// Can be called by anyone but needs a capability to function
pub fun createAuditorProxy(): @AuditorProxy {
access(all) fun createAuditorProxy(): @AuditorProxy {
return <- create AuditorProxy()
}

pub resource Administrator {
access(all) resource Administrator {

// Creates new Auditor
pub fun createNewAuditor(): @Auditor {
access(all) fun createNewAuditor(): @Auditor {
emit AuditorCreated()
return <-create Auditor()
}

// Checks all vouchers and removes expired ones
pub fun cleanupExpiredVouchers() {
access(all) fun cleanupExpiredVouchers() {
for key in FlowContractAudits.vouchers.keys {
let v = FlowContractAudits.vouchers[key]!
if v.expiryBlockHeight != nil {
Expand All @@ -166,7 +166,7 @@ pub contract FlowContractAudits {
}

// For testing
pub fun useVoucherForDeploy(address: Address, code: String): Bool {
access(all) fun useVoucherForDeploy(address: Address, code: String): Bool {
return FlowContractAudits.useVoucherForDeploy(address: address, code: code)
}
}
Expand Down
48 changes: 24 additions & 24 deletions contracts/FlowFees.cdc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,67 +2,67 @@ import FungibleToken from 0xFUNGIBLETOKENADDRESS
import FlowToken from 0xFLOWTOKENADDRESS
import FlowStorageFees from 0xFLOWSTORAGEFEESADDRESS

pub contract FlowFees {
access(all) contract FlowFees {

// Event that is emitted when tokens are deposited to the fee vault
pub event TokensDeposited(amount: UFix64)
access(all) event TokensDeposited(amount: UFix64)

// Event that is emitted when tokens are withdrawn from the fee vault
pub event TokensWithdrawn(amount: UFix64)
access(all) event TokensWithdrawn(amount: UFix64)

// Event that is emitted when fees are deducted
pub event FeesDeducted(amount: UFix64, inclusionEffort: UFix64, executionEffort: UFix64)
access(all) event FeesDeducted(amount: UFix64, inclusionEffort: UFix64, executionEffort: UFix64)

// Event that is emitted when fee parameters change
pub event FeeParametersChanged(surgeFactor: UFix64, inclusionEffortCost: UFix64, executionEffortCost: UFix64)
access(all) event FeeParametersChanged(surgeFactor: UFix64, inclusionEffortCost: UFix64, executionEffortCost: UFix64)

// Private vault with public deposit function
access(self) var vault: @FlowToken.Vault

pub fun deposit(from: @FungibleToken.Vault) {
access(all) fun deposit(from: @FungibleToken.Vault) {
let from <- from as! @FlowToken.Vault
let balance = from.balance
self.vault.deposit(from: <-from)
emit TokensDeposited(amount: balance)
}

/// Get the balance of the Fees Vault
pub fun getFeeBalance(): UFix64 {
access(all) fun getFeeBalance(): UFix64 {
return self.vault.balance
}

pub resource Administrator {
access(all) resource Administrator {
// withdraw
//
// Allows the administrator to withdraw tokens from the fee vault
pub fun withdrawTokensFromFeeVault(amount: UFix64): @FungibleToken.Vault {
access(all) fun withdrawTokensFromFeeVault(amount: UFix64): @FungibleToken.Vault {
let vault <- FlowFees.vault.withdraw(amount: amount)
emit TokensWithdrawn(amount: amount)
return <-vault
}

/// Allows the administrator to change all the fee parameters at once
pub fun setFeeParameters(surgeFactor: UFix64, inclusionEffortCost: UFix64, executionEffortCost: UFix64) {
access(all) fun setFeeParameters(surgeFactor: UFix64, inclusionEffortCost: UFix64, executionEffortCost: UFix64) {
let newParameters = FeeParameters(surgeFactor: surgeFactor, inclusionEffortCost: inclusionEffortCost, executionEffortCost: executionEffortCost)
FlowFees.setFeeParameters(newParameters)
}

/// Allows the administrator to change the fee surge factor
pub fun setFeeSurgeFactor(_ surgeFactor: UFix64) {
access(all) fun setFeeSurgeFactor(_ surgeFactor: UFix64) {
let oldParameters = FlowFees.getFeeParameters()
let newParameters = FeeParameters(surgeFactor: surgeFactor, inclusionEffortCost: oldParameters.inclusionEffortCost, executionEffortCost: oldParameters.executionEffortCost)
FlowFees.setFeeParameters(newParameters)
}
}

/// A struct holding the fee parameters needed to calculate the fees
pub struct FeeParameters {
access(all) struct FeeParameters {
/// The surge factor is used to make transaction fees respond to high loads on the network
pub var surgeFactor: UFix64
access(all) var surgeFactor: UFix64
/// The FLOW cost of one unit of inclusion effort. The FVM is responsible for metering inclusion effort.
pub var inclusionEffortCost: UFix64
access(all) var inclusionEffortCost: UFix64
/// The FLOW cost of one unit of execution effort. The FVM is responsible for metering execution effort.
pub var executionEffortCost: UFix64
access(all) var executionEffortCost: UFix64

init(surgeFactor: UFix64, inclusionEffortCost: UFix64, executionEffortCost: UFix64){
self.surgeFactor = surgeFactor
Expand All @@ -72,15 +72,15 @@ pub contract FlowFees {
}

// VerifyPayerBalanceResult is returned by the verifyPayersBalanceForTransactionExecution function
pub struct VerifyPayerBalanceResult {
access(all) struct VerifyPayerBalanceResult {
// True if the payer has sufficient balance for the transaction execution to continue
pub let canExecuteTransaction: Bool
access(all) let canExecuteTransaction: Bool
// The minimum payer balance required for the transaction execution to continue.
// This value is defined by verifyPayersBalanceForTransactionExecution.
pub let requiredBalance: UFix64
access(all) let requiredBalance: UFix64
// The maximum transaction fees (inclusion fees + execution fees) the transaction can incur
// (if all available execution effort is used)
pub let maximumTransactionFees: UFix64
access(all) let maximumTransactionFees: UFix64

init(canExecuteTransaction: Bool, requiredBalance: UFix64, maximumTransactionFees: UFix64){
self.canExecuteTransaction = canExecuteTransaction
Expand All @@ -97,7 +97,7 @@ pub contract FlowFees {
//
// The requiredBalance balance is defined as the minimum account balance +
// maximum transaction fees (inclusion fees + execution fees at max execution effort).
pub fun verifyPayersBalanceForTransactionExecution(
access(all) fun verifyPayersBalanceForTransactionExecution(
_ payerAcct: AuthAccount,
inclusionEffort: UFix64,
maxExecutionEffort: UFix64,
Expand Down Expand Up @@ -133,7 +133,7 @@ pub contract FlowFees {

/// Called when a transaction is submitted to deduct the fee
/// from the AuthAccount that submitted it
pub fun deductTransactionFee(_ acct: AuthAccount, inclusionEffort: UFix64, executionEffort: UFix64) {
access(all) fun deductTransactionFee(_ acct: AuthAccount, inclusionEffort: UFix64, executionEffort: UFix64) {
var feeAmount = self.computeFees(inclusionEffort: inclusionEffort, executionEffort: executionEffort)

if feeAmount == UFix64(0) {
Expand All @@ -142,7 +142,7 @@ pub contract FlowFees {
return
}

let tokenVault = acct.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault)
let tokenVault = acct.borrow<auth(FungibleToken.Withdrawable) &FlowToken.Vault>(from: /storage/flowTokenVault)
?? panic("Unable to borrow reference to the default token vault")


Expand All @@ -162,7 +162,7 @@ pub contract FlowFees {
emit FeesDeducted(amount: feeAmount, inclusionEffort: inclusionEffort, executionEffort: executionEffort)
}

pub fun getFeeParameters(): FeeParameters {
access(all) fun getFeeParameters(): FeeParameters {
return self.account.copy<FeeParameters>(from: /storage/FlowTxFeeParameters) ?? panic("Error getting tx fee parameters. They need to be initialized first!")
}

Expand All @@ -175,7 +175,7 @@ pub contract FlowFees {


// compute the transaction fees with the current fee parameters and the given inclusionEffort and executionEffort
pub fun computeFees(inclusionEffort: UFix64, executionEffort: UFix64): UFix64 {
access(all) fun computeFees(inclusionEffort: UFix64, executionEffort: UFix64): UFix64 {
let params = self.getFeeParameters()

let totalFees = params.surgeFactor * ( inclusionEffort * params.inclusionEffortCost + executionEffort * params.executionEffortCost )
Expand Down
Loading