diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index bba6481..21bed91 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,10 +2,13 @@ name: CI on: pull_request: - branches: [main] + branches: + - main + - stable-cadence push: - branches: [main] - + branches: + - main + - stable-cadence jobs: tests: name: Flow CLI Tests @@ -15,7 +18,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v3 with: - go-version: '1.20.x' + go-version: "1.20.x" - uses: actions/cache@v1 with: path: ~/go/pkg/mod @@ -23,17 +26,14 @@ jobs: restore-keys: | ${{ runner.os }}-go- - name: Install Flow CLI - run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)" -- v1.13.1 + run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/feature/stable-cadence/install.sh)" - name: Flow CLI Version - run: flow version + run: flow-c1 version - name: Update PATH run: echo "/root/.local/bin" >> $GITHUB_PATH - name: Run tests run: make ci - - name: Normalize coverage report filepaths - run : sh ./local/normalize_coverage_report.sh - name: Upload coverage reports to Codecov uses: codecov/codecov-action@v3 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - \ No newline at end of file diff --git a/Makefile b/Makefile index 2d00184..6477d5a 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ test: $(MAKE) generate -C lib/go $(MAKE) test -C lib/go - flow test --cover --covercode="contracts" --coverprofile="coverage.lcov" tests/*.cdc + flow-c1 test --cover --covercode="contracts" --coverprofile="coverage.lcov" tests/*.cdc .PHONY: ci ci: diff --git a/README.md b/README.md index d956984..5c1f055 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,6 @@ Coordinated Upgrade. | Network | Address | | --------- | ------------------------------------------------------------------------------------------------------------------------- | -| Crescendo | [0x27b2302520211b67](https://crescendo.flowdiver.io/contract/A.27b2302520211b67.MigrationContractStaging?tab=deployments) | | Testnet | [0x2ceae959ed1a7e7a](https://contractbrowser.com/A.2ceae959ed1a7e7a.MigrationContractStaging) | | Mainnet | [56100d46aa9b0212](https://contractbrowser.com/A.56100d46aa9b0212.MigrationContractStaging) | @@ -106,13 +105,13 @@ import "MigrationContractStaging" transaction(contractName: String, contractCode: String) { let host: &MigrationContractStaging.Host - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, SaveValue) &Account) { // Configure Host resource if needed - if signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { - signer.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) + if signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { + signer.storage.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) } // Assign Host reference - self.host = signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath)! + self.host = signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath)! } execute { @@ -229,7 +228,7 @@ access(all) struct ContractUpdate { access(all) view fun identifier(): String /// Returns whether this contract update passed the last emulated migration, validating the contained code. /// NOTE: false could mean validation hasn't begun, the code wasn't included in emulation, or validation failed - access(all) view fun isValidated(): Bool { + access(all) view fun isValidated(): Bool /// Replaces the ContractUpdate code with that provided. access(contract) fun replaceCode(_ code: String) } @@ -255,7 +254,7 @@ access(all) event StagingStatusUpdated( capsuleUUID: UInt64, address: Address, code: String, - contract: String, + contractIdentifier: String, action: String ) ``` diff --git a/contracts/DependencyAudit.cdc b/contracts/DependencyAudit.cdc new file mode 100644 index 0000000..39d5598 --- /dev/null +++ b/contracts/DependencyAudit.cdc @@ -0,0 +1,130 @@ +import "MigrationContractStaging" + +// This contract is is used by the FVM calling the `checkDependencies` function from a function of the same name and singnature in the FlowServiceAccount contract, +// at the end of every transaction. +// The `dependenciesAddresses` and `dependenciesNames` will be all the dependencies needded to run that transaction. +// +// The `checkDependencies` function will check if any of the dependencies are not staged in the MigrationContractStaging contract. +// If any of the dependencies are not staged, the function will emit an event with the unstaged dependencies, or panic if `panicOnUnstaged` is set to true. +access(all) contract DependencyAudit { + + access(all) let AdministratorStoragePath: StoragePath + + // The system addresses have contracts that will not be stages via the migration contract so we exclude them from the dependency chekcs + access(self) var excludedAddresses: {Address: Bool} + + access(all) var panicOnUnstaged: Bool + + access(all) event UnstagedDependencies(dependencies: [Dependency]) + + access(all) event PanicOnUnstagedDependenciesChanged(shouldPanic: Bool) + + // checkDependencies is called from the FlowServiceAccount contract + access(account) fun checkDependencies(_ dependenciesAddresses: [Address], _ dependenciesNames: [String], _ authorizers: [Address]) { + var unstagedDependencies: [Dependency] = [] + + var numDependencies = dependenciesAddresses.length + var i = 0 + while i < numDependencies { + let isExcluded = DependencyAudit.excludedAddresses[dependenciesAddresses[i]] ?? false + if isExcluded { + i = i + 1 + continue + } + + let staged = MigrationContractStaging.isStaged(address: dependenciesAddresses[i], name: dependenciesNames[i]) + if !staged { + unstagedDependencies.append(Dependency(address: dependenciesAddresses[i], name: dependenciesNames[i])) + } + + i = i + 1 + } + + if unstagedDependencies.length > 0 { + if DependencyAudit.panicOnUnstaged { + // If `panicOnUnstaged` is set to true, the transaction will panic if there are any unstaged dependencies + // the panic message will include the unstaged dependencies + var unstagedDependenciesString = "" + var numUnstagedDependencies = unstagedDependencies.length + var j = 0 + while j < numUnstagedDependencies { + if j > 0 { + unstagedDependenciesString = unstagedDependenciesString.concat(", ") + } + unstagedDependenciesString = unstagedDependenciesString.concat(unstagedDependencies[j].toString()) + + j = j + 1 + } + + // the transactions will fail with a message that looks like this: `error: panic: Found unstaged dependencies: A.2ceae959ed1a7e7a.MigrationContractStaging, A.2ceae959ed1a7e7a.DependencyAudit` + panic("This transaction is using dependencies not staged for Crescendo upgrade coming soon! Learn more: https://bit.ly/FLOWCRESCENDO. Dependencies not staged: ".concat(unstagedDependenciesString)) + } else { + emit UnstagedDependencies(dependencies: unstagedDependencies) + } + } + } + + // The Administrator resorce can be used to add or remove addresses from the excludedAddresses dictionary + // + access(all) resource Administrator { + // addExcludedAddresses add the addresses to the excludedAddresses dictionary + access(all) fun addExcludedAddresses(addresses: [Address]) { + for address in addresses { + DependencyAudit.excludedAddresses[address] = true + } + } + + // removeExcludedAddresses remove the addresses from the excludedAddresses dictionary + access(all) fun removeExcludedAddresses(addresses: [Address]) { + for address in addresses { + DependencyAudit.excludedAddresses.remove(key: address) + } + } + + // setPanicOnUnstagedDependencies sets the `panicOnUnstaged` variable to the value of `shouldPanic` + access(all) fun setPanicOnUnstagedDependencies(shouldPanic: Bool) { + DependencyAudit.panicOnUnstaged = shouldPanic + emit PanicOnUnstagedDependenciesChanged(shouldPanic: shouldPanic) + } + + // testCheckDependencies is used for testing purposes + // It will call the `checkDependencies` function with the provided dependencies + // `checkDependencies` is otherwise not callable from the outside + access(all) fun testCheckDependencies(_ dependenciesAddresses: [Address], _ dependenciesNames: [String], _ authorizers: [Address]) { + return DependencyAudit.checkDependencies(dependenciesAddresses, dependenciesNames, authorizers) + } + } + + access(all) struct Dependency { + access(all) let address: Address + access(all) let name: String + + init(address: Address, name: String) { + self.address = address + self.name = name + } + + access(all) fun toString(): String { + var addressString = self.address.toString() + // remove 0x prefix + addressString = addressString.slice(from: 2, upTo: addressString.length) + return "A.".concat(addressString).concat(".").concat(self.name) + } + } + + // The admin resource is saved to the storage so that the admin can be accessed by the service account + // The `excludedAddresses` will be the addresses with the system contracts. + init(excludedAddresses: [Address]) { + self.excludedAddresses = {} + self.panicOnUnstaged = false + + self.AdministratorStoragePath = /storage/flowDependencyAuditAdmin + + for address in excludedAddresses { + self.excludedAddresses[address] = true + } + + let admin <- create Administrator() + self.account.storage.save(<-admin, to: self.AdministratorStoragePath) + } +} diff --git a/contracts/MigrationContractStaging.cdc b/contracts/MigrationContractStaging.cdc index 106ac3a..6324d0f 100644 --- a/contracts/MigrationContractStaging.cdc +++ b/contracts/MigrationContractStaging.cdc @@ -33,7 +33,7 @@ access(all) contract MigrationContractStaging { capsuleUUID: UInt64, address: Address, code: String, - contract: String, + contractIdentifier: String, action: String ) /// Emitted when emulated contract migrations have been completed, where failedContracts are named by their @@ -78,20 +78,20 @@ access(all) contract MigrationContractStaging { self.stagedContracts.insert(key: host.address(), [name]) // Create a new Capsule to store the staged code let capsule <- self.createCapsule(host: host, name: name, code: code) - self.account.save(<-capsule, to: capsulePath) + self.account.storage.save(<-capsule, to: capsulePath) return } // We've seen contracts from this host address before - check if the contract is already staged if let contractIndex = self.stagedContracts[host.address()]!.firstIndex(of: name) { // The contract is already staged - replace the code - let capsule = self.account.borrow<&Capsule>(from: capsulePath) + let capsule = self.account.storage.borrow<&Capsule>(from: capsulePath) ?? panic("Could not borrow existing Capsule from storage for staged contract") capsule.replaceCode(code: code) return } // First time staging this contract - add the contract name to the list of contracts staged for host self.stagedContracts[host.address()]!.append(name) - self.account.save(<-self.createCapsule(host: host, name: name, code: code), to: capsulePath) + self.account.storage.save(<-self.createCapsule(host: host, name: name, code: code), to: capsulePath) } /// Removes the staged contract code from the staging environment. @@ -113,7 +113,7 @@ access(all) contract MigrationContractStaging { capsuleUUID: capsuleUUID, address: address, code: "", - contract: name, + contractIdentifier: name, action: "unstage" ) } @@ -122,13 +122,13 @@ access(all) contract MigrationContractStaging { /// Returns the last block height at which updates can be staged /// - access(all) fun getStagingCutoff(): UInt64? { + access(all) view fun getStagingCutoff(): UInt64? { return self.stagingCutoff } /// Returns whether the staging period is currently active /// - access(all) fun isStagingPeriodActive(): Bool { + access(all) view fun isStagingPeriodActive(): Bool { return self.stagingCutoff == nil || getCurrentBlock().height <= self.stagingCutoff! } @@ -160,7 +160,7 @@ access(all) contract MigrationContractStaging { /// access(all) view fun getStagedContractUpdate(address: Address, name: String): ContractUpdate? { let capsulePath = self.deriveCapsuleStoragePath(contractAddress: address, contractName: name) - if let capsule = self.account.borrow<&Capsule>(from: capsulePath) { + if let capsule = self.account.storage.borrow<&Capsule>(from: capsulePath) { return capsule.getContractUpdate() } else { return nil @@ -353,7 +353,7 @@ access(all) contract MigrationContractStaging { capsuleUUID: self.uuid, address: self.update.address, code: code, - contract: self.update.name, + contractIdentifier: self.update.name, action: "replace" ) } @@ -407,7 +407,7 @@ access(all) contract MigrationContractStaging { capsuleUUID: capsule.uuid, address: host.address(), code: code, - contract: name, + contractIdentifier: name, action: "stage" ) return <- capsule @@ -431,7 +431,7 @@ access(all) contract MigrationContractStaging { /// access(self) fun destroyCapsule(address: Address, name: String): UInt64? { let capsulePath = self.deriveCapsuleStoragePath(contractAddress: address, contractName: name) - if let capsule <- self.account.load<@Capsule>(from: capsulePath) { + if let capsule <- self.account.storage.load<@Capsule>(from: capsulePath) { let capsuleUUID = capsule.uuid destroy capsule return capsuleUUID @@ -452,6 +452,6 @@ access(all) contract MigrationContractStaging { self.stagingCutoff = nil self.lastEmulatedMigrationResult = nil - self.account.save(<-create Admin(), to: self.AdminStoragePath) + self.account.storage.save(<-create Admin(), to: self.AdminStoragePath) } } diff --git a/contracts/staged-contract-updates/README.md b/contracts/staged-contract-updates/README.md index efe7f00..e3b81a2 100644 --- a/contracts/staged-contract-updates/README.md +++ b/contracts/staged-contract-updates/README.md @@ -1,6 +1,6 @@ # StagedContractUpdates -> :warning: This contract is general purpose and is not supporting Cadence 1.0 contract staging! Please refer to the +> :warning: This contract is general purpose and is not supporting Cadence 1.0 contract staging! Please refer to > `MigrationContractStaging` for reference on staging your contract for the network-wide coordinated update. Enables pre-defined contract update deployments to a set of wrapped account at or beyond a specified block height. For @@ -93,7 +93,7 @@ should occur according to the contract set's dependency graph. In our example, our dependency graph will look like this: -![flat dependency dag](./resources/dependency_dag.png) +![flat dependency dag](../../resources/dependency_dag.png) So the contracts should be updated in the following order: @@ -114,11 +114,11 @@ More concretely, if we try to update all three contracts in the same transaction Consequently, we instead batch updates based on the contract's maximum depth in the dependency graph. In our case, instead of `[A, B, C]` we update `A` in one transaction, `B` in the next, and lastly `C` can be updated. -![dependency graph with node depth](./resources/dependency_dag_with_depth.png) +![dependency graph with node depth](../../resources/dependency_dag_with_depth.png) This concept can be extrapolated out for larger dependency graphs. For example, take the following: -![larger dag example](./resources/larger_dag.png) +![larger dag example](../../resources/larger_dag.png) This group of contracts would be updated over the same three stages, with each stage including contracts according to their maximum depth in the dependency graph. In this case: diff --git a/contracts/staged-contract-updates/StagedContractUpdates.cdc b/contracts/staged-contract-updates/StagedContractUpdates.cdc index 1e69c2c..1c3afb0 100644 --- a/contracts/staged-contract-updates/StagedContractUpdates.cdc +++ b/contracts/staged-contract-updates/StagedContractUpdates.cdc @@ -1,4 +1,5 @@ import "MetadataViews" +import "ViewResolver" /// This contract defines resources which enable storage of contract code for the purposes of updating at or beyond /// some blockheight boundary either by the containing resource's owner or by some delegated party. @@ -106,37 +107,37 @@ access(all) contract StagedContractUpdates { /* --- Host --- */ // - /// Encapsulates an AuthAccount, exposing only the ability to update contracts on the underlying account + /// Encapsulates an Account, exposing only the ability to update contracts on the underlying account /// access(all) resource Host { - access(self) let accountCapability: Capability<&AuthAccount> + access(self) let accountCapability: Capability - init(accountCapability: Capability<&AuthAccount>) { + init(accountCapability: Capability) { self.accountCapability = accountCapability } /// Updates the contract with the specified name and code /// - access(all) fun update(name: String, code: [UInt8]): Bool { + access(UpdateContract) fun update(name: String, code: [UInt8]): Bool { if let account = self.accountCapability.borrow() { // TODO: Replace update__experimental with tryUpdate() once it's available // let deploymentResult = account.contracts.tryUpdate(name: name, code: code) // return deploymentResult.success - account.contracts.update__experimental(name: name, code: code) + account.contracts.tryUpdate(name: name, code: code) return true } return false } - /// Checks the wrapped AuthAccount Capability + /// Checks the wrapped Account Capability /// - access(all) fun checkAccountCapability(): Bool { + access(all) view fun checkAccountCapability(): Bool { return self.accountCapability.check() } /// Returns the Address of the underlying account /// - access(all) fun getHostAddress(): Address? { + access(all) view fun getHostAddress(): Address? { return self.accountCapability.borrow()?.address } } @@ -146,26 +147,26 @@ access(all) contract StagedContractUpdates { /// Public interface enabling queries about the Updater /// access(all) resource interface UpdaterPublic { - access(all) fun getID(): UInt64 - access(all) fun getBlockUpdateBoundary(): UInt64 - access(all) fun getContractAccountAddresses(): [Address] - access(all) fun getDeployments(): [[ContractUpdate]] - access(all) fun getCurrentDeploymentStage(): Int - access(all) fun getFailedDeployments(): {Int: [String]} - access(all) fun hasBeenUpdated(): Bool - access(all) fun getInvalidHosts(): [Address] + access(all) view fun getID(): UInt64 + access(all) view fun getBlockUpdateBoundary(): UInt64 + access(all) view fun getContractAccountAddresses(): [Address] + access(all) view fun getDeployments(): [[ContractUpdate]] + access(all) view fun getCurrentDeploymentStage(): Int + access(all) view fun getFailedDeployments(): {Int: [String]} + access(all) view fun hasBeenUpdated(): Bool + access(all) view fun getInvalidHosts(): [Address] } /// Resource that enables delayed contract updates to a wrapped account at or beyond a specified block height /// - access(all) resource Updater : UpdaterPublic, MetadataViews.Resolver { + access(all) resource Updater : UpdaterPublic, ViewResolver.Resolver { /// Update to occur at or beyond this block height access(self) let blockUpdateBoundary: UInt64 /// Update status defining whether all update stages have been *attempted* /// NOTE: `true` does not necessarily mean all updates were successful access(self) var updateComplete: Bool /// Capabilities for contract hosting accounts - access(self) let hosts: {Address: Capability<&Host>} + access(self) let hosts: {Address: Capability} /// Updates ordered by their deployment sequence and staged by their dependency depth /// NOTE: Dev should be careful to validate their dependency tree such that updates are performed from root /// to leaf dependencies @@ -177,7 +178,7 @@ access(all) contract StagedContractUpdates { init( blockUpdateBoundary: UInt64, - hosts: [Capability<&Host>], + hosts: [Capability], deployments: [[ContractUpdate]] ) { pre { @@ -209,7 +210,7 @@ access(all) contract StagedContractUpdates { /// Executes the next update stage for all contracts defined in deployment, returning true if all stages have /// been attempted and false if stages remain /// - access(all) fun update(): Bool? { + access(UpdateContract) fun update(): Bool? { // Return early if we've already updated if self.updateComplete { return true @@ -266,39 +267,39 @@ access(all) contract StagedContractUpdates { /* --- Public getters --- */ - access(all) fun getID(): UInt64 { + access(all) view fun getID(): UInt64 { return self.uuid } - access(all) fun getBlockUpdateBoundary(): UInt64 { + access(all) view fun getBlockUpdateBoundary(): UInt64 { return self.blockUpdateBoundary } - access(all) fun getContractAccountAddresses(): [Address] { + access(all) view fun getContractAccountAddresses(): [Address] { return self.hosts.keys } - access(all) fun getDeployments(): [[ContractUpdate]] { + access(all) view fun getDeployments(): [[ContractUpdate]] { return self.deployments } - access(all) fun getCurrentDeploymentStage(): Int { + access(all) view fun getCurrentDeploymentStage(): Int { return self.currentDeploymentStage } - access(all) fun getFailedDeployments(): {Int: [String]} { + access(all) view fun getFailedDeployments(): {Int: [String]} { return self.failedDeployments } - access(all) fun hasBeenUpdated(): Bool { + access(all) view fun hasBeenUpdated(): Bool { return self.updateComplete } - access(all) fun getInvalidHosts(): [Address] { + access(all) view fun getInvalidHosts(): [Address] { var invalidHosts: [Address] = [] for host in self.hosts.values { if !host.check() || !host.borrow()!.checkAccountCapability() { - invalidHosts.append(host.address) + invalidHosts = invalidHosts.concat([host.address]) } } return invalidHosts @@ -306,7 +307,7 @@ access(all) contract StagedContractUpdates { /* --- MetadataViews.Resolver --- */ - access(all) fun getViews(): [Type] { + access(all) view fun getViews(): [Type] { return [Type()] } @@ -325,16 +326,16 @@ access(all) contract StagedContractUpdates { return nil } } - + /* --- Delegatee --- */ // /// Public interface for Delegatee /// access(all) resource interface DelegateePublic { - access(all) fun check(id: UInt64): Bool? - access(all) fun getUpdaterIDs(): [UInt64] - access(all) fun delegate(updaterCap: Capability<&Updater>) - access(all) fun removeAsUpdater(updaterCap: Capability<&Updater>) + access(all) view fun check(id: UInt64): Bool? + access(all) view fun getUpdaterIDs(): [UInt64] + access(all) fun delegate(updaterCap: Capability) + access(all) fun removeAsUpdater(updaterCap: Capability) } /// Resource capable of executed delegated updates via encapsulated Updater Capabilities @@ -345,7 +346,7 @@ access(all) contract StagedContractUpdates { /// ready when updates are performed will be revoked from the Delegatee access(self) let blockUpdateBoundary: UInt64 /// Mapping of all delegated Updater Capabilities by their UUID - access(self) let delegatedUpdaters: {UInt64: Capability<&Updater>} + access(self) let delegatedUpdaters: {UInt64: Capability} init(blockUpdateBoundary: UInt64) { self.blockUpdateBoundary = blockUpdateBoundary @@ -354,19 +355,19 @@ access(all) contract StagedContractUpdates { /// Checks if the specified DelegatedUpdater Capability is contained and valid /// - access(all) fun check(id: UInt64): Bool? { + access(all) view fun check(id: UInt64): Bool? { return self.delegatedUpdaters[id]?.check() ?? nil } /// Returns the IDs of delegated Updaters /// - access(all) fun getUpdaterIDs(): [UInt64] { + access(all) view fun getUpdaterIDs(): [UInt64] { return self.delegatedUpdaters.keys } /// Allows for the delegation of contract updates as defined within the Updater resource /// - access(all) fun delegate(updaterCap: Capability<&Updater>) { + access(all) fun delegate(updaterCap: Capability) { pre { getCurrentBlock().height < self.blockUpdateBoundary: "Delegation must occur before Delegatee boundary of ".concat(self.blockUpdateBoundary.toString()) @@ -389,7 +390,7 @@ access(all) contract StagedContractUpdates { /// Enables Updaters to remove their delegation /// - access(all) fun removeAsUpdater(updaterCap: Capability<&Updater>) { + access(all) fun removeAsUpdater(updaterCap: Capability) { pre { updaterCap.check(): "Invalid DelegatedUpdater Capability!" self.delegatedUpdaters.containsKey(updaterCap.borrow()!.getID()): "No Updater found for ID!" @@ -403,7 +404,7 @@ access(all) contract StagedContractUpdates { /// to be updated (updater.update() returns nil) or the attempted update is the final staged (updater.update() /// returns true), the corresponding Updater Capability is removed. /// - access(all) fun update(updaterIDs: [UInt64]) { + access(UpdateContract) fun update(updaterIDs: [UInt64]) { for id in updaterIDs { // Invalid ID - mark as purged and continue if self.delegatedUpdaters[id] == nil { @@ -411,7 +412,7 @@ access(all) contract StagedContractUpdates { } // Check Capability - if invalid, remove Capability, mark as purged and continue - let updaterCap: Capability<&StagedContractUpdates.Updater> = self.delegatedUpdaters[id]! + let updaterCap: Capability = self.delegatedUpdaters[id]! if !updaterCap.check() { self.delegatedUpdaters.remove(key: id) continue @@ -429,7 +430,7 @@ access(all) contract StagedContractUpdates { /// Enables admin removal of a Updater Capability /// - access(all) fun removeDelegatedUpdater(id: UInt64) { + access(Remove) fun removeDelegatedUpdater(id: UInt64) { if !self.delegatedUpdaters.containsKey(id) { return } @@ -465,7 +466,7 @@ access(all) contract StagedContractUpdates { /// Returns a Capability on the Delegatee associated with this contract /// access(all) fun getContractDelegateeCapability(): Capability<&{DelegateePublic}> { - let delegateeCap = self.account.getCapability<&{DelegateePublic}>(self.DelegateePublicPath) + let delegateeCap = self.account.capabilities.get<&{DelegateePublic}>(self.DelegateePublicPath) assert(delegateeCap.check(), message: "Invalid Delegatee Capability retrieved") return delegateeCap } @@ -506,7 +507,7 @@ access(all) contract StagedContractUpdates { /// Returns a new Host resource /// - access(all) fun createNewHost(accountCap: Capability<&AuthAccount>): @Host { + access(all) fun createNewHost(accountCap: Capability): @Host { return <- create Host(accountCapability: accountCap) } @@ -514,7 +515,7 @@ access(all) contract StagedContractUpdates { /// access(all) fun createNewUpdater( blockUpdateBoundary: UInt64, - hosts: [Capability<&Host>], + hosts: [Capability], deployments: [[ContractUpdate]] ): @Updater { let updater <- create Updater(blockUpdateBoundary: blockUpdateBoundary, hosts: hosts, deployments: deployments) @@ -542,10 +543,11 @@ access(all) contract StagedContractUpdates { self.DelegateePublicPath = PublicPath(identifier: "StagedContractUpdatesDelegateePublic_".concat(contractAddress))! self.CoordinatorStoragePath = StoragePath(identifier: "StagedContractUpdatesCoordinator_".concat(contractAddress))! - self.account.save(<-create Delegatee(blockUpdateBoundary: blockUpdateBoundary), to: self.DelegateeStoragePath) - self.account.link<&{DelegateePublic}>(self.DelegateePublicPath, target: self.DelegateeStoragePath) + self.account.storage.save(<-create Delegatee(blockUpdateBoundary: blockUpdateBoundary), to: self.DelegateeStoragePath) + let delegateePublicCap = self.account.capabilities.storage.issue<&{DelegateePublic}>(self.DelegateeStoragePath) + self.account.capabilities.publish(delegateePublicCap, at: self.DelegateePublicPath) - self.account.save(<-create Coordinator(), to: self.CoordinatorStoragePath) + self.account.storage.save(<-create Coordinator(), to: self.CoordinatorStoragePath) emit ContractBlockUpdateBoundaryUpdated(old: nil, new: blockUpdateBoundary) } diff --git a/contracts/standards/Burner.cdc b/contracts/standards/Burner.cdc new file mode 100644 index 0000000..0a3795e --- /dev/null +++ b/contracts/standards/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 + } + } +} \ No newline at end of file diff --git a/contracts/standards/FungibleToken.cdc b/contracts/standards/FungibleToken.cdc index 48b092d..c731911 100644 --- a/contracts/standards/FungibleToken.cdc +++ b/contracts/standards/FungibleToken.cdc @@ -2,21 +2,18 @@ # The Flow Fungible Token standard -## `FungibleToken` contract interface +## `FungibleToken` contract -The interface that all Fungible Token contracts would have to conform to. -If a users wants to deploy a new token contract, their contract -would need to implement the FungibleToken interface. - -Their contract would have to follow all the rules and naming -that the interface specifies. +The Fungible Token standard is no longer an interface +that all fungible token contracts would have to conform to. -## `Vault` resource +If a users wants to deploy a new token contract, their contract +does not need to implement the FungibleToken interface, but their tokens +do need to implement the interfaces defined in this contract. -Each account that owns tokens would need to have an instance -of the Vault resource stored in their account storage. +## `Vault` resource interface -The Vault resource has methods that the owner and other users can call. +Each fungible token resource type needs to implement the `Vault` resource interface. ## `Provider`, `Receiver`, and `Balance` resource interfaces @@ -32,32 +29,43 @@ these interfaces to do various things with the tokens. For example, a faucet can be implemented by conforming to the Provider interface. -By using resources and interfaces, users of Fungible Token contracts -can send and receive tokens peer-to-peer, without having to interact -with a central ledger smart contract. To send tokens to another user, -a user would simply withdraw the tokens from their Vault, then call -the deposit function on another user's Vault to complete the transfer. - */ -/// The interface that Fungible Token contracts implement. -/// -pub contract interface FungibleToken { +import ViewResolver from "ViewResolver" +import Burner from "Burner" - /// The total number of tokens in existence. - /// It is up to the implementer to ensure that the total supply - /// stays accurate and up to date - pub var totalSupply: UFix64 +/// FungibleToken +/// +/// Fungible Token implementations are no longer required to implement the fungible token +/// interface. We still have it as an interface here because there are some useful +/// utility methods that many projects will still want to have on their contracts, +/// but they are by no means required. all that is required is that the token +/// implements the `Vault` interface +access(all) contract interface FungibleToken: ViewResolver { - /// The event that is emitted when the contract is created - pub event TokensInitialized(initialSupply: UFix64) + // An entitlement for allowing the withdrawal of tokens from a Vault + access(all) entitlement Withdraw /// The event that is emitted when tokens are withdrawn from a Vault - pub event TokensWithdrawn(amount: UFix64, from: Address?) + access(all) event Withdrawn(type: String, amount: UFix64, from: Address?, fromUUID: UInt64, withdrawnUUID: UInt64) + + /// The event that is emitted when tokens are deposited to a Vault + access(all) event Deposited(type: String, amount: UFix64, to: Address?, toUUID: UInt64, depositedUUID: UInt64) + + /// Event that is emitted when the global burn method is called with a non-zero balance + access(all) event Burned(type: String, amount: UFix64, fromUUID: UInt64) - /// The event that is emitted when tokens are deposited into a Vault - pub event TokensDeposited(amount: UFix64, to: Address?) + /// Balance + /// + /// The interface that provides standard functions\ + /// for getting balance information + /// + access(all) resource interface Balance { + access(all) var balance: UFix64 + } + /// Provider + /// /// The interface that enforces the requirements for withdrawing /// tokens from the implementing type. /// @@ -65,35 +73,37 @@ pub contract interface FungibleToken { /// because it leaves open the possibility of creating custom providers /// that do not necessarily need their own balance. /// - pub resource interface Provider { + access(all) resource interface Provider { + + /// Function to ask a provider if a specific amount of tokens + /// is available to be withdrawn + /// This could be useful to avoid panicing when calling withdraw + /// when the balance is unknown + /// Additionally, if the provider is pulling from multiple vaults + /// it only needs to check some of the vaults until the desired amount + /// is reached, potentially helping with performance. + /// + access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool - /// Subtracts tokens from the owner's Vault + /// withdraw subtracts tokens from the implementing resource /// and returns a Vault with the removed tokens. /// - /// The function's access level is public, but this is not a problem - /// because only the owner storing the resource in their account - /// can initially call this function. - /// - /// The owner may grant other accounts access by creating a private - /// capability that allows specific other users to access - /// the provider resource through a reference. + /// The function's access level is `access(Withdraw)` + /// So in order to access it, one would either need the object itself + /// or an entitled reference with `Withdraw`. /// - /// The owner may also grant all accounts access by creating a public - /// capability that allows all users to access the provider - /// resource through a reference. - /// - /// @param amount: The amount of tokens to be withdrawn from the vault - /// @return The Vault resource containing the withdrawn funds - /// - pub fun withdraw(amount: UFix64): @Vault { + access(Withdraw) fun withdraw(amount: UFix64): @{Vault} { post { // `result` refers to the return value result.balance == amount: "Withdrawal amount must be the same as the balance of the withdrawn Vault" + emit Withdrawn(type: self.getType().identifier, amount: amount, from: self.owner?.address, fromUUID: self.uuid, withdrawnUUID: result.uuid) } } } + /// Receiver + /// /// The interface that enforces the requirements for depositing /// tokens into the implementing type. /// @@ -102,30 +112,54 @@ pub contract interface FungibleToken { /// can do custom things with the tokens, like split them up and /// send them to different places. /// - pub resource interface Receiver { + access(all) resource interface Receiver { - /// Takes a Vault and deposits it into the implementing resource type - /// - /// @param from: The Vault resource containing the funds that will be deposited + /// deposit takes a Vault and deposits it into the implementing resource type /// - pub fun deposit(from: @Vault) + access(all) fun deposit(from: @{Vault}) - /// Below is referenced from the FLIP #69 https://github.com/onflow/flips/blob/main/flips/20230206-fungible-token-vault-type-discovery.md - /// - /// Returns the dictionary of Vault types that the the receiver is able to accept in its `deposit` method - /// this then it would return `{Type<@FlowToken.Vault>(): true}` and if any custom receiver - /// uses the default implementation then it would return empty dictionary as its parent - /// resource doesn't conform with the `FungibleToken.Vault` resource. - /// - /// Custom receiver implementations are expected to upgrade their contracts to add an implementation - /// that supports this method because it is very valuable for various applications to have. - /// - /// @return dictionary of supported deposit vault types by the implementing resource. - /// - pub fun getSupportedVaultTypes(): {Type: Bool} { + /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts + access(all) view fun getSupportedVaultTypes(): {Type: Bool} + + /// Returns whether or not the given type is accepted by the Receiver + /// A vault that can accept any type should just return true by default + access(all) view fun isSupportedVaultType(type: Type): Bool + } + + /// Vault + /// + /// Ideally, this interface would also conform to Receiver, Balance, Transferor, Provider, and Resolver + /// but that is not supported yet + /// + access(all) resource interface Vault: Receiver, Provider, Balance, ViewResolver.Resolver, Burner.Burnable { + + /// Field that tracks the balance of a vault + access(all) var balance: UFix64 + + /// Called when a fungible token is burned via the `Burner.burn()` method + /// Implementations can do any bookkeeping or emit any events + /// that should be emitted when a vault is destroyed. + /// Many implementations will want to update the token's total supply + /// to reflect that the tokens have been burned and removed from the supply. + /// Implementations also need to set the balance to zero before the end of the function + /// This is to prevent vault owners from spamming fake Burned events. + access(contract) fun burnCallback() { + pre { + emit Burned(type: self.getType().identifier, amount: self.balance, fromUUID: self.uuid) + } + post { + self.balance == 0.0: "The balance must be set to zero during the burnCallback method so that it cannot be spammed" + } + } + + /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts + /// The default implementation is included here because vaults are expected + /// to only accepted their own type, so they have no need to provide an implementation + /// for this function + access(all) view fun getSupportedVaultTypes(): {Type: Bool} { // Below check is implemented to make sure that run-time type would // only get returned when the parent resource conforms with `FungibleToken.Vault`. - if self.getType().isSubtype(of: Type<@FungibleToken.Vault>()) { + if self.getType().isSubtype(of: Type<@{FungibleToken.Vault}>()) { return {self.getType(): true} } else { // Return an empty dictionary as the default value for resource who don't @@ -133,105 +167,61 @@ pub contract interface FungibleToken { return {} } } - } - - /// The interface that contains the `balance` field of the Vault - /// and enforces that when new Vaults are created, the balance - /// is initialized correctly. - /// - pub resource interface Balance { - - /// The total balance of a vault - /// - pub var balance: UFix64 - - init(balance: UFix64) { - post { - self.balance == balance: - "Balance must be initialized to the initial balance" - } - } - - /// Function that returns all the Metadata Views implemented by a Fungible Token - /// - /// @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 [] - } - /// Function that resolves a metadata view for this fungible token by type. - /// - /// @param view: The Type of the desired view. - /// @return A structure representing the requested view. - /// - pub fun resolveView(_ view: Type): AnyStruct? { - return nil + /// Checks if the given type is supported by this Vault + access(all) view fun isSupportedVaultType(type: Type): Bool { + return self.getSupportedVaultTypes()[type] ?? false } - } - - /// The resource that contains the functions to send and receive tokens. - /// The declaration of a concrete type in a contract interface means that - /// every Fungible Token contract that implements the FungibleToken interface - /// must define a concrete `Vault` resource that conforms to the `Provider`, `Receiver`, - /// and `Balance` interfaces, and declares their required fields and functions - /// - pub resource Vault: Provider, Receiver, Balance { - - /// The total balance of the vault - pub var balance: UFix64 - // The conforming type must declare an initializer - // that allows providing the initial balance of the Vault - // - init(balance: UFix64) - - /// Subtracts `amount` from the Vault's balance + /// withdraw subtracts `amount` from the Vault's balance /// and returns a new Vault with the subtracted balance /// - /// @param amount: The amount of tokens to be withdrawn from the vault - /// @return The Vault resource containing the withdrawn funds - /// - pub fun withdraw(amount: UFix64): @Vault { + access(Withdraw) fun withdraw(amount: UFix64): @{Vault} { pre { self.balance >= amount: "Amount withdrawn must be less than or equal than the balance of the Vault" } post { + result.getType() == self.getType(): "Must return the same vault type as self" // use the special function `before` to get the value of the `balance` field // at the beginning of the function execution // self.balance == before(self.balance) - amount: - "New Vault balance must be the difference of the previous balance and the withdrawn Vault" + "New Vault balance must be the difference of the previous balance and the withdrawn Vault balance" } } - /// Takes a Vault and deposits it into the implementing resource type + /// deposit takes a Vault and adds its balance to the balance of this Vault /// - /// @param from: The Vault resource containing the funds that will be deposited - /// - pub fun deposit(from: @Vault) { + access(all) fun deposit(from: @{FungibleToken.Vault}) { // Assert that the concrete type of the deposited vault is the same // as the vault that is accepting the deposit pre { from.isInstance(self.getType()): "Cannot deposit an incompatible token type" + emit Deposited(type: from.getType().identifier, amount: from.balance, to: self.owner?.address, toUUID: self.uuid, depositedUUID: from.uuid) } post { self.balance == before(self.balance) + before(from.balance): "New Vault balance must be the sum of the previous balance and the deposited Vault" } } + + /// createEmptyVault allows any user to create a new Vault that has a zero balance + /// + access(all) fun createEmptyVault(): @{Vault} { + post { + result.balance == 0.0: "The newly created Vault must have zero balance" + } + } } - /// Allows any user to create a new Vault that has a zero balance - /// - /// @return The new Vault resource + /// createEmptyVault allows any user to create a new Vault that has a zero balance /// - pub fun createEmptyVault(): @Vault { + access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} { post { + result.getType() == vaultType: "The returned vault does not match the desired type" result.balance == 0.0: "The newly created Vault must have zero balance" } } -} +} \ No newline at end of file diff --git a/contracts/standards/MetadataViews.cdc b/contracts/standards/MetadataViews.cdc index 59c1927..a35bb6a 100644 --- a/contracts/standards/MetadataViews.cdc +++ b/contracts/standards/MetadataViews.cdc @@ -1,5 +1,6 @@ -import "FungibleToken" -import "NonFungibleToken" +import FungibleToken from "FungibleToken" +import NonFungibleToken from "NonFungibleToken" +import ViewResolver from "ViewResolver" /// This contract implements the metadata standard proposed /// in FLIP-0636. @@ -11,113 +12,38 @@ import "NonFungibleToken" /// a different kind of metadata, such as a creator biography /// or a JPEG image file. /// -pub contract MetadataViews { - - /// Provides access to a set of metadata views. A struct or - /// resource (e.g. an NFT) can implement this interface to provide access to - /// the views that it supports. - /// - pub resource interface Resolver { - pub fun getViews(): [Type] - pub fun resolveView(_ view: Type): AnyStruct? - } - - /// A group of view resolvers indexed by ID. - /// - pub resource interface ResolverCollection { - pub fun borrowViewResolver(id: UInt64): &{Resolver} - pub fun getIDs(): [UInt64] - } - - /// NFTView wraps all Core views along `id` and `uuid` fields, and is used - /// to give a complete picture of an NFT. Most NFTs should implement this - /// view. - /// - pub struct NFTView { - pub let id: UInt64 - pub let uuid: UInt64 - pub let display: Display? - pub let externalURL: ExternalURL? - pub let collectionData: NFTCollectionData? - pub let collectionDisplay: NFTCollectionDisplay? - pub let royalties: Royalties? - pub let traits: Traits? - - init( - id : UInt64, - uuid : UInt64, - display : Display?, - externalURL : ExternalURL?, - collectionData : NFTCollectionData?, - collectionDisplay : NFTCollectionDisplay?, - royalties : Royalties?, - traits: Traits? - ) { - self.id = id - self.uuid = uuid - self.display = display - self.externalURL = externalURL - self.collectionData = collectionData - self.collectionDisplay = collectionDisplay - self.royalties = royalties - self.traits = traits - } - } - - /// Helper to get an NFT view - /// - /// @param id: The NFT id - /// @param viewResolver: A reference to the resolver resource - /// @return A NFTView struct - /// - pub fun getNFTView(id: UInt64, viewResolver: &{Resolver}) : NFTView { - let nftView = viewResolver.resolveView(Type()) - if nftView != nil { - return nftView! as! NFTView - } - - return NFTView( - id : id, - uuid: viewResolver.uuid, - display: self.getDisplay(viewResolver), - externalURL : self.getExternalURL(viewResolver), - collectionData : self.getNFTCollectionData(viewResolver), - collectionDisplay : self.getNFTCollectionDisplay(viewResolver), - royalties : self.getRoyalties(viewResolver), - traits : self.getTraits(viewResolver) - ) - } +access(all) contract MetadataViews { /// Display is a basic view that includes the name, description and /// thumbnail for an object. Most objects should implement this view. /// - pub struct Display { + access(all) struct Display { /// The name of the object. /// /// This field will be displayed in lists and therefore should /// be short an concise. /// - pub let name: String + access(all) let name: String /// A written description of the object. /// /// This field will be displayed in a detailed view of the object, /// so can be more verbose (e.g. a paragraph instead of a single line). /// - pub let description: String + access(all) let description: String /// A small thumbnail representation of the object. /// /// This field should be a web-friendly file (i.e JPEG, PNG) /// that can be displayed in lists, link previews, etc. /// - pub let thumbnail: AnyStruct{File} + access(all) let thumbnail: {File} - init( + view init( name: String, description: String, - thumbnail: AnyStruct{File} + thumbnail: {File} ) { self.name = name self.description = description @@ -130,7 +56,7 @@ pub contract MetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return An optional Display struct /// - pub fun getDisplay(_ viewResolver: &{Resolver}) : Display? { + access(all) fun getDisplay(_ viewResolver: &{ViewResolver.Resolver}) : Display? { if let view = viewResolver.resolveView(Type()) { if let v = view as? Display { return v @@ -142,20 +68,20 @@ pub contract MetadataViews { /// Generic interface that represents a file stored on or off chain. Files /// can be used to references images, videos and other media. /// - pub struct interface File { - pub fun uri(): String + access(all) struct interface File { + access(all) view fun uri(): String } /// View to expose a file that is accessible at an HTTP (or HTTPS) URL. /// - pub struct HTTPFile: File { - pub let url: String + access(all) struct HTTPFile: File { + access(all) let url: String - init(url: String) { + view init(url: String) { self.url = url } - pub fun uri(): String { + access(all) view fun uri(): String { return self.url } } @@ -165,13 +91,13 @@ pub contract MetadataViews { /// rather than a direct URI. A client application can use this CID /// to find and load the image via an IPFS gateway. /// - pub struct IPFSFile: File { + access(all) struct IPFSFile: File { /// CID is the content identifier for this IPFS file. /// /// Ref: https://docs.ipfs.io/concepts/content-addressing/ /// - pub let cid: String + access(all) let cid: String /// Path is an optional path to the file resource in an IPFS directory. /// @@ -179,9 +105,9 @@ pub contract MetadataViews { /// /// Ref: https://docs.ipfs.io/concepts/file-systems/ /// - pub let path: String? + access(all) let path: String? - init(cid: String, path: String?) { + view init(cid: String, path: String?) { self.cid = cid self.path = path } @@ -191,7 +117,7 @@ pub contract MetadataViews { /// /// @return The string containing the file uri /// - pub fun uri(): String { + access(all) view fun uri(): String { if let path = self.path { return "ipfs://".concat(self.cid).concat("/").concat(path) } @@ -200,125 +126,133 @@ pub contract MetadataViews { } } - /// Optional view for collections that issue multiple objects - /// with the same or similar metadata, for example an X of 100 set. This - /// information is useful for wallets and marketplaces. - /// An NFT might be part of multiple editions, which is why the edition - /// information is returned as an arbitrary sized array + /// View to represent a file with an correspoiding mediaType. /// - pub struct Edition { - - /// The name of the edition - /// For example, this could be Set, Play, Series, - /// or any other way a project could classify its editions - pub let name: String? + access(all) struct Media { - /// The edition number of the object. - /// For an "24 of 100 (#24/100)" item, the number is 24. - pub let number: UInt64 + /// File for the media + /// + access(all) let file: {File} - /// The max edition number of this type of objects. - /// This field should only be provided for limited-editioned objects. - /// For an "24 of 100 (#24/100)" item, max is 100. - /// For an item with unlimited edition, max should be set to nil. + /// media-type comes on the form of type/subtype as described here + /// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types /// - pub let max: UInt64? + access(all) let mediaType: String - init(name: String?, number: UInt64, max: UInt64?) { - if max != nil { - assert(number <= max!, message: "The number cannot be greater than the max number!") - } - self.name = name - self.number = number - self.max = max + view init(file: {File}, mediaType: String) { + self.file=file + self.mediaType=mediaType } } - /// Wrapper view for multiple Edition views + /// Wrapper view for multiple media views /// - pub struct Editions { + access(all) struct Medias { - /// An arbitrary-sized list for any number of editions - /// that the NFT might be a part of - pub let infoList: [Edition] + /// An arbitrary-sized list for any number of Media items + access(all) let items: [Media] - init(_ infoList: [Edition]) { - self.infoList = infoList + view init(_ items: [Media]) { + self.items = items } } - /// Helper to get Editions in a typesafe way + /// Helper to get Medias in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return An optional Editions struct + /// @return A optional Medias struct /// - pub fun getEditions(_ viewResolver: &{Resolver}) : Editions? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Editions { + access(all) fun getMedias(_ viewResolver: &{ViewResolver.Resolver}) : Medias? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Medias { return v } } return nil } - /// View representing a project-defined serial number for a specific NFT - /// Projects have different definitions for what a serial number should be - /// Some may use the NFTs regular ID and some may use a different - /// classification system. The serial number is expected to be unique among - /// other NFTs within that project + /// View to represent a license according to https://spdx.org/licenses/ + /// This view can be used if the content of an NFT is licensed. /// - pub struct Serial { - pub let number: UInt64 + access(all) struct License { + access(all) let spdxIdentifier: String - init(_ number: UInt64) { - self.number = number + view init(_ identifier: String) { + self.spdxIdentifier = identifier } } - /// Helper to get Serial in a typesafe way + /// Helper to get License in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return An optional Serial struct + /// @return A optional License struct /// - pub fun getSerial(_ viewResolver: &{Resolver}) : Serial? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Serial { + access(all) fun getLicense(_ viewResolver: &{ViewResolver.Resolver}) : License? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? License { return v } } return nil } - /// View that defines the composable royalty standard that gives marketplaces a + /// View to expose a URL to this item on an external site. + /// This can be used by applications like .find and Blocto to direct users + /// to the original link for an NFT or a project page that describes the NFT collection. + /// eg https://www.my-nft-project.com/overview-of-nft-collection + /// + access(all) struct ExternalURL { + access(all) let url: String + + view init(_ url: String) { + self.url=url + } + } + + /// Helper to get ExternalURL in a typesafe way + /// + /// @param viewResolver: A reference to the resolver resource + /// @return A optional ExternalURL struct + /// + access(all) fun getExternalURL(_ viewResolver: &{ViewResolver.Resolver}) : ExternalURL? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? ExternalURL { + return v + } + } + return nil + } + + /// View that defines the composable royalty standard that gives marketplaces a /// unified interface to support NFT royalties. /// - pub struct Royalty { + access(all) struct Royalty { /// Generic FungibleToken Receiver for the beneficiary of the royalty /// Can get the concrete type of the receiver with receiver.getType() - /// Recommendation - Users should create a new link for a FlowToken - /// receiver for this using `getRoyaltyReceiverPublicPath()`, and not - /// use the default FlowToken receiver. This will allow users to update + /// Recommendation - Users should create a new link for a FlowToken + /// receiver for this using `getRoyaltyReceiverPublicPath()`, and not + /// use the default FlowToken receiver. This will allow users to update /// the capability in the future to use a more generic capability - pub let receiver: Capability<&AnyResource{FungibleToken.Receiver}> + access(all) let receiver: Capability<&{FungibleToken.Receiver}> - /// Multiplier used to calculate the amount of sale value transferred to - /// royalty receiver. Note - It should be between 0.0 and 1.0 - /// Ex - If the sale value is x and multiplier is 0.56 then the royalty + /// Multiplier used to calculate the amount of sale value transferred to + /// royalty receiver. Note - It should be between 0.0 and 1.0 + /// Ex - If the sale value is x and multiplier is 0.56 then the royalty /// value would be 0.56 * x. /// Generally percentage get represented in terms of basis points - /// in solidity based smart contracts while cadence offers `UFix64` - /// that already supports the basis points use case because its - /// operations are entirely deterministic integer operations and support + /// in solidity based smart contracts while cadence offers `UFix64` + /// that already supports the basis points use case because its + /// operations are entirely deterministic integer operations and support /// up to 8 points of precision. - pub let cut: UFix64 + access(all) let cut: UFix64 /// Optional description: This can be the cause of paying the royalty, /// the relationship between the `wallet` and the NFT, or anything else /// that the owner might want to specify. - pub let description: String + access(all) let description: String - init(receiver: Capability<&AnyResource{FungibleToken.Receiver}>, cut: UFix64, description: String) { + view init(receiver: Capability<&{FungibleToken.Receiver}>, cut: UFix64, description: String) { pre { cut >= 0.0 && cut <= 1.0 : "Cut value should be in valid range i.e [0,1]" } @@ -329,15 +263,15 @@ pub contract MetadataViews { } /// Wrapper view for multiple Royalty views. - /// Marketplaces can query this `Royalties` struct from NFTs + /// Marketplaces can query this `Royalties` struct from NFTs /// and are expected to pay royalties based on these specifications. /// - pub struct Royalties { + access(all) struct Royalties { /// Array that tracks the individual royalties access(self) let cutInfos: [Royalty] - pub init(_ cutInfos: [Royalty]) { + access(all) view init(_ cutInfos: [Royalty]) { // Validate that sum of all cut multipliers should not be greater than 1.0 var totalCut = 0.0 for royalty in cutInfos { @@ -352,7 +286,7 @@ pub contract MetadataViews { /// /// @return An array containing all the royalties structs /// - pub fun getRoyalties(): [Royalty] { + access(all) view fun getRoyalties(): [Royalty] { return self.cutInfos } } @@ -362,7 +296,7 @@ pub contract MetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return A optional Royalties struct /// - pub fun getRoyalties(_ viewResolver: &{Resolver}) : Royalties? { + access(all) fun getRoyalties(_ viewResolver: &{ViewResolver.Resolver}) : Royalties? { if let view = viewResolver.resolveView(Type()) { if let v = view as? Royalties { return v @@ -377,162 +311,325 @@ pub contract MetadataViews { /// /// @return The PublicPath for the generic FT receiver /// - pub fun getRoyaltyReceiverPublicPath(): PublicPath { + access(all) view fun getRoyaltyReceiverPublicPath(): PublicPath { return /public/GenericFTReceiver } - /// View to represent, a file with an correspoiding mediaType. + /// View to represent a single field of metadata on an NFT. + /// This is used to get traits of individual key/value pairs along with some + /// contextualized data about the trait /// - pub struct Media { + access(all) struct Trait { + // The name of the trait. Like Background, Eyes, Hair, etc. + access(all) let name: String - /// File for the media + // The underlying value of the trait, the rest of the fields of a trait provide context to the value. + access(all) let value: AnyStruct + + // displayType is used to show some context about what this name and value represent + // for instance, you could set value to a unix timestamp, and specify displayType as "Date" to tell + // platforms to consume this trait as a date and not a number + access(all) let displayType: String? + + // Rarity can also be used directly on an attribute. + // + // This is optional because not all attributes need to contribute to the NFT's rarity. + access(all) let rarity: Rarity? + + view init(name: String, value: AnyStruct, displayType: String?, rarity: Rarity?) { + self.name = name + self.value = value + self.displayType = displayType + self.rarity = rarity + } + } + + /// Wrapper view to return all the traits on an NFT. + /// This is used to return traits as individual key/value pairs along with + /// some contextualized data about each trait. + access(all) struct Traits { + access(all) let traits: [Trait] + + view init(_ traits: [Trait]) { + self.traits = traits + } + + /// Adds a single Trait to the Traits view + /// + /// @param Trait: The trait struct to be added /// - pub let file: AnyStruct{File} + access(all) fun addTrait(_ t: Trait) { + self.traits.append(t) + } + } - /// media-type comes on the form of type/subtype as described here - /// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types + /// Helper to get Traits view in a typesafe way + /// + /// @param viewResolver: A reference to the resolver resource + /// @return A optional Traits struct + /// + access(all) fun getTraits(_ viewResolver: &{ViewResolver.Resolver}) : Traits? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Traits { + return v + } + } + return nil + } + + /// Helper function to easily convert a dictionary to traits. For NFT + /// collections that do not need either of the optional values of a Trait, + /// this method should suffice to give them an array of valid traits. + /// + /// @param dict: The dictionary to be converted to Traits + /// @param excludedNames: An optional String array specifying the `dict` + /// keys that are not wanted to become `Traits` + /// @return The generated Traits view + /// + access(all) fun dictToTraits(dict: {String: AnyStruct}, excludedNames: [String]?): Traits { + // Collection owners might not want all the fields in their metadata included. + // They might want to handle some specially, or they might just not want them included at all. + if excludedNames != nil { + for k in excludedNames! { + dict.remove(key: k) + } + } + + let traits: [Trait] = [] + for k in dict.keys { + let trait = Trait(name: k, value: dict[k]!, displayType: nil, rarity: nil) + traits.append(trait) + } + + return Traits(traits) + } + + /// Optional view for collections that issue multiple objects + /// with the same or similar metadata, for example an X of 100 set. This + /// information is useful for wallets and marketplaces. + /// An NFT might be part of multiple editions, which is why the edition + /// information is returned as an arbitrary sized array + /// + access(all) struct Edition { + + /// The name of the edition + /// For example, this could be Set, Play, Series, + /// or any other way a project could classify its editions + access(all) let name: String? + + /// The edition number of the object. + /// For an "24 of 100 (#24/100)" item, the number is 24. + access(all) let number: UInt64 + + /// The max edition number of this type of objects. + /// This field should only be provided for limited-editioned objects. + /// For an "24 of 100 (#24/100)" item, max is 100. + /// For an item with unlimited edition, max should be set to nil. /// - pub let mediaType: String + access(all) let max: UInt64? - init(file: AnyStruct{File}, mediaType: String) { - self.file=file - self.mediaType=mediaType + view init(name: String?, number: UInt64, max: UInt64?) { + if max != nil { + assert(number <= max!, message: "The number cannot be greater than the max number!") + } + self.name = name + self.number = number + self.max = max } } - /// Wrapper view for multiple media views + /// Wrapper view for multiple Edition views /// - pub struct Medias { + access(all) struct Editions { - /// An arbitrary-sized list for any number of Media items - pub let items: [Media] + /// An arbitrary-sized list for any number of editions + /// that the NFT might be a part of + access(all) let infoList: [Edition] - init(_ items: [Media]) { - self.items = items + view init(_ infoList: [Edition]) { + self.infoList = infoList } } - /// Helper to get Medias in a typesafe way + /// Helper to get Editions in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return A optional Medias struct + /// @return An optional Editions struct /// - pub fun getMedias(_ viewResolver: &{Resolver}) : Medias? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Medias { + access(all) fun getEditions(_ viewResolver: &{ViewResolver.Resolver}) : Editions? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Editions { return v } } return nil } - /// View to represent a license according to https://spdx.org/licenses/ - /// This view can be used if the content of an NFT is licensed. + /// View representing a project-defined serial number for a specific NFT + /// Projects have different definitions for what a serial number should be + /// Some may use the NFTs regular ID and some may use a different + /// classification system. The serial number is expected to be unique among + /// other NFTs within that project /// - pub struct License { - pub let spdxIdentifier: String + access(all) struct Serial { + access(all) let number: UInt64 - init(_ identifier: String) { - self.spdxIdentifier = identifier + view init(_ number: UInt64) { + self.number = number } } - /// Helper to get License in a typesafe way + /// Helper to get Serial in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return A optional License struct + /// @return An optional Serial struct /// - pub fun getLicense(_ viewResolver: &{Resolver}) : License? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? License { + access(all) fun getSerial(_ viewResolver: &{ViewResolver.Resolver}) : Serial? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Serial { return v } } return nil } - /// View to expose a URL to this item on an external site. - /// This can be used by applications like .find and Blocto to direct users - /// to the original link for an NFT or a project page that describes the NFT collection. - /// eg https://www.my-nft-project.com/overview-of-nft-collection + /// View to expose rarity information for a single rarity + /// Note that a rarity needs to have either score or description but it can + /// have both /// - pub struct ExternalURL { - pub let url: String + access(all) struct Rarity { + /// The score of the rarity as a number + access(all) let score: UFix64? - init(_ url: String) { - self.url=url + /// The maximum value of score + access(all) let max: UFix64? + + /// The description of the rarity as a string. + /// + /// This could be Legendary, Epic, Rare, Uncommon, Common or any other string value + access(all) let description: String? + + view init(score: UFix64?, max: UFix64?, description: String?) { + if score == nil && description == nil { + panic("A Rarity needs to set score, description or both") + } + + self.score = score + self.max = max + self.description = description } } - /// Helper to get ExternalURL in a typesafe way + /// Helper to get Rarity view in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return A optional ExternalURL struct + /// @return A optional Rarity struct /// - pub fun getExternalURL(_ viewResolver: &{Resolver}) : ExternalURL? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? ExternalURL { + access(all) fun getRarity(_ viewResolver: &{ViewResolver.Resolver}) : Rarity? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Rarity { return v } } return nil } + /// NFTView wraps all Core views along `id` and `uuid` fields, and is used + /// to give a complete picture of an NFT. Most NFTs should implement this + /// view. + /// + access(all) struct NFTView { + access(all) let id: UInt64 + access(all) let uuid: UInt64 + access(all) let display: MetadataViews.Display? + access(all) let externalURL: MetadataViews.ExternalURL? + access(all) let collectionData: NFTCollectionData? + access(all) let collectionDisplay: NFTCollectionDisplay? + access(all) let royalties: Royalties? + access(all) let traits: Traits? + + view init( + id : UInt64, + uuid : UInt64, + display : MetadataViews.Display?, + externalURL : MetadataViews.ExternalURL?, + collectionData : NFTCollectionData?, + collectionDisplay : NFTCollectionDisplay?, + royalties : Royalties?, + traits: Traits? + ) { + self.id = id + self.uuid = uuid + self.display = display + self.externalURL = externalURL + self.collectionData = collectionData + self.collectionDisplay = collectionDisplay + self.royalties = royalties + self.traits = traits + } + } + + /// Helper to get an NFT view + /// + /// @param id: The NFT id + /// @param viewResolver: A reference to the resolver resource + /// @return A NFTView struct + /// + access(all) fun getNFTView(id: UInt64, viewResolver: &{ViewResolver.Resolver}) : NFTView { + let nftView = viewResolver.resolveView(Type()) + if nftView != nil { + return nftView! as! NFTView + } + + return NFTView( + id : id, + uuid: viewResolver.uuid, + display: MetadataViews.getDisplay(viewResolver), + externalURL : MetadataViews.getExternalURL(viewResolver), + collectionData : self.getNFTCollectionData(viewResolver), + collectionDisplay : self.getNFTCollectionDisplay(viewResolver), + royalties : self.getRoyalties(viewResolver), + traits : self.getTraits(viewResolver) + ) + } + /// View to expose the information needed store and retrieve an NFT. - /// This can be used by applications to setup a NFT collection with proper + /// This can be used by applications to setup a NFT collection with proper /// storage and public capabilities. /// - pub struct NFTCollectionData { + access(all) struct NFTCollectionData { /// Path in storage where this NFT is recommended to be stored. - pub let storagePath: StoragePath + access(all) let storagePath: StoragePath /// Public path which must be linked to expose public capabilities of this NFT /// including standard NFT interfaces and metadataviews interfaces - pub let publicPath: PublicPath - - /// Private path which should be linked to expose the provider - /// capability to withdraw NFTs from the collection holding NFTs - pub let providerPath: PrivatePath + access(all) let publicPath: PublicPath - /// Public collection type that is expected to provide sufficient read-only access to standard - /// functions (deposit + getIDs + borrowNFT) - /// This field is for backwards compatibility with collections that have not used the standard - /// NonFungibleToken.CollectionPublic interface when setting up collections. For new - /// collections, this may be set to be equal to the type specified in `publicLinkedType`. - pub let publicCollection: Type + /// The concrete type of the collection that is exposed to the public + /// now that entitlements exist, it no longer needs to be restricted to a specific interface + access(all) let publicCollection: Type - /// Type that should be linked at the aforementioned public path. This is normally a - /// restricted type with many interfaces. Notably the `NFT.CollectionPublic`, - /// `NFT.Receiver`, and `MetadataViews.ResolverCollection` interfaces are required. - pub let publicLinkedType: Type - - /// Type that should be linked at the aforementioned private path. This is normally - /// a restricted type with at a minimum the `NFT.Provider` interface - pub let providerLinkedType: Type + /// Type that should be linked at the aforementioned public path + access(all) let publicLinkedType: Type /// Function that allows creation of an empty NFT collection that is intended to store /// this NFT. - pub let createEmptyCollection: ((): @NonFungibleToken.Collection) + access(all) let createEmptyCollection: fun(): @{NonFungibleToken.Collection} - init( + view init( storagePath: StoragePath, publicPath: PublicPath, - providerPath: PrivatePath, publicCollection: Type, publicLinkedType: Type, - providerLinkedType: Type, - createEmptyCollectionFunction: ((): @NonFungibleToken.Collection) + createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection} ) { pre { - publicLinkedType.isSubtype(of: Type<&{NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, MetadataViews.ResolverCollection}>()): "Public type must include NonFungibleToken.CollectionPublic, NonFungibleToken.Receiver, and MetadataViews.ResolverCollection interfaces." - providerLinkedType.isSubtype(of: Type<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, MetadataViews.ResolverCollection}>()): "Provider type must include NonFungibleToken.Provider, NonFungibleToken.CollectionPublic, and MetadataViews.ResolverCollection interface." + publicLinkedType.isSubtype(of: Type<&{NonFungibleToken.Collection}>()): "Public type must be a subtype of NonFungibleToken.Collection interface." } self.storagePath=storagePath self.publicPath=publicPath - self.providerPath = providerPath self.publicCollection=publicCollection self.publicLinkedType=publicLinkedType - self.providerLinkedType = providerLinkedType self.createEmptyCollection=createEmptyCollectionFunction } } @@ -542,7 +639,7 @@ pub contract MetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return A optional NFTCollectionData struct /// - pub fun getNFTCollectionData(_ viewResolver: &{Resolver}) : NFTCollectionData? { + access(all) fun getNFTCollectionData(_ viewResolver: &{ViewResolver.Resolver}) : NFTCollectionData? { if let view = viewResolver.resolveView(Type()) { if let v = view as? NFTCollectionData { return v @@ -552,36 +649,36 @@ pub contract MetadataViews { } /// View to expose the information needed to showcase this NFT's - /// collection. This can be used by applications to give an overview and + /// collection. This can be used by applications to give an overview and /// graphics of the NFT collection this NFT belongs to. /// - pub struct NFTCollectionDisplay { + access(all) struct NFTCollectionDisplay { // Name that should be used when displaying this NFT collection. - pub let name: String + access(all) let name: String // Description that should be used to give an overview of this collection. - pub let description: String + access(all) let description: String // External link to a URL to view more information about this collection. - pub let externalURL: ExternalURL + access(all) let externalURL: MetadataViews.ExternalURL // Square-sized image to represent this collection. - pub let squareImage: Media + access(all) let squareImage: MetadataViews.Media // Banner-sized image for this collection, recommended to have a size near 1200x630. - pub let bannerImage: Media + access(all) let bannerImage: MetadataViews.Media // Social links to reach this collection's social homepages. // Possible keys may be "instagram", "twitter", "discord", etc. - pub let socials: {String: ExternalURL} + access(all) let socials: {String: MetadataViews.ExternalURL} - init( + view init( name: String, description: String, - externalURL: ExternalURL, - squareImage: Media, - bannerImage: Media, - socials: {String: ExternalURL} + externalURL: MetadataViews.ExternalURL, + squareImage: MetadataViews.Media, + bannerImage: MetadataViews.Media, + socials: {String: MetadataViews.ExternalURL} ) { self.name = name self.description = description @@ -592,13 +689,13 @@ pub contract MetadataViews { } } - /// Helper to get NFTCollectionDisplay in a way that will return a typed + /// Helper to get NFTCollectionDisplay in a way that will return a typed /// Optional /// /// @param viewResolver: A reference to the resolver resource /// @return A optional NFTCollection struct /// - pub fun getNFTCollectionDisplay(_ viewResolver: &{Resolver}) : NFTCollectionDisplay? { + access(all) fun getNFTCollectionDisplay(_ viewResolver: &{ViewResolver.Resolver}) : NFTCollectionDisplay? { if let view = viewResolver.resolveView(Type()) { if let v = view as? NFTCollectionDisplay { return v @@ -607,134 +704,43 @@ pub contract MetadataViews { return nil } - /// View to expose rarity information for a single rarity - /// Note that a rarity needs to have either score or description but it can - /// have both + /// A struct to represent a general case URI, used to represent the URI of the NFT where the type of URI is not + /// able to be determined (i.e. HTTP, IPFS, etc.) /// - pub struct Rarity { - /// The score of the rarity as a number - pub let score: UFix64? + access(all) struct URI : File { + /// The base URI prefix, if any. Not needed for all URIs, but helpful for some use cases + /// For example, updating a whole NFT collection's image host easily + access(all) let baseURI: String? + /// The URI value + /// NOTE: this is set on init as a concatenation of the baseURI and the value if baseURI != nil + access(self) let value: String - /// The maximum value of score - pub let max: UFix64? - - /// The description of the rarity as a string. - /// - /// This could be Legendary, Epic, Rare, Uncommon, Common or any other string value - pub let description: String? - - init(score: UFix64?, max: UFix64?, description: String?) { - if score == nil && description == nil { - panic("A Rarity needs to set score, description or both") - } - - self.score = score - self.max = max - self.description = description + access(all) view fun uri(): String { + return self.value } - } - /// Helper to get Rarity view in a typesafe way - /// - /// @param viewResolver: A reference to the resolver resource - /// @return A optional Rarity struct - /// - pub fun getRarity(_ viewResolver: &{Resolver}) : Rarity? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Rarity { - return v - } + init(baseURI: String?, value: String) { + self.baseURI = baseURI + self.value = baseURI != nil ? baseURI!.concat(value) : value } - return nil } - /// View to represent a single field of metadata on an NFT. - /// This is used to get traits of individual key/value pairs along with some - /// contextualized data about the trait + /// Proof of concept metadata to represent the ERC721 values of the NFT /// - pub struct Trait { - // The name of the trait. Like Background, Eyes, Hair, etc. - pub let name: String - - // The underlying value of the trait, the rest of the fields of a trait provide context to the value. - pub let value: AnyStruct + access(all) struct EVMBridgedMetadata { + /// The name of the NFT + access(all) let name: String + /// The symbol of the NFT + access(all) let symbol: String + /// The URI of the asset - this can either be contract-level or token-level URI depending on where the metadata + /// is requested. See the ViewResolver contract interface to discover how contract & resource-level metadata + /// requests are handled. + access(all) let uri: {MetadataViews.File} - // displayType is used to show some context about what this name and value represent - // for instance, you could set value to a unix timestamp, and specify displayType as "Date" to tell - // platforms to consume this trait as a date and not a number - pub let displayType: String? - - // Rarity can also be used directly on an attribute. - // - // This is optional because not all attributes need to contribute to the NFT's rarity. - pub let rarity: Rarity? - - init(name: String, value: AnyStruct, displayType: String?, rarity: Rarity?) { + init(name: String, symbol: String, uri: {MetadataViews.File}) { self.name = name - self.value = value - self.displayType = displayType - self.rarity = rarity + self.symbol = symbol + self.uri = uri } } - - /// Wrapper view to return all the traits on an NFT. - /// This is used to return traits as individual key/value pairs along with - /// some contextualized data about each trait. - pub struct Traits { - pub let traits: [Trait] - - init(_ traits: [Trait]) { - self.traits = traits - } - - /// Adds a single Trait to the Traits view - /// - /// @param Trait: The trait struct to be added - /// - pub fun addTrait(_ t: Trait) { - self.traits.append(t) - } - } - - /// Helper to get Traits view in a typesafe way - /// - /// @param viewResolver: A reference to the resolver resource - /// @return A optional Traits struct - /// - pub fun getTraits(_ viewResolver: &{Resolver}) : Traits? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Traits { - return v - } - } - return nil - } - - /// Helper function to easily convert a dictionary to traits. For NFT - /// collections that do not need either of the optional values of a Trait, - /// this method should suffice to give them an array of valid traits. - /// - /// @param dict: The dictionary to be converted to Traits - /// @param excludedNames: An optional String array specifying the `dict` - /// keys that are not wanted to become `Traits` - /// @return The generated Traits view - /// - pub fun dictToTraits(dict: {String: AnyStruct}, excludedNames: [String]?): Traits { - // Collection owners might not want all the fields in their metadata included. - // They might want to handle some specially, or they might just not want them included at all. - if excludedNames != nil { - for k in excludedNames! { - dict.remove(key: k) - } - } - - let traits: [Trait] = [] - for k in dict.keys { - let trait = Trait(name: k, value: dict[k]!, displayType: nil, rarity: nil) - traits.append(trait) - } - - return Traits(traits) - } - } diff --git a/contracts/standards/NonFungibleToken.cdc b/contracts/standards/NonFungibleToken.cdc index 5ebd8fc..efce109 100644 --- a/contracts/standards/NonFungibleToken.cdc +++ b/contracts/standards/NonFungibleToken.cdc @@ -2,20 +2,17 @@ ## The Flow Non-Fungible Token standard -## `NonFungibleToken` contract interface +## `NonFungibleToken` contract -The interface that all Non-Fungible Token contracts could conform to. -If a user wants to deploy a new NFT contract, their contract would need -to implement the NonFungibleToken interface. +The interface that all Non-Fungible Token contracts should conform to. +If a user wants to deploy a new NFT contract, their contract should implement +The types defined here -Their contract would have to follow all the rules and naming -that the interface specifies. - -## `NFT` resource +## `NFT` resource interface The core resource type that represents an NFT in the smart contract. -## `Collection` Resource +## `Collection` Resource interface The resource that stores a user's NFT collection. It includes a few functions to allow the owner to easily @@ -26,10 +23,8 @@ move tokens in and out of the collection. These interfaces declare functions with some pre and post conditions that require the Collection to follow certain naming and behavior standards. -They are separate because it gives the user the ability to share a reference -to their Collection that only exposes the fields and functions in one or more -of the interfaces. It also gives users the ability to make custom resources -that implement these interfaces to do various things with the tokens. +They are separate because it gives developers the ability to define functions +that can use any type that implements these interfaces By using resources and interfaces, users of NFT smart contracts can send and receive tokens peer-to-peer, without having to interact with a central ledger @@ -41,162 +36,206 @@ Collection to complete the transfer. */ -/// The main NFT contract interface. Other NFT contracts will -/// import and implement this interface +import "ViewResolver" + +/// The main NFT contract. Other NFT contracts will +/// import and implement the interfaces defined in this contract /// -pub contract interface NonFungibleToken { +access(all) contract interface NonFungibleToken: ViewResolver { - /// The total number of tokens of this type in existence - pub var totalSupply: UInt64 + /// An entitlement for allowing the withdrawal of tokens from a Vault + access(all) entitlement Withdraw - /// Event that emitted when the NFT contract is initialized + /// An entitlement for allowing updates and update events for an NFT + access(all) entitlement Update + + /// Event that contracts should emit when the metadata of an NFT is updated + /// It can only be emitted by calling the `emitNFTUpdated` function + /// with an `Updatable` entitled reference to the NFT that was updated + /// The entitlement prevents spammers from calling this from other users' collections + /// because only code within a collection or that has special entitled access + /// to the collections methods will be able to get the entitled reference + /// + /// The event makes it so that third-party indexers can monitor the events + /// and query the updated metadata from the owners' collections. /// - pub event ContractInitialized() + access(all) event Updated(type: String, id: UInt64, uuid: UInt64, owner: Address?) + access(all) view fun emitNFTUpdated(_ nftRef: auth(Update) &{NonFungibleToken.NFT}) + { + emit Updated(type: nftRef.getType().identifier, id: nftRef.id, uuid: nftRef.uuid, owner: nftRef.owner?.address) + } + /// Event that is emitted when a token is withdrawn, - /// indicating the owner of the collection that it was withdrawn from. + /// indicating the type, id, uuid, the owner of the collection that it was withdrawn from, + /// and the UUID of the resource it was withdrawn from, usually a collection. /// /// If the collection is not in an account's storage, `from` will be `nil`. /// - pub event Withdraw(id: UInt64, from: Address?) + access(all) event Withdrawn(type: String, id: UInt64, uuid: UInt64, from: Address?, providerUUID: UInt64) /// Event that emitted when a token is deposited to a collection. + /// Indicates the type, id, uuid, the owner of the collection that it was deposited to, + /// and the UUID of the collection it was deposited to /// - /// It indicates the owner of the collection that it was deposited to. + /// If the collection is not in an account's storage, `from`, will be `nil`. /// - pub event Deposit(id: UInt64, to: Address?) + access(all) event Deposited(type: String, id: UInt64, uuid: UInt64, to: Address?, collectionUUID: UInt64) - /// Interface that the NFTs have to conform to - /// The metadata views methods are included here temporarily - /// because enforcing the metadata interfaces in the standard - /// would break many contracts in an upgrade. Those breaking changes - /// are being saved for the stable cadence milestone + /// Interface that the NFTs must conform to /// - pub resource interface INFT { - /// The unique ID that each NFT has - pub let id: UInt64 + access(all) resource interface NFT: ViewResolver.Resolver { - /// Function that returns all the Metadata Views implemented by a Non Fungible Token - /// - /// @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 [] + /// unique ID for the NFT + access(all) let id: UInt64 + + /// Event that is emitted automatically every time a resource is destroyed + /// The type information is included in the metadata event so it is not needed as an argument + access(all) event ResourceDestroyed(id: UInt64 = self.id, uuid: UInt64 = self.uuid) + + /// createEmptyCollection creates an empty Collection that is able to store the NFT + /// and returns it to the caller so that they can own NFTs + /// @return A an empty collection that can store this NFT + access(all) fun createEmptyCollection(): @{Collection} { + post { + result.getLength() == 0: "The created collection must be empty!" + result.isSupportedNFTType(type: self.getType()): "The created collection must support this NFT type" + } } - /// Function that resolves a metadata view for this token. + /// Gets all the NFTs that this NFT directly owns + /// @return A dictionary of all subNFTS keyed by type + access(all) view fun getAvailableSubNFTS(): {Type: UInt64} { + return {} + } + + /// Get a reference to an NFT that this NFT owns + /// Both arguments are optional to allow the NFT to choose + /// how it returns sub NFTs depending on what arguments are provided + /// For example, if `type` has a value, but `id` doesn't, the NFT + /// can choose which NFT of that type to return if there is a "default" + /// If both are `nil`, then NFTs that only store a single NFT can just return + /// that. This helps callers who aren't sure what they are looking for /// - /// @param view: The Type of the desired view. - /// @return A structure representing the requested view. + /// @param type: The Type of the desired NFT + /// @param id: The id of the NFT to borrow /// - pub fun resolveView(_ view: Type): AnyStruct? { + /// @return A structure representing the requested view. + access(all) fun getSubNFT(type: Type, id: UInt64) : &{NonFungibleToken.NFT}? { return nil } } - /// Requirement that all conforming NFT smart contracts have - /// to define a resource called NFT that conforms to INFT + /// Interface to mediate withdrawals from a resource, usually a Collection /// - pub resource NFT: INFT { - pub let id: UInt64 - } + access(all) resource interface Provider { - /// Interface to mediate withdraws from the Collection - /// - pub resource interface Provider { - /// Removes an NFT from the resource implementing it and moves it to the caller - /// - /// @param withdrawID: The ID of the NFT that will be removed - /// @return The NFT resource removed from the implementing resource - /// - pub fun withdraw(withdrawID: UInt64): @NFT { + // We emit withdraw events from the provider interface because conficting withdraw + // events aren't as confusing to event listeners as conflicting deposit events + + /// withdraw removes an NFT from the collection and moves it to the caller + /// It does not specify whether the ID is UUID or not + /// @param withdrawID: The id of the NFT to withdraw from the collection + access(Withdraw) fun withdraw(withdrawID: UInt64): @{NFT} { post { result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID" + emit Withdrawn(type: result.getType().identifier, id: result.id, uuid: result.uuid, from: self.owner?.address, providerUUID: self.uuid) } } } /// Interface to mediate deposits to the Collection /// - pub resource interface Receiver { - - /// Adds an NFT to the resource implementing it - /// - /// @param token: The NFT resource that will be deposited - /// - pub fun deposit(token: @NFT) + access(all) resource interface Receiver { + + /// deposit takes an NFT as an argument and adds it to the Collection + /// @param token: The NFT to deposit + access(all) fun deposit(token: @{NFT}) + + /// getSupportedNFTTypes returns a list of NFT types that this receiver accepts + /// @return A dictionary of types mapped to booleans indicating if this + /// reciever supports it + access(all) view fun getSupportedNFTTypes(): {Type: Bool} + + /// Returns whether or not the given type is accepted by the collection + /// A collection that can accept any type should just return true by default + /// @param type: An NFT type + /// @return A boolean indicating if this receiver can recieve the desired NFT type + access(all) view fun isSupportedNFTType(type: Type): Bool } - /// Interface that an account would commonly - /// publish for their collection - /// - pub resource interface CollectionPublic { - pub fun deposit(token: @NFT) - pub fun getIDs(): [UInt64] - pub fun borrowNFT(id: UInt64): &NFT - /// Safe way to borrow a reference to an NFT that does not panic - /// - /// @param id: The ID of the NFT that want to be borrowed - /// @return An optional reference to the desired NFT, will be nil if the passed id does not exist - /// - pub fun borrowNFTSafe(id: UInt64): &NFT? { - post { - result == nil || result!.id == id: "The returned reference's ID does not match the requested ID" - } - return nil - } + /// Kept for backwards-compatibility reasons + access(all) resource interface CollectionPublic { + access(all) fun deposit(token: @{NFT}) + access(all) view fun getLength(): Int + access(all) view fun getIDs(): [UInt64] + access(all) fun forEachID(_ f: fun (UInt64): Bool): Void + access(all) view fun borrowNFT(_ id: UInt64): &{NFT}? } /// Requirement for the concrete resource type /// to be declared in the implementing contract /// - pub resource Collection: Provider, Receiver, CollectionPublic { + access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection { - /// Dictionary to hold the NFTs in the Collection - pub var ownedNFTs: @{UInt64: NFT} + access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}} - /// Removes an NFT from the collection and moves it to the caller - /// - /// @param withdrawID: The ID of the NFT that will be withdrawn - /// @return The resource containing the desired NFT - /// - pub fun withdraw(withdrawID: UInt64): @NFT + /// deposit takes a NFT as an argument and stores it in the collection + /// @param token: The NFT to deposit into the collection + access(all) fun deposit(token: @{NonFungibleToken.NFT}) { + pre { + // We emit the deposit event in the `Collection` interface + // because the `Collection` interface is almost always the final destination + // of tokens and deposit emissions from custom receivers could be confusing + // and hard to reconcile to event listeners + emit Deposited(type: token.getType().identifier, id: token.id, uuid: token.uuid, to: self.owner?.address, collectionUUID: self.uuid) + } + } - /// Takes a NFT and adds it to the collections dictionary - /// and adds the ID to the ID array - /// - /// @param token: An NFT resource - /// - pub fun deposit(token: @NFT) + /// Gets the amount of NFTs stored in the collection + /// @return An integer indicating the size of the collection + access(all) view fun getLength(): Int { + return self.ownedNFTs.length + } - /// Returns an array of the IDs that are in the collection - /// - /// @return An array containing all the IDs on the collection - /// - pub fun getIDs(): [UInt64] + /// Allows a given function to iterate through the list + /// of owned NFT IDs in a collection without first + /// having to load the entire list into memory + access(all) fun forEachID(_ f: fun (UInt64): Bool): Void { + self.ownedNFTs.forEachKey(f) + } - /// Returns a borrowed reference to an NFT in the collection - /// so that the caller can read data and call methods from it + /// Borrows a reference to an NFT stored in the collection + /// If the NFT with the specified ID is not in the collection, + /// the function should return `nil` and not panic. /// - /// @param id: The ID of the NFT that want to be borrowed - /// @return A reference to the NFT - /// - pub fun borrowNFT(id: UInt64): &NFT { - pre { - self.ownedNFTs[id] != nil: "NFT does not exist in the collection!" + /// @param id: The desired nft id in the collection to return a referece for. + /// @return An optional reference to the NFT + access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? { + post { + (result == nil) || (result?.id == id): + "Cannot borrow NFT reference: The ID of the returned reference does not match the ID that was specified" + } + } + + /// createEmptyCollection creates an empty Collection of the same type + /// and returns it to the caller + /// @return A an empty collection of the same type + access(all) fun createEmptyCollection(): @{Collection} { + post { + result.getType() == self.getType(): "The created collection does not have the same type as this collection" + result.getLength() == 0: "The created collection must be empty!" } } } - /// Creates an empty Collection and returns it to the caller so that they can own NFTs - /// - /// @return A new Collection resource - /// - pub fun createEmptyCollection(): @Collection { + /// createEmptyCollection creates an empty Collection for the specified NFT type + /// and returns it to the caller so that they can own NFTs + /// @param nftType: The desired nft type to return a collection for. + /// @return An array of NFT Types that the implementing contract defines. + access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection} { post { result.getIDs().length == 0: "The created collection must be empty!" } } } - \ No newline at end of file diff --git a/contracts/standards/ViewResolver.cdc b/contracts/standards/ViewResolver.cdc new file mode 100644 index 0000000..862a4e8 --- /dev/null +++ b/contracts/standards/ViewResolver.cdc @@ -0,0 +1,59 @@ +// Taken from the NFT Metadata standard, this contract exposes an interface to let +// anyone borrow a contract and resolve views on it. +// +// This will allow you to obtain information about a contract without necessarily knowing anything about it. +// All you need is its address and name and you're good to go! +access(all) contract interface ViewResolver { + + /// Function that returns all the Metadata Views implemented by the resolving contract. + /// Some contracts may have multiple resource types that support metadata views + /// so there there is an optional parameter for specify which resource type the caller + /// is looking for views for. + /// Some contract-level views may be type-agnostic. In that case, the contract + /// should return the same views regardless of what type is passed in. + /// + /// @param resourceType: An optional resource type to return views for + /// @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. + /// + access(all) view fun getContractViews(resourceType: Type?): [Type] + + /// Function that resolves a metadata view for this token. + /// Some contracts may have multiple resource types that support metadata views + /// so there there is an optional parameter for specify which resource type the caller + /// is looking for views for. + /// Some contract-level views may be type-agnostic. In that case, the contract + /// should return the same views regardless of what type is passed in. + /// + /// @param resourceType: An optional resource type to return views for + /// @param view: The Type of the desired view. + /// @return A structure representing the requested view. + /// + access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? + + /// Provides access to a set of metadata views. A struct or + /// resource (e.g. an NFT) can implement this interface to provide access to + /// the views that it supports. + /// + access(all) resource interface Resolver { + + /// Same as getViews above, but on a specific NFT instead of a contract + access(all) view fun getViews(): [Type] + + /// Same as resolveView above, but on a specific NFT instead of a contract + access(all) fun resolveView(_ view: Type): AnyStruct? + } + + /// A group of view resolvers indexed by ID. + /// + access(all) resource interface ResolverCollection { + access(all) view fun borrowViewResolver(id: UInt64): &{Resolver}? { + return nil + } + + access(all) view fun getIDs(): [UInt64] { + return [] + } + } +} + \ No newline at end of file diff --git a/contracts/test/A.cdc b/contracts/test/A.cdc index b08388b..c160429 100644 --- a/contracts/test/A.cdc +++ b/contracts/test/A.cdc @@ -1,12 +1,12 @@ -pub contract interface A { +access(all) contract interface A { - pub resource interface I { - pub fun foo(): String + access(all) resource interface I { + access(all) fun foo(): String } - pub resource R : I { - pub fun foo(): String { + access(all) resource interface R : I { + access(all) fun foo(): String { return "foo" } } -} \ No newline at end of file +} diff --git a/contracts/test/A_update.cdc b/contracts/test/A_update.cdc index 44da41d..afdabdb 100644 --- a/contracts/test/A_update.cdc +++ b/contracts/test/A_update.cdc @@ -5,7 +5,7 @@ access(all) contract interface A { access(all) fun bar(): String } - access(all) resource R : I { + access(all) resource interface R : I { access(all) fun foo(): String { return "foo" } diff --git a/contracts/test/B.cdc b/contracts/test/B.cdc index 79abea6..bdd3a9c 100644 --- a/contracts/test/B.cdc +++ b/contracts/test/B.cdc @@ -1,14 +1,14 @@ import "A" -pub contract B : A { +access(all) contract B : A { - pub resource R : A.I { - pub fun foo(): String { + access(all) resource R : A.R { + access(all) fun foo(): String { return "foo" } } - pub fun createR(): @R { + access(all) fun createR(): @R { return <-create R() } } \ No newline at end of file diff --git a/contracts/test/B_update.cdc b/contracts/test/B_update.cdc index 3cb6a4e..0773887 100644 --- a/contracts/test/B_update.cdc +++ b/contracts/test/B_update.cdc @@ -2,7 +2,7 @@ import A from 0x0000000000000009 access(all) contract B : A { - access(all) resource R : A.I { + access(all) resource R : A.R { access(all) fun foo(): String { return "foo" } diff --git a/contracts/test/C.cdc b/contracts/test/C.cdc index 4c3f270..0597bd8 100644 --- a/contracts/test/C.cdc +++ b/contracts/test/C.cdc @@ -1,51 +1,48 @@ import "A" import "B" -pub contract C { +access(all) contract C { - pub let StoragePath: StoragePath - pub let PublicPath: PublicPath + access(all) let StoragePath: StoragePath + access(all) let PublicPath: PublicPath - pub resource interface OuterPublic { - pub fun getFooFrom(id: UInt64): String + access(all) resource interface OuterPublic { + access(all) fun getFooFrom(id: UInt64): String } - pub resource Outer : OuterPublic { - pub let inner: @{UInt64: A.R} + access(all) resource Outer : OuterPublic { + access(all) let inner: @{UInt64: {A.R}} init() { self.inner <- {} } - pub fun getFooFrom(id: UInt64): String { + access(all) fun getFooFrom(id: UInt64): String { return self.borrowResource(id)?.foo() ?? panic("No resource found with given ID") } - pub fun addResource(_ i: @A.R) { + access(all) fun addResource(_ i: @{A.R}) { self.inner[i.uuid] <-! i } - pub fun borrowResource(_ id: UInt64): &{A.I}? { + access(all) fun borrowResource(_ id: UInt64): &{A.I}? { return &self.inner[id] as &{A.I}? } - pub fun removeResource(_ id: UInt64): @A.R? { + access(all) fun removeResource(_ id: UInt64): @{A.R}? { return <- self.inner.remove(key: id) } - - destroy() { - destroy self.inner - } } init() { self.StoragePath = /storage/Outer self.PublicPath = /public/OuterPublic - self.account.save<@Outer>(<-create Outer(), to: self.StoragePath) - self.account.link<&{OuterPublic}>(self.PublicPath, target: self.StoragePath) + self.account.storage.save<@Outer>(<-create Outer(), to: self.StoragePath) + let cap = self.account.capabilities.storage.issue<&{OuterPublic}>(self.StoragePath) + self.account.capabilities.publish(cap, at: self.PublicPath) - let outer = self.account.borrow<&Outer>(from: self.StoragePath)! + let outer = self.account.storage.borrow<&Outer>(from: self.StoragePath)! outer.addResource(<- B.createR()) } } \ No newline at end of file diff --git a/contracts/test/C_update.cdc b/contracts/test/C_update.cdc index d181917..7be1f87 100644 --- a/contracts/test/C_update.cdc +++ b/contracts/test/C_update.cdc @@ -12,7 +12,7 @@ access(all) contract C { } access(all) resource Outer : OuterPublic { - access(all) let inner: @{UInt64: A.R} + access(all) let inner: @{UInt64: {A.R}} init() { self.inner <- {} @@ -26,7 +26,7 @@ access(all) contract C { return self.borrowResource(id)?.bar() ?? panic("No resource found with given ID") } - access(all) fun addResource(_ i: @A.R) { + access(all) fun addResource(_ i: @{A.R}) { self.inner[i.uuid] <-! i } @@ -34,23 +34,20 @@ access(all) contract C { return &self.inner[id] as &{A.I}? } - access(all) fun removeResource(_ id: UInt64): @A.R? { + access(all) fun removeResource(_ id: UInt64): @{A.R}? { return <- self.inner.remove(key: id) } - - destroy() { - destroy self.inner - } } init() { self.StoragePath = /storage/Outer self.PublicPath = /public/OuterPublic - self.account.save<@Outer>(<-create Outer(), to: self.StoragePath) - self.account.link<&{OuterPublic}>(self.PublicPath, target: self.StoragePath) + self.account.storage.save<@Outer>(<-create Outer(), to: self.StoragePath) + let cap = self.account.capabilities.storage.issue<&{OuterPublic}>(self.StoragePath) + self.account.capabilities.publish(cap, at: self.PublicPath) - let outer = self.account.borrow<&Outer>(from: self.StoragePath)! + let outer = self.account.storage.borrow<&Outer>(from: self.StoragePath)! outer.addResource(<- B.createR()) } } \ No newline at end of file diff --git a/contracts/test/Foo.cdc b/contracts/test/Foo.cdc index 41d1bc2..663c5ef 100644 --- a/contracts/test/Foo.cdc +++ b/contracts/test/Foo.cdc @@ -1,5 +1,5 @@ -pub contract Foo { - pub fun foo(): String { +access(all) contract Foo { + access(all) fun foo(): String { return "foo" } } diff --git a/flow.json b/flow.json index e5ba0e3..5137363 100644 --- a/flow.json +++ b/flow.json @@ -1,153 +1,169 @@ { - "contracts": { - "A": { - "source": "./contracts/test/A.cdc", - "aliases": { - "emulator": "179b6b1cb6755e31", - "testing": "0000000000000009" - } - }, - "B": { - "source": "./contracts/test/B.cdc", - "aliases": { - "emulator": "f3fcd2c1a78f5eee", - "testing": "0000000000000010" - } - }, - "C": { - "source": "./contracts/test/C.cdc", - "aliases": { - "emulator": "f3fcd2c1a78f5eee", - "testing": "0000000000000010" - } - }, - "Foo": { - "source": "./contracts/test/Foo.cdc", - "aliases": { - "emulator": "01cf0e2f2f715450", - "testing": "0000000000000008" - } - }, - "FungibleToken": { - "source": "./contracts/standards/FungibleToken.cdc", - "aliases": { - "emulator": "ee82856bf20e2aa6", - "mainnet": "f233dcee88fe0abe", - "testnet": "9a0766d93b6608b7" - } - }, - "MetadataViews": { - "source": "./contracts/standards/MetadataViews.cdc", - "aliases": { - "emulator": "f8d6e0586b0a20c7", - "mainnet": "1d7e57aa55817448", - "testnet": "631e88ae7f1d7c20" - } - }, - "MigrationContractStaging": { - "source": "./contracts/MigrationContractStaging.cdc", - "aliases": { - "crescendo": "27b2302520211b67", - "emulator": "f8d6e0586b0a20c7", - "mainnet": "56100d46aa9b0212", - "testing": "0000000000000007", - "testnet": "2ceae959ed1a7e7a" - } - }, - "NonFungibleToken": { - "source": "./contracts/standards/NonFungibleToken.cdc", - "aliases": { - "emulator": "f8d6e0586b0a20c7", - "mainnet": "1d7e57aa55817448", - "testnet": "631e88ae7f1d7c20" - } - }, - "StagedContractUpdates": { - "source": "./contracts/staged-contract-updates/StagedContractUpdates.cdc", - "aliases": { - "emulator": "f8d6e0586b0a20c7", - "testing": "0000000000000007" - } - } - }, - "networks": { - "crescendo": "access.crescendo.nodes.onflow.org: 9000", - "emulator": "127.0.0.1:3569", - "mainnet": "access.mainnet.nodes.onflow.org:9000", - "sandboxnet": "access.sandboxnet.nodes.onflow.org:9000", - "testing": "127.0.0.1:3569", - "testnet": "access.devnet.nodes.onflow.org:9000" - }, - "accounts": { - "a-account": { - "address": "179b6b1cb6755e31", - "key": "1bbaf3239cfd9e8e35f85723f6c70f2ac5c8f50856c4667021cf9ed72eabd9f8" - }, - "abc-updater": { - "address": "e03daebed8ca0615", - "key": "caa4da634fee3ad45ce67ef8a6813987888d88f4b4e6e70b8d84685845db7f25" - }, - "bc-account": { - "address": "f3fcd2c1a78f5eee", - "key": "c06a4b0fce3bc3088a2a2e3b11a9ea5d13e251661cefa3f26af1180ad317d3dc" - }, - "emulator-account": { - "address": "f8d6e0586b0a20c7", - "key": "a08c990a1f7adb14c290d05df0f397d2de2f4d0cb18cdffed592f611f95f5d08" - }, - "emulator-ft": { - "address": "ee82856bf20e2aa6", - "key": "686779d775e5fcbf8d2f4a85cb4c53525d02b7ef53230d180fc16f35d9b7d025" - }, - "foo": { - "address": "01cf0e2f2f715450", - "key": "e9b7b36e9d16f47501db73e84c68e441609475ee482ee808411b2fe0bd2329da" - }, - "migration-contract-staging-crescendo": { - "address": "27b2302520211b67", - "key": { - "type": "google-kms", - "hashAlgorithm": "SHA2_256", - "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-testnet/cryptoKeys/evm-storage-testnet-key/cryptoKeyVersions/1" - } - }, - "migration-contract-staging-mainnet": { - "address": "56100d46aa9b0212", - "key": { - "type": "google-kms", - "hashAlgorithm": "SHA2_256", - "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-mainnet/cryptoKeys/evm-storage-mainnet-key/cryptoKeyVersions/1" - } - }, - "migration-contract-staging-testnet": { - "address": "2ceae959ed1a7e7a", - "key": { - "type": "google-kms", - "hashAlgorithm": "SHA2_256", - "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-testnet/cryptoKeys/evm-storage-testnet-key/cryptoKeyVersions/1" - } - } - }, - "deployments": { - "crescendo": { - "migration-contract-staging-crescendo": [ - "MigrationContractStaging" - ] - }, - "emulator": { - "emulator-account": [ - "MigrationContractStaging" - ] - }, - "mainnet": { - "migration-contract-staging-mainnet": [ - "MigrationContractStaging" - ] - }, - "testnet": { - "migration-contract-staging-testnet": [ - "MigrationContractStaging" - ] - } - } -} \ No newline at end of file + "contracts": { + "A": { + "source": "./contracts/test/A.cdc", + "aliases": { + "emulator": "179b6b1cb6755e31", + "testing": "0000000000000009" + } + }, + "B": { + "source": "./contracts/test/B.cdc", + "aliases": { + "emulator": "f3fcd2c1a78f5eee", + "testing": "0000000000000010" + } + }, + "Burner": { + "source": "./contracts/standards/Burner.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "previewnet": "b6763b4399a888c8", + "testing": "0000000000000001" + } + }, + "C": { + "source": "./contracts/test/C.cdc", + "aliases": { + "emulator": "f3fcd2c1a78f5eee", + "testing": "0000000000000010" + } + }, + "Foo": { + "source": "./contracts/test/Foo.cdc", + "aliases": { + "emulator": "01cf0e2f2f715450", + "testing": "0000000000000008" + } + }, + "FungibleToken": { + "source": "./contracts/standards/FungibleToken.cdc", + "aliases": { + "emulator": "ee82856bf20e2aa6", + "mainnet": "f233dcee88fe0abe", + "testnet": "9a0766d93b6608b7" + } + }, + "MetadataViews": { + "source": "./contracts/standards/MetadataViews.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "mainnet": "1d7e57aa55817448", + "testnet": "631e88ae7f1d7c20" + } + }, + "MigrationContractStaging": { + "source": "./contracts/MigrationContractStaging.cdc", + "aliases": { + "crescendo": "27b2302520211b67", + "emulator": "f8d6e0586b0a20c7", + "mainnet": "56100d46aa9b0212", + "testing": "0000000000000007", + "testnet": "2ceae959ed1a7e7a" + } + }, + "NonFungibleToken": { + "source": "./contracts/standards/NonFungibleToken.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "mainnet": "1d7e57aa55817448", + "testnet": "631e88ae7f1d7c20" + } + }, + "DependencyAudit": { + "source": "./contracts/DependencyAudit.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "testing": "0000000000000007" + } + }, + "StagedContractUpdates": { + "source": "./contracts/staged-contract-updates/StagedContractUpdates.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "testing": "0000000000000007" + } + }, + "ViewResolver": { + "source": "./contracts/standards/ViewResolver.cdc", + "aliases": { + "emulator": "f8d6e0586b0a20c7", + "mainnet": "1d7e57aa55817448", + "testnet": "631e88ae7f1d7c20" + } + } + }, + "networks": { + "crescendo": "access.crescendo.nodes.onflow.org: 9000", + "emulator": "127.0.0.1:3569", + "mainnet": "access.mainnet.nodes.onflow.org:9000", + "previewnet": "access.previewnet.nodes.onflow.org: 9000", + "sandboxnet": "access.sandboxnet.nodes.onflow.org:9000", + "testing": "127.0.0.1:3569", + "testnet": "access.devnet.nodes.onflow.org:9000" + }, + "accounts": { + "a-account": { + "address": "179b6b1cb6755e31", + "key": "1bbaf3239cfd9e8e35f85723f6c70f2ac5c8f50856c4667021cf9ed72eabd9f8" + }, + "abc-updater": { + "address": "e03daebed8ca0615", + "key": "caa4da634fee3ad45ce67ef8a6813987888d88f4b4e6e70b8d84685845db7f25" + }, + "bc-account": { + "address": "f3fcd2c1a78f5eee", + "key": "c06a4b0fce3bc3088a2a2e3b11a9ea5d13e251661cefa3f26af1180ad317d3dc" + }, + "emulator-account": { + "address": "f8d6e0586b0a20c7", + "key": "a08c990a1f7adb14c290d05df0f397d2de2f4d0cb18cdffed592f611f95f5d08" + }, + "emulator-ft": { + "address": "ee82856bf20e2aa6", + "key": "686779d775e5fcbf8d2f4a85cb4c53525d02b7ef53230d180fc16f35d9b7d025" + }, + "foo": { + "address": "01cf0e2f2f715450", + "key": "e9b7b36e9d16f47501db73e84c68e441609475ee482ee808411b2fe0bd2329da" + }, + "migration-contract-staging-crescendo": { + "address": "27b2302520211b67", + "key": { + "type": "google-kms", + "hashAlgorithm": "SHA2_256", + "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-testnet/cryptoKeys/evm-storage-testnet-key/cryptoKeyVersions/1" + } + }, + "migration-contract-staging-mainnet": { + "address": "56100d46aa9b0212", + "key": { + "type": "google-kms", + "hashAlgorithm": "SHA2_256", + "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-mainnet/cryptoKeys/evm-storage-mainnet-key/cryptoKeyVersions/1" + } + }, + "migration-contract-staging-testnet": { + "address": "2ceae959ed1a7e7a", + "key": { + "type": "google-kms", + "hashAlgorithm": "SHA2_256", + "resourceID": "projects/dl-flow-admin/locations/global/keyRings/migration-contract-staging-testnet/cryptoKeys/evm-storage-testnet-key/cryptoKeyVersions/1" + } + } + }, + "deployments": { + "crescendo": { + "migration-contract-staging-crescendo": ["MigrationContractStaging"] + }, + "emulator": { + "emulator-account": ["MigrationContractStaging", "DependencyAudit"] + }, + "mainnet": { + "migration-contract-staging-mainnet": ["MigrationContractStaging"] + }, + "testnet": { + "migration-contract-staging-testnet": ["MigrationContractStaging"] + } + } +} diff --git a/lib/go/contracts/internal/assets/assets.go b/lib/go/contracts/internal/assets/assets.go index b7453af..642747c 100644 --- a/lib/go/contracts/internal/assets/assets.go +++ b/lib/go/contracts/internal/assets/assets.go @@ -1,6 +1,7 @@ // Code generated by go-bindata. DO NOT EDIT. // sources: -// MigrationContractStaging.cdc (19.438kB) +// DependencyAudit.cdc (6.098kB) +// MigrationContractStaging.cdc (19.536kB) package assets @@ -69,7 +70,27 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _migrationcontractstagingCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x3c\xcb\x72\x5b\xb9\xb1\x7b\x7f\x45\x8b\x0b\x9b\xbc\x45\x51\x93\xa9\x5b\x77\xa1\x32\xe3\x51\x64\xcf\x1d\x2f\xec\x71\x59\x72\xb2\x70\xb9\x26\xd0\x39\x4d\x12\xe5\x43\x80\x05\xe0\x88\xd6\x75\xbc\xcf\x77\xde\x2f\x49\xe1\xfd\x38\x07\x24\xad\x99\x1a\x56\x12\xdb\x24\x80\x7e\xa0\xbb\xd1\xcf\x5c\x5c\x5c\xc0\xed\x86\x4a\x68\x38\x53\x82\x34\x0a\xa8\x04\xca\x14\xb2\x16\x5b\x58\x71\x01\xbd\x44\xa0\x0c\xd4\x06\xe1\x9a\xb4\xc8\x1a\x84\xbf\x2c\x7e\x88\xeb\xb7\x74\x2d\x88\xa2\x9c\x01\x69\x04\x97\xd2\xac\xfc\xb9\xe3\x7b\x60\xa8\xf6\x5c\x7c\x5e\x3c\xb9\xb8\xb8\xd0\xff\x85\xd7\x0c\x76\x02\x77\xc4\xad\xd7\xa7\x2b\x0d\x7b\x4b\x3b\x94\x8a\x33\x9c\xc3\x03\xef\x45\x3c\x7b\x4f\xbb\x0e\xde\xbe\x7a\xf5\x12\x14\x87\x3b\x84\x7e\xd7\x12\x85\xed\x19\xfc\xaa\xd1\x78\xe0\xfd\xb3\xfb\xf0\xa5\xdf\xda\xa2\x3e\xd8\xc0\x4b\xf0\x35\x27\xc3\x9b\x0f\x37\xb7\x20\x15\x59\x63\x01\xc8\x6c\x33\x54\xa6\xac\x90\x1c\xd4\x86\x28\x43\x91\x85\x02\x0d\x61\x1a\x11\xfc\x82\x4d\xaf\x81\x12\x09\x04\x76\x44\x28\xe0\x2b\xbd\xce\xc0\x75\x84\x9f\xef\x69\x8b\x1a\x9c\xc2\xc8\xa5\xc8\x8d\x5b\x3e\x8a\x8a\x05\x74\x69\x96\xfc\x65\x01\x8d\x40\xbd\x9f\xc0\x2f\x5c\x2a\x78\x0a\x92\xdc\x1b\x4c\xb3\x4d\xe7\x1b\x2e\x15\x65\x6b\x20\x4d\xc3\x7b\xa6\xcc\xe6\x1f\x17\xd0\x90\xae\xb3\x40\xae\xdd\xca\xe9\x0c\x76\x44\x4a\xb3\x16\x04\xae\x50\x18\x0e\x29\x6e\xf8\xa3\x61\xcc\x0d\xb9\x01\x1d\x46\xb6\x38\x07\xc2\xda\x84\x0b\x6d\xe0\xac\xe6\x5b\x24\xc8\x30\xcf\x32\xa8\xe5\xcc\xa0\x49\x40\xc3\xea\x10\x94\x20\x4c\x92\x46\xb3\xe0\x0c\x7e\xe6\x02\xb6\x5c\xd8\xfd\x06\x16\x7e\x51\x73\x90\x88\xb0\x51\x6a\x27\x2f\x2f\x2e\xd6\x54\x6d\xfa\xbb\x45\xc3\xb7\x17\x9c\xad\x3a\xbe\xbf\x08\xc4\x5a\x24\xcc\x15\x3f\x21\x4d\x83\x52\x4e\x49\xd7\xcd\x22\xce\x6f\x3c\xb3\x3d\xd5\x37\x8a\xac\x35\xc9\x5f\x9f\x3c\x01\x00\xb8\xb8\x80\x77\x44\x6d\xf4\x06\xa9\x08\x53\xd2\x7d\x6b\xfe\x70\x27\x4a\xec\x56\x33\xe8\x50\x41\x8b\x1d\xdd\x52\x85\xe2\x12\x6e\x94\xa0\x6c\x3d\xbe\xac\x21\x3b\xd9\x77\xa8\x0f\x7e\x27\x70\x45\xbf\x8c\x2d\x37\x78\xea\xd5\x9a\xd3\x37\x8a\x0b\xb2\x36\x3b\xf4\xda\xf0\x8f\xd1\x0d\x57\xed\x96\xb2\x83\x3b\xf4\x15\xbc\x21\xbb\x44\x7e\x49\xdb\x0a\x94\x12\xa5\xbe\x5f\xc2\x80\x08\x41\x1e\xb4\xa0\x1a\x91\x68\xf3\x4b\x96\xe3\x64\xd9\xa5\x9e\x91\xf2\x12\xbe\x5e\xd9\x53\x2f\xe1\xa3\xa5\xef\xd3\xb7\x00\xfe\x76\x83\x70\xd7\xf1\xe6\x33\x6c\x90\xae\x37\x0a\x88\x82\xfd\x86\x36\x1b\x27\x38\x56\x3c\x18\xd7\xff\xe9\x38\x5b\xa3\xd0\xb2\x62\x41\x2c\xe0\xf5\x0a\x18\xed\xe6\xd9\xda\xf0\x33\x50\xd6\xe2\x8a\x32\xaa\xb0\x7b\x80\x9e\x29\xda\x05\xb0\x46\x60\x7b\xc5\x57\x2b\xb8\x27\x5d\x8f\xda\x86\x49\x54\x8b\x21\x45\xf7\x44\x98\xf3\x28\x5b\x5f\x9b\x0d\x97\xf0\xe1\x35\x53\xff\xf3\xdf\x2f\xc2\x61\xef\x51\xf6\x9d\x92\x4e\x9f\xa1\x23\x52\x01\x6e\xfb\xce\xc8\xfd\xd0\xea\xcd\xa1\xe1\xdb\x2d\x55\xfa\xd7\xbb\x07\xb3\x85\xe8\xab\x02\xb2\x52\x28\x80\xaf\x56\xcd\x86\x50\x36\xb2\x73\x70\xcd\x1a\x39\x0d\xee\x95\x83\x16\xc4\xd8\xa2\x74\x09\x95\x1f\x5e\x3c\x09\xc8\xbf\xba\x47\xa6\xd1\xb5\xf8\xec\x37\xa8\x35\xd0\x83\x7e\x26\x9d\x9d\x93\x8e\xa7\x73\x10\xb8\xeb\x48\x83\x2d\x68\x43\xcf\xec\xb7\xe1\xb0\x7f\x5a\x75\xfd\x27\xfc\xff\xbf\xff\x0d\x5f\x27\xe6\xd7\xc9\x1c\x26\x6e\x93\xfe\xab\xdb\x33\xf9\x06\x48\x9a\x0d\xb4\xc8\xb8\xb1\x43\x86\x0d\x66\x37\xdc\xa1\xf9\x82\x7c\x46\x06\xdc\xbe\x23\x85\xf8\x05\x80\x6f\x7f\xbd\x7d\x75\x09\x2f\x39\x4a\x60\x5c\xc1\xba\x27\x82\x30\x85\x18\xad\x70\x61\xb0\xa5\xbe\x6f\x1a\xcc\xd1\x80\xa3\x68\xd8\xe1\xb4\xff\x46\x11\xd5\xcb\x0f\xd6\x82\x4d\xcd\x5a\xfd\x71\x7a\xfb\xe1\xc3\xeb\x97\x5e\x18\xe6\xe1\x47\xe2\x65\xdd\x09\x7d\xfc\x45\x23\xe0\x35\x3c\xfd\xd6\xe2\x37\xfc\xc5\x72\x23\xb3\x09\xb3\x78\x6d\xe9\x85\x1d\x10\x36\x09\x1b\x6d\xfe\xef\x10\xb5\x40\x6d\x77\x1d\x2a\x7d\x8b\xfb\x0d\x0a\x84\x15\xa1\x5d\xa2\xa9\x40\x04\x1a\xc5\xf6\x72\x49\x45\x80\x17\x1f\xfb\x16\x99\xa2\x2b\x8a\x02\xce\xe1\x6a\x71\xf5\xf2\xe5\xfb\x57\x37\x37\x8b\xb7\x57\x6f\x5e\xb9\x53\xdd\x57\x9a\xd7\xfa\x02\xf4\x43\xe3\xb9\x02\x7b\xaa\x36\xbc\x57\xf0\xc3\x97\x0a\xe7\x2b\x02\x7b\xed\x35\x26\xde\x82\x64\x64\x27\x37\x5c\xdd\xd2\x2d\x4a\x45\xb6\xbb\x4b\xf8\xf0\x33\xfd\x92\xde\x45\xd0\xb3\x03\x6b\x0a\x1e\x44\x1b\x75\x88\xe1\x5e\x24\x83\x51\x88\x56\xc4\xbd\x77\x87\x05\xcb\x6e\xf2\x82\xc5\xbb\x36\x18\x95\x39\x30\xdc\x87\x7f\xcd\x9e\x38\x45\xfd\xaf\x91\x4f\x20\xe1\x5d\x7f\xd7\xd1\x06\xde\xa0\xda\xf0\xd6\x1a\x65\x18\xdb\x70\xe1\x0f\x83\xf3\xf3\x73\x8f\x8a\xdf\x66\xbe\x0b\x4b\xb4\x27\x01\xe7\x70\xed\x5d\x09\x7b\x89\xac\x75\xce\x84\x3a\xea\x4f\x68\x3b\x5e\x7b\x54\x17\xc5\x53\xe6\x41\x06\xd0\x16\xac\xf4\x2e\x8c\x44\x71\x6f\x8e\x96\x41\xfa\x9a\xd4\x1f\x4c\x94\xdc\x41\x5f\xc0\xfb\xd4\x51\x31\x3e\x9a\x40\xc9\x7b\xd1\x60\x94\x60\x23\x9f\x51\xc2\x49\xd7\x19\x28\x4e\x54\x25\xd7\x74\x6e\x7b\xa9\xcc\x93\x42\xee\xcd\x8b\x12\xe8\x93\x16\x7f\xb8\xc3\x95\x76\x4b\xac\xcd\xea\x25\xb6\x1a\xa0\xf5\xd2\x48\xe9\xa2\x2d\x32\x4a\x53\xe9\x58\xf5\xcc\xf9\x6d\x9a\xe2\xe9\xec\x12\x7e\x32\xa4\x7f\x0d\x97\x2c\x50\xf5\x82\xc1\xf3\x73\xef\xdf\xd9\x85\xe6\xf7\x6f\xf1\xd6\x7e\xd4\xb7\x36\xe6\xc3\x69\xcd\x8b\xfa\x18\xfd\x38\x7d\xa9\xd9\xab\x9e\x7f\x63\xac\xa6\x76\xf4\xf6\x54\x6e\x02\x69\x83\x1b\xd3\x37\x6b\xf9\x59\x6c\xf5\x37\xb4\xa6\xf7\xc8\x4a\x40\x6a\x60\x20\xcc\x93\x9e\x9d\x42\x25\x90\x4e\x20\x69\x1f\xfc\x13\x94\x3f\xe2\x1a\x88\x71\xfa\xef\x30\xbc\x4d\x8b\xe2\x7d\xd8\x92\xcf\xe6\x76\x9c\x97\xe0\xa9\x68\xed\x6e\x81\x12\x95\x7b\x17\xac\x58\x49\x63\xf7\x1d\xee\x44\x05\x64\x0e\xdf\x5f\xce\x71\x4d\xd5\x25\x3c\xb5\xfe\xb1\x26\x37\x18\xf8\xec\x21\x98\x25\x57\xbc\x13\x98\xfc\xcb\xd8\x38\xec\x56\x0b\x2a\x9d\xde\xbc\x43\x41\x79\x7b\xd5\x28\x7a\x8f\x5a\x44\x26\x5e\x85\x77\xe6\x07\xd8\x10\x09\x26\x0a\x9b\x84\x43\xbe\x85\xbf\x15\x0e\x27\x2c\xed\xe1\x2d\x0a\x7a\x8f\xd7\xf6\x87\x44\x27\xa7\x9e\xe6\xe0\xbb\x69\x82\x16\xee\x9a\xa6\xb3\x79\x60\xca\x5b\x43\x9b\xa6\x70\x16\x80\xd1\x95\x3d\xbd\x70\x05\x3f\xe6\x67\x7c\x82\xe5\x52\xfb\x6f\x05\xd1\x17\x17\xf0\x33\x15\x52\x81\xa2\x5b\x84\x3d\x3e\x13\xa8\xfd\x7c\x4d\x68\x13\x9e\xaa\x95\xe0\x5b\xab\xd7\x5e\x5f\xcf\x81\x32\x89\x42\x39\x87\xca\x7e\x39\x90\xee\x21\x7b\x0b\x1c\x17\xf6\x94\xe9\x67\x7c\x18\xd2\xfc\x51\x1f\xf1\x69\x56\xa2\x1b\xcc\x24\xc3\x3d\x38\x5e\x5a\x29\xd3\xa6\x21\xf3\x5f\xda\x1c\x83\xe4\x56\xb4\x6a\x1b\x84\xac\x7e\xbb\x63\x9c\x1c\x6d\x12\x31\xb2\xf1\x95\x15\x22\xfd\xbf\xb3\x21\x4d\xde\x0c\x6a\xab\x35\x7d\x7e\xee\x20\xcc\x41\xf1\xcb\x54\x08\xf2\x9d\xd6\xc2\x8c\x88\xce\xc5\x05\xfc\x03\x75\xdc\x2c\x31\xd1\xe1\xf4\x0e\xb2\x37\xde\x59\xc4\x73\x68\x36\xd8\x7c\xd6\xb2\x70\x58\xa1\x53\xa9\x31\xfc\x70\x2b\x5f\xb3\x16\xbf\x78\x39\x3d\x22\x49\x67\x8b\x95\x16\x19\xb3\x65\xca\x57\x4e\x1e\x87\x82\x75\x7b\x10\x13\x38\xf7\x26\x24\xd8\x96\xea\x6d\x2d\x73\x4e\xdf\x71\x21\xf8\xfe\xf9\x53\x77\x6d\x7f\x9d\x6a\xe6\x1c\x60\xb6\xfe\xbc\x78\x01\x3b\xc2\x68\x33\x9d\x5c\xf3\xbe\x6b\x8d\x07\x6b\xcf\x01\xfc\x42\xed\x73\xea\xa5\xc9\xf0\xda\xbf\x39\xda\x30\x15\x1e\xf1\x24\x3f\xde\xc1\x5d\x38\x72\xae\x79\x8b\xd3\x9a\xc4\x1c\xba\xf7\x44\x11\x9d\xbf\x53\x24\x3c\xce\xf5\xb5\x0f\xe3\x7f\xfb\xea\x22\x74\x54\x9a\x3c\x47\x14\x1a\x87\xb7\x26\x41\xdf\xe1\x93\x43\xba\x38\xbc\x65\xb2\xdb\x21\x6b\xa7\xb9\xb5\x19\x13\xf9\xc7\x69\x52\x45\x43\x92\xf7\xf5\x3d\x6e\xf9\xbd\x7b\xe9\xca\x98\xd8\x3e\x78\x56\x29\x22\xbf\x90\xdd\x53\xc1\xd9\x16\xd9\x91\xf7\xc3\x45\x46\xc7\x5f\x90\x3f\xed\xcd\xd8\xe5\x2e\x88\xfe\x9c\x25\xc7\x63\x3b\x25\xb5\xd7\x21\x32\x58\x03\xbd\x4e\x54\x4e\x2a\xea\xdd\x93\xea\x43\xe5\x4d\xc9\xb2\x38\xf7\xe8\x03\xe3\x56\x56\x5e\x96\xaa\xa4\x27\x8a\xad\xa3\x3a\xaf\xdc\xc2\x5c\xf6\x4d\x06\x23\x92\xec\xfe\x92\xd1\xfa\x64\x5c\xbf\xdf\x09\x7e\xd7\xe1\x16\x5a\x94\x4a\xf0\x87\xe8\x8c\x78\xfd\x4e\xd4\x57\x87\xe2\x47\x02\x50\x28\x83\xd0\xe4\x1f\xf3\x6c\xd5\x00\xd9\xfc\x0c\x23\xf9\x93\x49\xf9\xad\x8f\x48\x8d\x7e\xe4\xe7\xb9\x98\x34\x84\xf1\xe1\xd7\x5c\x53\x6c\x88\xe1\x02\x93\xff\x45\xa5\x50\x0c\x23\x8c\xf7\xe6\x3a\x64\x4c\x9a\x1c\x4f\x04\x85\xe4\xce\x41\x4d\x5a\xa3\xca\x02\x2d\x2d\xf8\x2e\xa2\x1a\x7a\xd4\x41\x8e\xc2\xf2\xa1\xce\x5b\x3c\xf7\x1b\x54\x1b\x14\x99\x76\x3b\x35\xd2\x26\xb1\x17\x02\x99\xea\x1e\x0c\x93\xee\xf1\x20\x86\x55\xfd\xfc\x1b\xe7\xdd\x29\x38\x7a\x01\xff\xd7\xbf\x34\xb5\xd7\x16\xf6\xdf\x34\xff\xa6\xb3\x85\xe3\xe0\xf3\xe5\xc8\xc6\xb3\x1a\x75\x4a\xe8\x00\x76\xf8\x58\x47\xba\x5c\xd6\xad\x4a\xd8\x3d\xc5\x7d\x42\x5d\x6a\x1e\xae\x72\x5d\x71\x76\xec\x28\xb9\x63\xaa\xfd\x62\xa1\xb1\x23\x94\x49\xfb\x0c\x68\x35\x5b\x91\x4e\xe2\xe3\x09\x73\xae\x3f\xb6\xc6\x5f\xd4\x6c\xa5\x2b\xa0\xea\x99\x4d\x2a\x7d\x07\xd9\x7f\xf7\x07\x9d\x46\x79\x4d\x1a\x9d\xfc\x46\xea\xad\x05\x38\x6c\x7a\x5e\x2c\x52\xf8\x86\x2d\xcc\x65\x3c\xc7\x98\xb2\xb1\xa9\x1e\x93\xb5\x0c\xf1\x62\x9b\x7a\x77\x59\xe4\xe6\xe3\xb3\xe3\x5c\x18\x20\xaf\x03\x04\x39\x5d\x71\x71\x55\xf0\x64\x16\x93\x2d\x27\xca\x40\x3c\xe4\x93\xa6\xef\xe3\xa7\x43\xe4\x95\xcf\x73\x5a\x81\x18\xa7\xce\x5e\x3f\xd9\x1e\x08\xd4\xeb\x64\x1a\x1f\xeb\xe8\xb5\xdb\xbf\xfc\xc1\x17\x1f\x1c\xd5\x0a\x27\xf2\xd3\x40\x2a\xd1\x37\xaa\x16\x9a\x7b\xd1\x37\x29\xc3\x93\x65\xff\x28\xe6\x35\x86\xe4\xeb\x53\xc6\xfc\xee\x88\x35\x30\xeb\x48\xa8\xfa\xfb\xdc\xfa\x51\x1f\x23\x38\xe0\xda\x38\xe7\x1c\x89\xa0\xbf\x01\x76\xb2\x74\xdf\xdc\x7e\xaf\xba\x10\xfc\x94\x91\xbb\x4d\x0b\x34\x23\x3a\x9c\x85\x65\x78\xa2\xee\x5e\x75\x5d\x7e\x91\xda\xff\x94\xfa\x69\xfa\x18\x54\xef\x24\x65\x5d\x7c\xc6\x07\x59\xc5\x1c\x5a\x6a\x5c\x09\x22\xaa\xd8\xd7\xf5\xf4\x91\x94\x18\x0d\x1d\xb7\x43\x5f\xad\x3c\x7a\xb9\xfc\x56\x8a\x61\x6a\xca\x6a\x21\x69\x62\x9c\x52\xe9\x2a\xf6\xd6\xfd\x52\xf8\xfa\xad\xe2\x9a\x7a\x48\xda\x5b\x1b\x60\xba\x4c\xf7\x69\x76\x99\xf8\x2b\xa9\x1f\x19\xc0\x67\x05\x48\x27\xf6\xce\x0b\x5d\x9e\x68\x7e\x22\x89\x99\x05\x2a\xce\xd6\x9f\x88\xf2\x47\x97\xfb\x34\xa9\x13\x58\xfa\x54\xe8\x20\xb8\x1e\x23\xde\x8b\x57\x38\xac\x2a\x4f\x63\x2f\x98\xa9\xb4\x6f\xc9\x6e\xa7\x1d\x35\x2d\x64\xce\xca\x17\xa5\xcd\x91\x9a\xe6\x77\x8b\x96\x51\x90\x91\x3a\xe7\x69\xaa\x52\xd7\x92\xc4\xbe\xe5\x09\x25\x9f\x17\x70\x35\xc7\x15\x17\xdb\xcb\xb0\xdf\xfc\xe9\x92\x05\x17\x36\x12\x2e\x4b\xcd\xbf\xb9\x2a\xcd\x6f\x6f\xaf\xde\xbc\xaa\xd3\x7a\xba\xb1\xbd\x1a\x37\xb6\xc9\xc3\x17\x29\xc9\x95\x2b\xa9\x28\x39\x39\x1c\x60\x9b\x09\x8a\xf6\xff\x1a\xa2\xa6\xee\x35\x70\xa5\xf6\xd9\xe8\x9a\x02\xcd\x85\xe2\x16\xa1\xe9\x6c\x7c\xfd\xf7\x9c\xf9\x36\x7b\x47\xdc\xf5\xa6\x3c\x8a\x84\x5d\x26\x44\xd6\x62\xc4\x98\x03\xb2\x4c\x0f\x57\x9c\x72\x4e\xeb\x77\x66\x0a\x27\x23\x71\xd7\x9f\xf6\xd1\xd1\xdc\x23\xc1\xea\x77\xdf\xfa\x21\xf2\xfb\xf7\x3e\x1e\xec\xef\xf9\x98\xd8\xd5\x01\x3e\xfc\x09\x37\x5c\xa9\x66\xda\xdf\x8f\x1c\x92\x05\xca\x3b\x81\x12\x99\xb2\xee\x9c\x88\xfd\x06\xe4\x60\xf1\xd7\x2a\x23\xa1\xcc\x17\xd8\xa5\x22\x42\xc1\xd3\xa4\x01\xc1\xa4\xf6\xb4\xdb\x4b\xd8\x83\xab\x85\x06\xb0\xb9\x61\x34\xa5\x99\xa4\xa4\xb5\x27\x21\x99\xe7\xba\x18\xec\xe9\xe1\x44\x6a\xc3\xa7\x8e\x4a\x65\x4b\x67\x45\xa9\x75\x0e\x54\xc9\xa2\xb9\xc1\x16\xe2\x4c\x9c\xdf\x70\x26\x69\x8b\x02\x5b\x90\xbd\xb1\x4d\xab\xbe\xab\x5a\x67\xe7\xd3\x56\x18\x9e\x58\x1c\xd3\x74\xe2\xcb\xc1\xb1\x4d\x20\xf6\xa4\xf9\xba\xb2\x21\xd0\x34\x21\x84\xbd\x65\x87\x8d\x5f\xea\xab\xca\xa7\x03\xf1\x57\xb8\x47\xd3\xd2\xe4\x6e\xa3\x0a\x28\xac\x18\x85\xf4\x3a\xd8\x96\xd0\x83\x12\x1f\x41\x03\xdc\x72\x3e\x2d\x71\xb5\xbd\xf0\x42\x11\x04\x28\xbf\x8a\x31\x3c\xea\xc5\xf2\xe8\xf1\x30\xaa\xa6\x25\x63\xe6\xf5\x9d\xa5\xf3\x30\x92\x73\x84\x90\x1e\xf6\x57\xf3\xdc\xbd\x13\x91\x2d\x93\x1b\xff\x9b\xaf\xd8\xba\x0e\xc4\x1d\x91\x6a\x52\x71\x34\x86\x07\x2f\xc3\x9d\x0e\x17\x45\xa5\x59\x8e\xe4\x5c\x94\xbf\xee\xe1\xc6\xb2\xcd\x62\x59\x72\xa3\xe2\xe9\x1f\x34\x2d\xb9\x8b\x56\xb7\x28\xe3\x66\x24\x16\xcc\xb5\xa2\x9a\x2f\x84\x40\xb9\xe3\xac\xb5\x75\xb6\xf6\x40\x0c\xec\x74\xad\x88\x2a\x73\x15\x73\x0f\x6e\x29\x8f\x79\xce\xbf\x14\xaf\x32\x58\xcc\x4e\xd4\xcf\x6d\x79\x5c\xf5\xa4\x34\xc8\xcc\xb5\x72\xa4\x25\xd1\x36\xa7\x26\xee\x68\xd9\x62\x95\x16\x6c\xab\x3a\xee\x6b\xd1\x44\xda\x64\x66\xda\x08\x32\x76\xa8\x5e\xe4\x32\xbb\x41\xab\x73\x2d\x3a\x1c\x3b\xd7\xeb\xc8\x41\xf0\x62\x1a\x9d\x14\x0c\x0d\x4b\x4c\xb0\xb0\xac\x94\x46\x0d\x41\xcb\x61\x1d\xcc\xfc\x98\xe0\x7f\xa2\x42\x7c\x7b\x92\x31\xcf\x27\xab\x64\x34\x90\xb6\xf9\x28\x08\x8b\xa9\x82\x49\xdf\x27\xa0\x88\x58\x47\x21\x59\xa4\x67\x8d\x33\xd9\x3b\xb1\xf6\x98\x91\xec\x2a\x44\xbf\x4d\x3b\xf5\x36\xe6\x9f\xa6\xac\x9b\x2d\x82\x25\x5d\xd8\x57\x30\x24\x1f\x03\xfb\x66\x35\x02\x6f\x50\x50\xd2\xd1\xff\x73\xe5\xa2\x32\xc9\x04\x94\xe9\x48\x44\xab\x93\x0b\x50\xbc\x27\x0f\x3f\x7c\x49\xfb\xaa\x4e\xa7\x34\xba\xb7\x5e\x2e\xc6\xa9\x4d\x49\x4c\x7c\x62\xef\xe1\x4e\x16\x93\x59\xe6\x11\x9f\x4a\xa6\x61\x4e\xa3\x2c\x65\xd4\x54\xfb\x0c\x12\x89\x8b\x9f\x92\x79\xac\x7d\xac\x23\xcd\x67\xe9\x7b\xc5\x4e\x62\x40\x04\x54\x65\x81\x79\xb8\x09\x93\x3f\x84\xda\xf2\x08\x23\x64\x47\x1b\x74\xc9\x9e\x1f\xe7\xd0\xef\x6e\xf9\x65\x75\x71\x87\x6c\x5d\xd6\x77\x35\x94\x9d\x89\x5d\x60\x09\x93\xab\xc9\x28\x6b\x0d\x16\x19\xd7\xc7\x2e\xcb\x1e\x73\xfa\x7d\x0c\xcb\x15\x69\xc1\xd6\x45\xfc\x3b\x22\x4d\xaf\xd2\xa0\x5f\x35\x71\x1e\xbd\xbb\xe0\xfc\x04\x27\xf9\xae\x8d\x61\x91\x1b\x67\xd3\x67\x63\xd2\xf0\xd0\x98\x40\x66\x8b\x84\xa5\x0e\xc7\x86\x48\xf6\x4c\x3f\xcc\xeb\x9e\xcd\x33\x73\xa9\xbf\xa6\xac\xe9\xfa\xd6\xba\x89\x16\x15\x83\x01\x17\xe9\x11\x89\x7b\x7a\x9a\x30\xa4\xf9\xf0\x51\xe5\x8f\xa3\x0c\xce\x72\x47\x1a\x9d\xfb\x50\x61\x8e\x51\xe2\x96\xb6\x1a\x77\x8d\xd6\x58\x6e\xe5\x40\x63\x2e\x2c\xeb\xcd\x71\x87\xb6\x0d\xfd\xa2\x54\xa1\x53\x8b\xfc\xfc\x10\xf8\xe8\xef\x0c\xce\xd3\x9f\xa7\x4f\xe1\xec\xd0\xee\xc2\x7b\x29\x4c\x62\xaa\x82\xb3\x03\x8e\x97\xc3\x3c\x96\x6e\x46\x45\xd9\xb4\x2f\x8c\x66\xb1\x5d\xe7\x97\xe9\x6a\x23\x5a\xd9\xf8\x3d\x6d\x7d\xae\xba\x22\x1f\x5e\x0b\x6c\x11\x2e\x6d\x8e\xf8\xed\xf8\x6b\xfa\x87\xbf\x86\x70\xaa\xaf\xa7\x3f\xbf\x04\xc7\xe9\x88\x97\x77\x83\xe2\x1e\x65\xa5\x59\x92\x98\x36\x47\x14\xcf\xe4\x20\x97\xea\x74\xf8\x66\x63\xd4\x37\x6d\x79\xf4\x6d\x27\x26\x4c\x34\x8c\x04\x49\x56\xb8\xee\x89\x68\xed\x40\x4b\x6c\x27\x5c\x0b\xa2\xfd\x4b\xb7\x4c\xf1\x64\x34\xc6\xc9\xb7\x09\x23\x87\x31\xa6\xc9\x55\xef\xa9\xdc\xd8\x06\xbd\x16\x3b\x5c\xdb\x62\x85\x6b\x3b\xe1\x40\x18\x37\x06\xcd\xb7\x60\x4e\x71\xb1\x5e\xc0\xb6\xef\x14\x95\x34\x76\x9e\x4a\x54\xfd\x0e\x90\x91\x3b\xdb\xcf\x09\x2d\xde\x63\xc7\x77\x18\xbb\x99\x43\x8b\x26\x67\xe6\x99\xba\xc3\x0d\xe9\x56\x33\x1d\x91\x82\xb4\x0c\x08\x53\x34\xef\xde\xbf\xfe\xfb\xd5\xed\x2b\xdb\x8a\xda\x90\x1d\xb9\xa3\x1d\x55\x0f\x86\x1b\xbb\xfe\xae\xa3\x72\xa3\xb7\xb9\x86\x17\x81\x0d\xd2\xfb\xa4\x11\xb6\xee\x46\x87\x86\xd4\xa2\xd3\xb3\xac\xde\x84\x75\x7c\xcf\xd2\x9b\x3b\xdd\x10\x86\xfe\x89\xe0\x4a\x1e\x70\x0b\x0c\x94\x17\xc1\x77\x8c\x09\x2a\x83\x26\x95\xd0\x33\xbd\xa4\x3d\x9b\xcc\x1e\x2b\xcb\x2e\xb3\x75\x62\xd0\xe2\xa8\x37\x5a\x6e\x12\xa0\x12\x76\xe8\xe3\x94\xec\x55\x93\x76\x7e\x68\xb4\xdc\xb5\x80\x5f\x59\x10\xa6\x41\x67\xae\xaf\x33\x04\xb0\xab\xd0\xf8\x34\xd7\x27\xba\x54\x9c\x6f\x34\xb5\xc2\x61\xcb\xc5\x06\xa5\x76\x38\x0a\x16\x5a\x91\xaf\xd8\x83\x4b\x8a\x0c\x9a\x72\xcd\xb4\x15\x0d\x39\x67\xd8\x92\x16\x81\xac\x09\x8d\xad\xcd\x52\x7b\x8a\xfe\xd0\xe4\xe1\x0c\x03\x76\x39\x66\xa1\x05\x16\xae\xa4\xe9\xdb\x95\x88\xf3\x6c\x25\x95\xb0\x45\x81\xdd\x43\x80\x1a\x86\xf7\xb2\x0c\xb3\x86\x32\x07\x32\x70\x1d\x64\x80\x15\x46\xda\xee\x1e\xca\x99\xb5\x74\xb2\xcf\xcd\xb6\x39\x37\x3e\x40\x4d\xa3\xaf\x30\xce\x77\x82\xb6\x78\x3a\xbe\x0e\xe2\xba\xac\x38\xea\x5a\x3f\xdb\x41\xcc\x68\x05\xc9\xd3\xe0\xa2\xb4\x45\xa9\x40\x71\x9c\xc9\x4d\xd7\x95\x01\x77\x1e\xaa\x8d\x2f\x1a\xe4\x36\x06\xcd\x5a\xfa\xe3\x0a\x22\x31\x4a\x99\xdc\xda\x48\x27\x60\xdc\xfa\xf9\x16\xb3\xe6\x68\x36\x23\x14\x75\xfa\x24\x37\x50\xf7\x13\xc7\x6a\xe5\xee\x08\x27\x64\xc6\x59\xe7\xab\xaa\x6a\x9d\x6e\x89\x46\xca\xa1\x25\xd3\x0e\x98\xa6\x63\xf4\x24\xce\xc2\x68\x31\x31\xf4\xc0\xdb\x14\xfa\xd8\x68\xe2\x23\xdd\x87\xa3\xce\x83\xbb\xe4\x72\x4f\xee\x20\x9d\xd8\xfa\x05\x65\xfb\x97\x85\xd0\xd3\x76\x3e\x58\x17\x72\x08\x29\x16\xa3\xcd\x60\x10\x1a\xc2\x8c\xe6\x8f\xfc\xe6\xdb\xc2\xd2\xa3\x86\x2d\x62\x90\xb6\x89\xf9\xc1\xaf\x6c\xc5\xa3\xdf\x0d\x33\xd1\x78\xd2\xab\x61\x56\x46\x9b\x61\xa6\x92\x77\x49\x2c\x33\x32\xbc\x73\xdc\xf2\xd8\x43\xbf\x96\xd1\xaf\xcb\xca\x9f\x34\xc5\x58\x8e\x30\x1e\xd5\x1c\x33\x58\x50\xb6\xb3\x11\xe5\xe0\xc4\x41\xa1\x93\x2c\x8d\x43\x2e\xb6\x8e\xd9\x2f\xce\xe0\xaf\xd5\x26\xb2\xcb\xd1\x08\x61\xf2\x8b\x3d\xc9\xe7\x5a\xf5\x71\x5c\xc0\xda\x3c\x8b\x66\x68\x82\xf9\xf6\xaa\x8c\x2f\x87\x4c\x57\x2a\xfc\x23\xf3\x51\xd5\x78\x29\xbb\x4a\x37\x3e\x65\xa1\xe5\xca\x75\xda\x01\xb0\x74\x9b\x6b\x56\xc6\x4e\xa2\x7d\x67\x21\xe6\xa4\x6b\xb6\xf9\xe5\x22\xd8\x92\xd5\x5c\x7a\x3d\x85\xfe\xa8\xd0\x72\x59\xab\x9d\x0c\x6d\x4f\xc4\xc8\xff\x6d\x68\x01\x06\xf9\xfe\x22\x78\x87\xcc\x0e\x84\xfb\x3f\x7d\xfc\xaf\x44\x26\x19\xf1\xab\x63\x35\x36\x10\xf8\x18\x6e\x9d\xc5\x62\xc0\xef\x25\xfd\xb8\x09\x8c\x36\xf0\x35\x53\x28\x18\xe9\x8e\x8f\xfa\xa5\xb6\x30\x4e\xd3\x79\xd7\x29\x58\xb4\xe2\x41\xfc\xc5\x4f\xf9\xe5\x2f\xf2\x02\xfe\xe1\xbc\x25\xe7\xeb\xba\x84\xac\xad\x53\xb7\xb0\x23\x6a\xe3\xfd\xdf\x41\x60\xf7\x4c\x96\x23\x73\xa3\x3e\x9e\xf5\xb7\xe2\x18\x5c\xde\xb4\x7f\x7c\x8c\xea\x12\x7e\x1a\x3a\x86\x59\x87\x4b\xad\xa7\xa5\xde\xb9\x3e\x3e\x64\x53\x8c\xec\xb8\x38\xd1\xe3\xeb\x1d\x41\xfb\xe7\x1f\xd2\xd5\x3d\xf2\xb2\xd7\x90\xcf\xcf\xaa\x3c\xe6\x27\xf5\x77\x8f\x76\x77\x43\x3e\x87\x98\x44\x71\x87\x27\x24\x2c\x33\x9e\xc9\xf1\x69\x16\x2d\x70\x22\xf1\x45\x4d\x07\xbe\x73\xda\x6d\x07\x7e\x1b\xdb\x5d\x44\x6c\xcf\x0d\x10\x5d\x0e\x71\xc5\x7b\xa6\xe3\x9e\x4e\x72\xb7\x4f\x8e\x0c\xa6\x64\xf3\x19\x69\x55\xce\x35\x0a\x1d\x91\xce\xc3\x23\x01\xb5\x26\xc7\x61\xf3\xf9\xc9\x83\x4e\xbe\xed\x79\x7c\xc2\xe9\x2c\x1c\x78\x64\xb3\xc5\x7b\x4a\xd4\x65\x0e\x76\x96\x3c\x4d\xee\xea\x0c\x77\x7c\x9e\xe0\x18\xbb\xec\x55\x98\x31\x12\xc6\x87\x2d\x58\x02\xb7\x69\x30\x9b\x36\x24\xc6\x00\xea\xc8\x2c\xc7\x99\x4b\xb0\x6b\xbf\xe5\x87\x31\xdf\xba\x6c\x3c\x74\xb4\x9a\x09\x3e\x5f\xc7\x29\xec\x2d\x14\x91\x85\x1b\xcc\xf0\x5a\x7c\x7c\xc6\x23\x11\xf8\x97\x76\xaf\xcc\xa2\xec\x60\x62\x0f\xd8\xca\x03\x36\xb2\xa6\x14\x31\x83\x65\xce\x34\x80\x13\xf5\xb0\x97\x61\xa2\xc4\x4a\xd7\x6e\x94\xe4\x1a\xc9\xdf\x29\xc3\x7f\x76\x83\xae\x9f\x92\xf4\xe9\x95\x8e\x93\xf6\xf9\x4f\xa7\xf7\xe7\x0e\x47\x7d\x52\x33\x9b\x2d\x75\x1c\xca\x0c\x5d\x21\x3c\xc9\x49\x75\x09\x2b\xda\xf0\x4d\xc2\x20\x45\x2b\x6f\x3a\x83\x25\x4c\x7e\x9b\xe4\x3f\x16\x03\xf3\xb0\xcc\xfa\xcc\x06\x1e\x48\xda\x78\x36\xa9\xf9\x37\xfa\xcc\x49\xa5\xef\x2d\xfb\xda\x73\x7a\x58\xf9\xca\x1d\xb8\xd9\xa1\x66\x36\xe3\x5a\x24\x48\x4f\x8a\xf1\xbd\xf2\xff\xac\x06\x96\xb1\x83\xb1\x46\x41\x12\x0e\x86\x1c\x7d\xd9\x39\xa8\xb9\x59\xdb\xef\x67\xaf\x32\x2a\xbe\xa7\x13\xf0\x64\xf6\x8c\x99\xa9\xbc\x71\x77\x6c\xc2\x27\x6b\x02\x0f\x55\x86\xba\x03\xaf\x97\xe7\xeb\xcb\x39\x60\xeb\xab\x18\xbe\x4d\xdd\xb0\xe3\x28\xf7\xbd\x8d\xfb\xf6\xe4\x3f\x01\x00\x00\xff\xff\xac\x90\x9d\x2a\xee\x4b\x00\x00" +var _dependencyauditCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x58\x6d\x6f\xdb\xb6\x13\x7f\xef\x4f\x71\xf5\x2b\x0b\x7f\x57\x6e\x0b\xfc\x51\x54\xa8\x57\x64\x69\x0a\x0c\xe8\x13\x96\x6e\x7b\x61\x04\x33\x23\x9d\x6d\x26\x32\x69\x90\x94\x53\x2f\xc8\x77\x1f\x8e\x94\x25\x52\xa2\x9c\x0c\x05\x2a\x04\x81\x64\x1e\xef\x8e\xbf\x7b\xe0\x8f\xe4\xdb\x9d\x54\x06\xc6\x9f\xf8\x5a\x31\xc3\xa5\x38\x97\xc2\x28\x96\x9b\x4b\xc3\xd6\x5c\xac\xc7\xa3\xd1\x6c\x06\xdf\x36\x5c\x43\x5e\x8f\x00\xd7\xf4\x57\x69\x2c\xe0\xfa\x00\x66\x83\xf0\xe1\xcf\x4f\x90\xb3\xb2\xe4\x62\x6d\xbf\x97\xf9\x06\xf3\xdb\xf7\xb8\x43\x51\xa0\xc8\x39\xea\x25\xac\x2a\x91\x93\x01\x58\x29\xb9\x05\xd6\x7e\xcb\x95\x9d\xa3\xd9\x16\x41\xd0\x3f\x26\x0a\xd0\x5c\xac\x05\x33\x95\x42\xe0\xc2\xd9\x28\xe5\xdd\x25\xaa\x3d\xcf\xf1\x2c\xcf\x65\x25\x4c\xe3\xd1\x94\x7c\x64\xc6\x8a\xa1\x28\x48\x23\xee\x51\x1d\xc0\x28\x26\x34\xb3\x66\x52\xb7\x0e\x84\x65\xe1\xb9\x75\x56\x14\x0a\xb5\x26\xff\xc8\x6a\x30\xf6\x99\x6d\xe9\xf7\x3b\x5e\x96\x70\x8d\xc0\xca\xd2\x1a\xf0\x45\x40\x20\x16\x05\x16\x60\x24\xa8\x8a\xfc\x24\x2f\x42\xa3\x8d\xdd\x53\x98\x58\x23\x56\x00\xf8\x0a\x98\x38\x1c\x51\x09\xac\x31\x85\x20\xa4\x01\x6d\xd8\x1a\x8b\x23\x30\x43\xa1\x6b\xe0\xb1\x4b\xff\xed\xa9\x6a\xa7\x56\x20\xf4\x0c\xb7\xdc\x00\x13\x84\xaa\x30\x70\xc7\xcd\xc6\x0a\x55\xa2\xf6\xc4\x57\x37\x05\xa9\x60\xc7\x04\xcf\x69\x29\x4b\xfb\xf6\x45\xfc\x51\x8b\x2e\x29\x75\x34\x1a\x42\xcc\xa8\x0a\xd3\x11\xcb\x73\xd4\x7a\xc2\xca\x32\x69\x53\xac\x81\xe9\x70\x56\x15\xdc\xc0\xfd\x68\x04\x00\xe0\xcb\x96\x68\xe0\xac\xd8\x72\xc1\xb5\x51\xcc\x48\x75\x69\xa4\x62\x6b\xfc\xca\xcc\x26\x03\xef\xc3\x4d\xad\xa3\xa0\x0f\xda\xe0\x16\xd8\x31\xee\xb0\x61\x7b\x6c\xec\x6a\x17\x41\xbb\x66\x42\xe4\x1a\x1d\x28\x1a\xf6\x9c\xd9\x25\x6f\x8f\x60\xb7\xbe\x6a\x09\x77\x08\xf8\x3d\x2f\xab\x02\x49\x68\xeb\x52\x3c\xc0\xf9\x40\xd1\xbd\xcd\xb5\xbf\x0c\x8d\xe5\x2a\x81\x3d\x53\xc7\xc9\x45\x93\x8e\x19\xdc\xd7\xef\x19\xfc\x2a\x65\xf9\xd0\x5f\x3f\xcd\xeb\x80\xeb\x64\xfb\xa2\x2e\x6c\x47\x29\x3f\x05\x27\x7e\xe4\x32\x58\xb4\xb8\x5f\x25\x43\x7a\xbe\x86\x46\x7d\x75\xe7\x1b\x26\xd6\x58\x4c\xf4\x46\x56\x65\x61\x05\x9d\x4f\x49\x13\x84\x5e\x15\x50\x42\x50\xef\xc0\xa2\x85\xed\x44\xad\x07\x4e\xb9\xb1\x84\xb2\xb5\xaf\x78\xf2\x37\x44\x4b\x3d\x83\x45\xfd\x7e\x35\x85\x50\xc6\x96\x7c\x06\x8b\x4b\xa3\xb8\x58\xdb\x61\x56\x99\x8d\x54\xfc\x1f\x54\xfe\xc4\x04\xee\xad\x23\xf4\x50\x20\xaa\x08\x18\x21\x9c\x30\x87\xc5\xd5\x28\x98\x24\xaa\x6d\x00\xc4\x3c\xee\x6f\x5a\xa2\x58\x9b\x4d\x30\x95\xc3\x1c\x5e\x34\xbf\xdc\x6d\x78\x89\xc0\xe1\x6d\x4f\x65\xeb\x25\x3d\x54\x32\x5c\x5f\xd4\xc9\x06\xf3\x6e\x99\xa5\xbd\x3c\x5c\x44\x3d\x5a\xf0\xab\x2b\x78\xf7\x0e\x56\xac\xd4\x18\x58\xe0\x2b\xdf\x40\x68\xdd\x8e\xc3\x1c\x38\xfc\x0f\x5e\xf6\x46\x28\xbe\x5c\x54\xa1\xba\x87\x51\xcf\xff\xba\xe3\xcc\x07\xdb\x5e\xca\xf5\xa5\x95\x99\xb0\x63\x05\x0d\x2d\x62\x6a\xf7\x9b\xac\x9f\x02\x0b\x7e\x95\x74\xd7\xf5\xac\xb6\xdc\x5f\x54\x2c\xf8\x29\xdb\xd1\xc7\xa4\x45\xf8\x07\xdd\x49\x4e\x01\xd3\x87\xd5\x13\xe0\xab\xb8\x87\x2e\xad\xe0\x17\x78\xd1\x59\x13\x5f\xf5\x12\xa3\xd3\x68\x22\x20\xb8\x2d\xe6\xb1\x76\xef\x36\x17\x6f\x87\x74\xbd\xb6\xd9\x2e\xcc\x06\x15\xda\x0d\x89\x36\xab\xe8\xfe\x12\xb3\x4c\x4a\x9d\x8e\x2d\x6a\xcd\xd6\xe8\xd4\x72\xd1\xf4\xe4\x27\xea\x1a\xaa\x65\xd7\x10\x60\x0e\xe3\x71\x74\x8e\xa8\xb6\xb1\x7e\x08\xf3\x53\xd0\x47\x35\xdd\x04\x95\x7d\x7c\x5c\x85\xdf\xb8\x0a\x8f\x5a\xea\x47\xa4\x0e\xe5\x4d\x24\xc2\xfe\x73\x72\xb9\xc3\x83\x69\x2e\x45\xce\xcc\x64\x3c\x85\x71\x12\x55\xfe\x10\xfd\xf5\x07\xcd\xc5\x24\x16\x37\x57\xa9\x91\x4e\x6e\x92\x24\xa3\xa8\x5d\xc2\xf5\x26\xda\x79\x1e\xfa\x13\xea\x94\xf2\xf2\x54\xbb\x8c\x5a\x31\x5e\x3a\xfe\xc3\x9a\x54\xb3\x94\xa1\x94\xf2\x56\x43\xc9\x6f\xe9\x9b\xeb\x0c\x96\xa8\x94\x54\x99\x4b\xcb\x0c\x3e\xc8\x4a\x14\xf1\x24\xcc\xe0\x2c\x7d\x95\x23\xc3\x37\xff\x7f\x83\xc5\x4b\xf6\x1a\x5f\xb3\x74\xa8\xbb\x4d\x63\xc2\x9d\x6a\x5d\xf6\xd6\x63\x9d\x98\x8c\x2d\x8d\xf7\x8b\xcf\xd2\x78\x82\x3e\x24\xb5\x2d\xc5\x5c\x49\x05\xe7\x0a\x75\x8e\xa2\x90\x50\xed\xd6\x8a\x15\x44\x97\xb6\x34\x49\x4b\x29\x9e\xc1\x47\x64\x4a\xc0\x56\x2a\xcc\x60\x63\xcc\x4e\x67\xb3\xd9\x35\x37\x69\x79\x98\x7d\xf8\xf8\xe5\xaf\xf3\xdf\x2f\x2e\xcf\x2f\x3e\xbf\xff\x92\xc2\xfb\xb8\x91\x0c\xc6\xa7\xa2\xeb\xe2\xda\xed\x7f\x80\xa5\xc6\x48\x56\x5b\xa6\xfa\x04\xa6\x13\xb3\xd4\x6d\xb1\xe1\xdb\x43\xc0\x23\x03\xe6\x09\x0a\xb5\x54\x39\x42\xce\x04\x71\x46\x7b\x34\x32\x92\x58\x26\xd8\xd1\xad\xdc\xa3\xc7\x39\x1b\x9e\xd3\xdb\x6f\xa1\xe0\x36\x32\x4c\x1d\x6a\x6b\x3d\x12\x46\xb6\x2a\x32\x16\xba\xd0\x42\x41\x67\xa1\xa2\xb8\xe8\xa9\x26\x6f\xc8\x68\xeb\x07\x35\xe5\xa7\x78\xd1\x75\x81\xe8\x56\xcc\xc4\x84\x45\x38\x56\xd2\x89\x12\xa5\x54\x2d\x47\x27\x98\xd6\x9b\x7e\x30\x1f\xa7\x27\xf5\x6c\x62\x57\xb4\xbd\x0c\x06\xd0\x07\xc7\x85\xa3\x8f\x4f\x1d\xa6\x10\xa2\xa7\x87\x2a\x06\xd2\x80\xa9\x9f\x8e\x53\xea\x1c\x99\xdc\xe2\x21\x3b\x6a\x1a\xce\x76\x1f\x2c\x8d\xe6\x04\xdf\xa7\x61\xed\x4e\xfc\xbd\x8d\x7f\xcf\x14\x67\xd7\x25\x1e\xb3\x6c\xcf\xca\x0a\xe9\xfc\xb9\xf4\x4e\x07\xcb\x41\xe8\x4e\x1b\x8e\x9c\x30\x3a\xb8\x3c\xc6\x60\xe6\xe0\xa9\x08\x66\xda\x16\xf2\x5f\x0f\x39\xde\x47\x32\x00\xa5\x41\x6d\xce\x63\xa7\x1f\xdb\x2e\x28\xdc\x24\x41\x8d\x75\x57\xa9\x9d\xd4\x1e\x3d\x21\x72\x55\x1f\x4b\xf3\xe3\x3d\xc4\x23\xf7\x09\xf5\x11\x7d\xa7\xe4\x9e\x17\x43\xb4\x67\x36\x8b\xaa\xe1\x1a\x24\x31\xb1\x3b\xae\xdd\xcd\x00\x19\xb5\xb1\x6c\xca\x41\x56\x46\xf3\x02\x07\xc3\x17\x5d\xec\xcf\x3a\x91\xd1\xa3\xd0\x54\x4a\xf4\xd2\xa0\x7f\x4a\x8c\x7a\x34\xed\x3b\x31\xf5\x0d\x27\xf1\xcd\xc1\x47\x41\x1b\x55\x05\x37\x19\x9e\x83\xdd\x7b\x8c\xe6\x68\x50\x3b\x30\x28\xe8\x0e\x08\x0e\x0c\x8f\xe1\x0b\x6e\x26\x5d\x1d\xd3\x40\xb8\x0b\x8f\xc6\x72\x95\x1e\xdb\xcb\xfc\xe8\x40\x5f\xc4\x5e\xc8\xcd\xad\xaa\x58\x5a\xf7\xc2\xde\xd0\xb0\xa3\xe1\x8e\x5d\xa2\xb8\xb5\xb1\x86\xf5\xf9\xbe\x78\x44\x2e\x98\xd7\xf4\x6d\x78\xf1\x1d\x76\x0a\x57\xfc\x7b\x30\xde\xd5\x19\x7c\xa7\xba\xe4\x39\x4e\x28\x79\x33\x78\x35\x85\x6a\xf7\x4d\x66\x1d\x11\x47\xc9\x93\x58\x0e\x8d\xcf\xd2\x86\xa1\x04\x93\x92\x86\x04\xa7\xe3\xe6\xbd\x81\x6d\x20\x47\x6a\x02\xc1\x68\xf7\x6e\x37\x73\x3a\x26\xb1\xbd\xa3\x0d\xf6\x36\xd4\xdd\x5f\x81\x96\xf5\xa5\x62\x33\xa5\xe6\x18\x0e\xf9\xf6\x0a\x56\xbb\xeb\x12\xa8\xef\x44\x7c\x53\xcb\xde\x7e\xd0\xde\x6a\x86\xbb\x5d\xd3\x36\xea\x6b\xb2\xe6\x5e\x2c\x1d\x35\x79\x16\xb9\xab\x8a\x16\xa1\xc5\xa1\xbf\x6b\xce\xe1\xfe\x21\x94\xe9\x77\x66\x77\xaf\x10\x4a\x0d\x5d\xf5\xc1\x1c\x66\x35\x58\xb3\x55\x29\xef\x3a\x05\x6f\xa7\xb5\xaa\x3a\x9b\x6a\xdf\xbd\x48\x95\x3c\x9d\x75\x78\x85\xe1\xaa\x9a\xe2\xf5\xf6\x39\xe4\x0a\x99\xe9\x10\x36\x2f\xbf\x5d\xfe\xbb\xb8\xa5\xf5\x5a\x52\xca\x86\xc9\xdb\xe7\x56\xc7\x14\x8c\xcc\x4e\xc3\x90\xd4\x29\xf6\x30\xfa\x37\x00\x00\xff\xff\xa1\x1e\x0f\x3b\xd2\x17\x00\x00" + +func dependencyauditCdcBytes() ([]byte, error) { + return bindataRead( + _dependencyauditCdc, + "DependencyAudit.cdc", + ) +} + +func dependencyauditCdc() (*asset, error) { + bytes, err := dependencyauditCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "DependencyAudit.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbd, 0xab, 0xe2, 0x21, 0xa8, 0xaf, 0xb2, 0x59, 0x7e, 0x4f, 0xf3, 0xbe, 0x36, 0x9e, 0x17, 0xa2, 0x8b, 0x4d, 0x59, 0x42, 0xe1, 0xde, 0xd2, 0x9f, 0xa7, 0xec, 0x5a, 0xfd, 0xef, 0x9e, 0x29, 0x45}} + return a, nil +} + +var _migrationcontractstagingCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x3c\xcb\x6e\x5b\xc9\x95\x7b\x7f\xc5\x11\x17\x36\x39\xa0\xa8\x4e\x63\x30\x0b\xc1\x8c\x5b\x91\xdd\xd3\x5e\xd8\x6d\x58\x72\xb2\x30\x8c\x4e\xe9\xde\x43\xb2\xe0\xcb\x2a\xa2\xaa\xae\x68\x8d\xe3\x7d\xbe\x73\xbe\x24\xa8\xf7\xe3\xde\x22\x69\x75\xa3\x89\x24\xb6\xc9\x7a\x9c\x73\xea\xbc\x1f\xb9\xb8\xb8\x80\xdb\x0d\x95\xd0\x70\xa6\x04\x69\x14\x50\x09\x94\x29\x64\x2d\xb6\xb0\xe2\x02\x7a\x89\x40\x19\xa8\x0d\xc2\x35\x69\x91\x35\x08\x7f\x59\xfc\x10\xd7\x6f\xe9\x5a\x10\x45\x39\x03\xd2\x08\x2e\xa5\x59\xf9\x73\xc7\xf7\xc0\x50\xed\xb9\xf8\xbc\x78\x72\x71\x71\xa1\xff\x0b\xaf\x19\xec\x04\xee\x88\x5b\xaf\x4f\x57\xfa\xee\x2d\xed\x50\x2a\xce\x70\x0e\x0f\xbc\x17\xf1\xec\x3d\xed\x3a\x78\xfb\xea\xd5\x4b\x50\x1c\xee\x10\xfa\x5d\x4b\x14\xb6\x67\xf0\xab\x06\xe3\x81\xf7\xcf\xee\xc3\x97\x7e\x6b\x8b\xfa\x60\x73\x5f\x02\xaf\x39\x19\xde\x7c\xb8\xb9\x05\xa9\xc8\x1a\x8b\x8b\xcc\x36\x83\x65\x4a\x0a\xc9\x41\x6d\x88\x32\x18\xd9\x5b\xa0\x21\x4c\x03\x82\x5f\xb0\xe9\xf5\xa5\x44\x02\x81\x1d\x11\x0a\xf8\x4a\xaf\x33\xf7\x3a\xc4\xcf\xf7\xb4\x45\x7d\x9d\xc2\x48\xa5\x48\x8d\x5b\x3e\x0a\x8a\xbd\xe8\xd2\x2c\xf9\xcb\x02\x1a\x81\x7a\x3f\x81\x5f\xb8\x54\xf0\x14\x24\xb9\x37\x90\x66\x9b\xce\x37\x5c\x2a\xca\xd6\x40\x9a\x86\xf7\x4c\x99\xcd\x3f\x2e\xa0\x21\x5d\x67\x2f\xb9\x76\x2b\xa7\x33\xd8\x11\x29\xcd\x5a\x10\xb8\x42\x61\x28\xa4\xb8\xa1\x8f\xbe\x63\x6e\xd0\x0d\xe0\x30\xb2\xc5\x39\x10\xd6\x26\x54\x68\x03\x65\x35\xdd\x22\x42\x86\x78\x96\x40\x2d\x67\x06\x4c\x02\xfa\xae\x0e\x41\x09\xc2\x24\x69\x34\x09\xce\xe0\x67\x2e\x60\xcb\x85\xdd\x6f\xee\xc2\x2f\x6a\x0e\x12\x11\x36\x4a\xed\xe4\xe5\xc5\xc5\x9a\xaa\x4d\x7f\xb7\x68\xf8\xf6\x82\xb3\x55\xc7\xf7\x17\x01\x59\x0b\x84\x79\xe2\x27\xa4\x69\x50\xca\x29\xe9\xba\x59\x84\xf9\x8d\x27\xb6\xc7\xfa\x46\x91\xb5\x46\xf9\xeb\x93\x27\x00\x00\x17\x17\xf0\x8e\xa8\x8d\xde\x20\x15\x61\x4a\xba\x6f\xcd\x1f\xee\x44\x89\xdd\x6a\x06\x1d\x2a\x68\xb1\xa3\x5b\xaa\x50\x5c\xc2\x8d\x12\x94\xad\xc7\x97\x35\x64\x27\xfb\x0e\xf5\xc1\xef\x04\xae\xe8\x97\xb1\xe5\x06\x4e\xbd\x5a\x53\xfa\x46\x71\x41\xd6\x66\x87\x5e\x1b\xfe\x31\xba\xe1\xaa\xdd\x52\x76\x70\x87\x7e\x82\x37\x64\x97\xf0\x2f\x69\x5b\x81\x52\xa2\xd4\xef\x4b\x18\x10\x21\xc8\x83\x66\x54\xc3\x12\x6d\xfe\xc8\x72\x1c\x2d\xbb\xd4\x13\x52\x5e\xc2\xd7\x2b\x7b\xea\x25\x7c\xb4\xf8\x7d\xfa\x16\xae\xbf\xdd\x20\xdc\x75\xbc\xf9\x0c\x1b\xa4\xeb\x8d\x02\xa2\x60\xbf\xa1\xcd\xc6\x31\x8e\x65\x0f\xc6\xf5\x7f\x3a\xce\xd6\x28\x34\xaf\xd8\x2b\x16\xf0\x7a\x05\x8c\x76\xf3\x6c\x6d\xf8\x19\x28\x6b\x71\x45\x19\x55\xd8\x3d\x40\xcf\x14\xed\xc2\xb5\x86\x61\x7b\xc5\x57\x2b\xb8\x27\x5d\x8f\x5a\x87\x49\x54\x8b\x21\x46\xf7\x44\x98\xf3\x28\x5b\x5f\x9b\x0d\x97\xf0\xe1\x35\x53\xff\xf3\xdf\x2f\xc2\x61\xef\x51\xf6\x9d\x92\x4e\x9e\xa1\x23\x52\x01\x6e\xfb\xce\xf0\xfd\x50\xeb\xcd\xa1\xe1\xdb\x2d\x55\xfa\xd7\xbb\x07\xb3\x85\xe8\xa7\x02\xb2\x52\x28\x80\xaf\x56\xcd\x86\x50\x36\xb2\x73\xf0\xcc\x1a\x38\x7d\xdd\x2b\x77\x5b\x60\x63\x0b\xd2\x25\x54\x7e\x78\xf1\x24\x00\xff\xea\x1e\x99\x06\xd7\xc2\xb3\xdf\xa0\x96\x40\x7f\xf5\x33\xe9\xf4\x9c\x74\x34\x9d\x83\xc0\x5d\x47\x1a\x6c\x41\x2b\x7a\x66\xbf\x0d\x87\xfd\xd3\x8a\xeb\x3f\xe1\xff\xff\xfd\x6f\xf8\x3a\x31\xbf\x4e\xe6\x30\x71\x9b\xf4\x5f\xdd\x9e\xc9\x37\x40\xd2\x6c\xa0\x45\xc6\x8d\x1e\x32\x64\x30\xbb\xe1\x0e\xcd\x17\xe4\x33\x32\xe0\xd6\x8e\x14\xec\x17\x2e\x7c\xfb\xeb\xed\xab\x4b\x78\xc9\x51\x02\xe3\x0a\xd6\x3d\x11\x84\x29\xc4\xa8\x85\x0b\x85\x2d\xf5\x7b\xd3\xa0\x8e\x06\x14\x45\x43\x0e\x27\xfd\x37\x8a\xa8\x5e\x7e\xb0\x1a\x6c\x6a\xd6\xea\x8f\x93\xdb\x0f\x1f\x5e\xbf\xf4\xcc\x30\x0f\x3f\x12\xcf\xeb\x8e\xe9\xe3\x2f\x1a\x00\x2f\xe1\xe9\xb7\x16\xbe\xd7\x2d\x32\x45\x57\x34\x2a\x8d\xe4\x4c\x43\x97\x4c\x3b\xcc\xe2\x03\xa6\x4f\x77\x80\xed\x24\x6c\xb4\x21\xb8\x43\xd4\xac\xb5\xdd\x75\xa8\xf4\x7b\xee\x37\x28\x10\x56\x84\x76\x89\xcc\x02\x11\x68\x44\xdc\x73\x28\x15\xe1\xbe\x68\xf6\x03\xc4\x70\x0e\x57\x8b\xab\x97\x2f\xdf\xbf\xba\xb9\x59\xbc\xbd\x7a\xf3\xca\x9d\xea\xbe\xd2\x54\xd7\x4f\xa1\x4d\x8e\xa7\x0f\xec\xa9\xda\xf0\x5e\xc1\x0f\x5f\x2a\x6f\x50\x61\xdd\x6b\x2f\x3b\xf1\x3d\x24\x23\x3b\xb9\xe1\xea\x96\x6e\x51\x2a\xb2\xdd\x5d\xc2\x87\x9f\xe9\x97\xf4\x55\x82\xc4\x1d\x58\x53\xd0\x20\x6a\xab\x43\x04\xf7\xcc\x19\xd4\x43\xd4\x27\xce\xf2\x1d\x66\x31\xbb\xc9\xb3\x18\xef\xda\xa0\x5e\xe6\xc0\x70\x1f\xfe\x35\x7b\xe2\x44\xf6\xbf\x46\x3e\x01\x85\x77\xfd\x5d\x47\x1b\x78\x83\x6a\xc3\x5b\xab\x9e\x61\x6c\xc3\x85\x3f\x0c\xce\xcf\xcf\x3d\x28\x7e\x9b\xf9\x2e\x2c\xd1\x3e\x05\x9c\xc3\xb5\x77\x2a\xec\x23\xb2\xd6\xb9\x15\xea\xa8\x67\xa1\x35\x7a\xcd\xbc\x2e\x0a\xa3\xe6\xaf\x0c\x57\xdb\x6b\xa5\x77\x66\x24\x8a\x7b\x73\xb4\x0c\xdc\xd7\xa4\x9e\x61\x22\xee\xee\xf6\x05\xbc\x4f\x5d\x16\xe3\xad\x09\x94\xbc\x17\x0d\x46\x0e\x36\xfc\x19\x39\x9c\x74\x9d\xb9\xc5\xb1\xaa\xe4\x1a\xcf\x6d\x2f\x95\x31\x2e\xe4\xde\xd8\x96\x80\x9f\xb4\xf0\xc3\x1d\xae\xb4\x83\x62\xb5\x57\x2f\xb1\xd5\x17\x5a\x7f\x8d\x94\xce\xda\x22\xc3\x34\xe5\x8e\x55\xcf\x9c\x07\xa7\x31\x9e\xce\x2e\xe1\x27\x83\xfa\xd7\xf0\xc8\x02\x55\x2f\x18\x3c\x3f\xf7\x9e\x9e\x5d\x68\x7e\xff\x16\x5f\xed\x47\xfd\x6a\x63\xde\x9c\x96\xbc\x28\x8f\xd1\xa3\xd3\x8f\x9a\xd9\xf7\xfc\x1b\xa3\x3f\xb5\xcb\xb7\xa7\x72\x13\x50\x1b\xbc\x98\x7e\x59\x4b\xcf\x62\xab\x7f\xa1\x35\xbd\x47\x56\x5e\xa4\x06\x0a\xc2\x18\xf7\xec\x14\x2a\x81\x74\x02\x49\xfb\xe0\x8d\x51\x6e\xce\xf5\x25\xc6\xfd\xbf\xc3\x60\xa5\x16\x85\xa5\xd8\x92\xcf\xe6\x75\x9c\xbf\xe0\xb1\x68\xed\x6e\x81\x12\x95\xb3\x10\x96\xad\xa4\xb1\x00\x0e\x76\xa2\x02\x30\x87\xdf\x2f\xa7\xb8\xc6\xea\x12\x9e\x5a\x4f\x59\xa3\x1b\x14\x7c\x66\x12\x66\xc9\x13\xef\x04\x26\xff\x32\x3a\x0e\xbb\xd5\x82\x4a\x27\x37\xef\x50\x50\xde\x5e\x35\x8a\xde\xa3\x66\x91\x89\x17\xe1\x9d\xf9\x01\x36\x44\x82\x89\xc7\x26\xe1\x90\x6f\xe1\x6f\x85\xeb\x09\x4b\x7b\x78\x8b\x82\xde\xe3\xb5\xfd\x21\x91\xc9\xa9\xc7\x39\x78\x71\x1a\xa1\x85\x7b\xa6\xe9\x6c\x1e\x88\xf2\xd6\xe0\xa6\x31\x9c\x85\xcb\xe8\xca\x9e\x5e\x38\x85\x1f\xf3\x33\x3e\xc1\x72\xa9\x3d\xb9\x02\xe9\x8b\x0b\xf8\x99\x0a\xa9\x40\xd1\x2d\xc2\x1e\x9f\x09\xd4\x1e\xbf\x46\xb4\x09\xa6\x6a\x25\xf8\xd6\xca\xb5\x97\xd7\x73\xa0\x4c\xa2\x50\xce\xb5\xb2\x5f\x0e\xb8\x7b\x48\xde\x02\xc6\x85\x3d\x65\xfa\x19\x1f\x86\x38\x7f\xd4\x47\x7c\x9a\x95\xe0\x06\x35\xc9\x70\x0f\x8e\x96\x96\xcb\xb4\x6a\xc8\x3c\x99\x36\x87\x20\x79\x15\x2d\xda\x06\x20\x2b\xdf\xee\x18\xc7\x47\x9b\x84\x8d\x6c\xa4\x65\x99\x48\xff\xef\x6c\x88\x93\x57\x83\x4e\x49\x2d\xb4\xf6\x9a\x3e\x3f\x77\x37\xcd\x41\xf1\xcb\x94\x19\xf2\x13\xac\xa6\x19\x61\xa1\x8b\x0b\xf8\x07\xea\x48\x5a\x62\x22\xcb\xe9\x5b\x64\xb6\xde\x69\xc6\x73\x68\x36\xd8\x7c\xd6\x3c\x71\x58\xb0\x53\xee\x31\x74\xf1\x3e\x12\x6b\xf1\x8b\xe7\xd7\x23\x1c\x75\xb6\x58\x69\xd6\x31\x5b\xa6\x7c\xe5\xf8\x72\xc8\x60\xb7\x07\x21\x81\x73\xaf\x4a\x82\x8e\xa9\xbe\xda\x72\x9c\xe2\x77\x5c\x08\xbe\x7f\xfe\xd4\x3d\xe3\x5f\xa7\x9a\x48\x07\x88\xae\x3f\x2f\x5e\xc0\x8e\x30\xda\x4c\x27\xd7\xbc\xef\x5a\xe3\xdb\xda\x73\x00\xbf\x50\x6b\x5e\x3d\x77\x19\x9a\x7b\x1b\xa4\x15\x55\xe1\x2b\x4f\xf2\xe3\xdd\xbd\x0b\x87\xd6\x35\x6f\x71\x5a\xe3\xa0\x43\xef\x9f\x08\xa6\xf3\x7f\x8a\x54\xc8\xb9\x7e\xfe\x61\x66\xc0\x5a\x61\x84\x8e\x4a\x93\x01\x89\xcc\xe3\xe0\xd6\x28\xe8\xb7\x7c\x72\x48\x36\x87\xaf\x4d\x76\x3b\x64\xed\x34\xd7\x3e\x87\x44\xe0\x71\x12\x56\x91\x98\xc4\xee\xbe\xc7\x2d\xbf\x77\x16\xb0\x8c\x9a\xad\x21\xb4\x42\x12\xe9\x86\xec\x9e\x0a\xce\xb6\xc8\x8e\xd8\x15\x17\x3b\x1d\xb7\x2c\x7f\x9a\x2d\xd9\xe5\xae\x89\xfe\x9c\x25\xc7\x63\x3b\x25\x35\xab\x11\x09\xac\x2f\xbd\x4e\x44\x50\x2a\xea\xdd\x96\xaa\x01\xf3\xaa\x65\x59\x9c\x7b\xd4\xf0\xb8\x95\x15\x8b\x53\xe5\xf8\x44\xd0\x75\xdc\xe7\x85\x5d\x98\xc7\xbe\xc9\xee\x88\x28\xbb\xbf\x64\xb8\x3e\x19\x97\xf3\x77\x82\xdf\x75\xb8\x85\x16\xa5\x12\xfc\x21\x3a\x29\x5e\xce\x13\x31\xd6\xc1\xfa\x91\x10\x15\xca\x30\x35\xf9\xc7\x3c\x5b\x35\x00\x36\x3f\xc3\x70\xfe\x64\x52\x7e\x3b\x8c\x59\x8d\xa4\xe4\x27\xbb\xa8\x35\x84\xfc\xe1\xd7\x5c\x66\x6c\x10\xe2\x42\x97\xff\x45\xa5\x50\x0c\x63\x90\xf7\xe6\x61\x64\x4c\xb0\x1c\x4f\x1a\x85\x44\x50\x55\xa6\xee\x29\xee\x8d\x60\xad\x51\x65\xf1\x98\x96\x03\x17\x78\x0d\x1d\xef\xc0\x56\x61\xf9\x50\x05\x58\x60\xf7\x1b\x54\x1b\x14\x99\xb0\x3b\xa9\xd2\x9a\xb2\x17\x02\x99\xea\x1e\x0c\xa5\xee\xf1\x38\x98\x55\x99\xfd\x1b\xe7\xdd\x29\x80\x7a\xa6\xff\xd7\xbf\x34\xca\xd7\x16\x80\xbf\x69\x4a\x4e\x67\x0b\x47\xcb\xe7\xcb\x91\x8d\x67\x35\x14\x95\xd0\xc1\xee\xd0\xa0\x47\xe4\x5c\xae\xee\x54\xec\x52\x95\x71\x95\xcb\x8f\xd3\x6d\x47\xd1\x1d\x13\xf7\x17\x0b\x0d\x1d\xa1\x4c\x5a\x13\xa1\x45\x6f\x45\x3a\x89\x8f\x47\xcc\x85\x09\xd8\x1a\xdf\x52\x93\x95\xae\x80\xaa\x67\x36\x15\xf5\x1d\x68\xff\xdd\x1f\x74\x1a\xe6\x35\x96\x74\x4c\x1c\xb1\xb7\x5a\xe1\xb0\x3a\x7a\xb1\x48\xef\x37\x64\x61\x2e\x4f\x3a\x46\x94\x8d\x4d\x0b\x99\x5c\x67\x88\x2d\xdb\xd4\x03\xcc\xa2\x3c\x1f\xcb\x9d\x2c\x81\x11\x78\x1d\x4c\xc8\xe9\x8a\x8b\xab\x82\x26\xb3\x98\x98\x39\x91\x07\xe2\x21\x9f\x34\x7e\x1f\x3f\x1d\x42\xaf\x34\xd9\x69\xdd\x62\x1c\x3b\xfb\xfc\x64\x7b\x20\xa8\xaf\xa3\x69\xfc\xaf\xa3\xcf\x6e\xff\xf2\x07\x3f\x7c\x70\x66\x2b\x94\xc8\x4f\x03\xa9\x44\xdf\xa8\x5a\x18\xef\x59\xdf\xa4\x17\x4f\xe6\xfd\xa3\x90\xd7\x08\x92\xaf\x4f\x09\xf3\xbb\xa3\xdb\x40\xac\x23\x61\xed\x1f\xe3\xfa\x8f\xfa\x1f\xc1\x49\xd7\x4a\x3a\xa7\x4c\x04\xe1\x1b\x60\x27\x4b\xd7\xce\xed\xf7\x22\x0c\xc1\x87\x19\x79\xe3\xb4\xbc\x33\x22\xcb\x59\x08\x87\x27\xca\xf0\x55\xd7\xe5\x0f\xaa\x7d\x53\xa9\x4d\xd4\xc7\x20\x82\x27\x09\xed\xe2\x33\x3e\xc8\x2a\xe4\xd0\x52\xe3\x5c\x10\x51\x85\xbe\x2e\xaf\x8f\xc4\xc4\x48\xea\xb8\x3e\xfa\x6a\xf9\xd2\xf3\xe7\xb7\x92\x1d\x53\x95\x56\x0b\x5f\x13\x25\x95\x72\x59\xb1\xb7\xee\xb3\xc2\xd7\x6f\x15\xb7\xd5\xdf\xa4\x3d\xb9\x01\xa4\xcb\x74\x9f\x26\x97\x89\xd1\x92\xea\x93\xb9\xf8\xac\xb8\xd2\xb1\xbf\xf3\x50\x97\x27\xaa\xa1\x88\x62\xa6\x89\x8a\xb3\xf5\x27\x82\xfc\xd1\xe5\x4b\x4d\xba\x05\x96\x3e\x7d\x3a\x08\xc4\xc7\x90\xf7\xec\x15\x0e\xab\xf2\xd3\x98\x25\x33\x75\xfa\x2d\xd9\xed\xb4\xd7\xa6\x99\xcc\x69\xfb\xa2\x30\x3a\x52\x11\xfd\x6e\xd6\x32\x02\x32\x52\x25\x3d\x4d\x54\xea\x52\x92\xe8\xb9\x3c\x09\xe5\x73\x07\xae\x62\xb9\xe2\x62\x7b\x19\xf6\x9b\x3f\x9d\x0a\xbb\xb0\x51\x72\x59\xa8\xfe\xcd\x55\x76\x7e\x7b\x7b\xf5\xe6\x55\x1d\xd7\xd3\x95\xee\xd5\xb8\xd2\x4d\x0c\x60\xc4\x24\x17\xae\xa4\x0a\xe5\xf8\x70\x00\x6d\xc6\x28\xda\x0f\x6c\x88\x9a\x3a\xab\xe0\x0a\xf5\xb3\xd1\x35\x05\x98\x0b\xc5\x2d\x40\xd3\xd9\xf8\xfa\xef\x39\xf3\x6d\x66\x4f\xdc\xf3\xa6\x34\xa2\x49\x70\x15\xff\x5e\x8b\x1f\x63\x9e\xc8\x12\x3d\x3c\x71\x4a\x39\x2d\xdf\x99\x2a\x9c\x8c\x44\x62\x7f\xda\x47\xc7\x77\x8f\xbc\x56\xdb\x7f\xeb\x8f\xc8\xef\xdf\xfb\xf8\x6b\x7f\xcf\xc7\x44\xb3\xee\xe2\xc3\x9f\xf0\xc2\x95\x0a\xa8\xfd\xfd\xc8\x21\x59\xe8\xbc\x13\x28\x91\x29\xeb\xd6\x89\xd8\xad\x40\x0e\x16\x8c\xad\x30\x12\xca\x7c\x79\x5e\x2a\x22\x14\x3c\x4d\xda\x17\x4c\xfa\x4f\xbb\xbf\x84\x3d\xb8\xfa\x69\xb8\x36\x57\x8c\xa6\x9c\x93\x94\xc1\xf6\x24\x24\xfc\x5c\x0f\x84\x3d\x3d\x9c\x48\x6d\x18\xd5\x51\xa9\x6c\xb9\xad\x28\xcf\xce\x81\x2a\x59\xb4\x46\xd8\xe2\x9d\x89\xfc\x1b\xce\x24\x6d\x51\x60\x0b\xb2\x37\xba\x69\xd5\x77\x55\xed\xec\x7c\xdb\x0a\xc1\x13\x8d\x63\x5a\x56\x7c\x09\x39\x36\x19\xc4\x8e\x36\x5f\x8b\x36\x08\x9a\x16\x86\xb0\xb7\xec\xcf\xf1\x4b\x7d\x25\xfa\xf4\x4b\xfc\x13\xee\xd1\x34\x44\xb9\xd7\xa8\x5e\x14\x56\x8c\xde\x14\x93\x38\xa1\x83\x25\x1a\x41\x73\xb9\xa5\x7c\x5a\x16\x6b\x7b\xe1\x99\x22\x30\x50\xfe\x14\x63\x70\xd4\x0b\xec\xd1\xe3\x61\x54\x4d\x4b\xc2\xcc\xeb\x3b\x4b\xe7\x61\x24\x1f\x09\x21\x85\xec\x9f\xe6\xb9\xb3\x13\x91\x2c\x93\x1b\xff\x9b\xaf\xf2\xba\xfe\xc5\x1d\x91\x6a\x52\x71\x34\x86\x07\x2f\xc3\x9b\x0e\x17\x45\xa1\x59\x8e\xe4\x5e\x94\x7f\xee\xe1\xc6\xb2\x35\x63\x59\x52\xa3\xe2\xe9\x1f\x54\x2d\xb9\x8b\x56\xd7\x28\xe3\x6a\x24\x16\xd9\xb5\xa0\x9a\x2f\x84\x40\xb9\xe3\xac\xb5\xb5\xb9\xf6\x40\x2c\xec\x64\xad\x88\x2e\x73\x11\x73\x06\xb7\xe4\xc7\xbc\x2e\x50\xb2\x57\x19\x34\x66\x27\x6a\x73\x5b\x1e\x57\x3d\x29\x0d\x36\x73\xa9\x1c\x69\x68\xb4\xad\xad\x89\x3b\x5a\x36\x68\xa5\x45\xde\xaa\x8c\xfb\xfa\x35\x91\x36\xbd\x99\x36\x8f\x8c\x1d\xaa\x17\xb9\xac\x6f\x90\xea\x5c\x8a\x0e\xc7\xd0\xf5\xda\x73\x60\xbc\x98\x62\x27\x05\x41\xc3\x12\x13\x2c\x2c\x2b\xe5\x54\x83\xd0\x72\x58\x33\x33\x3f\x26\xf0\x9f\x28\x10\xdf\x9e\x64\xc4\xf3\x49\x2b\x19\x15\xa4\x6d\x58\x0a\xcc\x62\x2a\x65\xd2\xf7\x16\x28\x22\xd6\x91\x49\x16\xe9\x59\xe3\x44\xf6\x4e\xac\x3d\x66\x24\xcb\x0a\xd1\x6f\xd3\x4e\xbd\x8d\xfd\xa7\x29\xe9\x66\x8b\xa0\x49\x17\xd6\x0a\x86\x24\x64\x20\xdf\xac\x86\xe0\x0d\x0a\x4a\x3a\xfa\x7f\xae\x94\x54\x26\x9b\x80\x32\x1d\x89\x68\x71\x72\x01\x8a\xf7\xe4\xe1\x87\x2f\x69\x2f\xd6\xe9\x98\x46\xf7\xd6\xf3\xc5\x38\xb6\x29\x8a\x89\x4f\xec\x3d\xdc\xc9\x62\x32\xcb\x3c\xe2\x53\xd1\x34\xc4\x69\x94\xc5\x8c\x9a\x8a\xa0\x01\x22\x71\xf1\x53\x34\x8f\xb5\x9c\x75\xa4\xf9\x2c\x7d\x7f\xd9\x49\x04\x88\x17\x55\x49\x60\x0c\x37\x61\xf2\x87\x50\x87\x1e\x21\x84\xec\x68\x83\x2e\xd9\xf3\xe3\x1c\xfa\xdd\x2d\xbf\xac\x2e\xee\x90\xad\xcb\x1a\xb0\xbe\x65\x67\x62\x17\x58\xc2\xe4\x6a\x32\x4a\x5a\x03\x45\x46\xf5\xb1\xc7\xb2\xc7\x9c\xfe\x1e\xc3\xda\x45\x5a\xd4\x75\x11\xff\x8e\x48\xd3\xdf\x34\xe8\x76\x4d\x9c\x47\xef\x2e\x38\x3f\xc1\x71\xbe\x6b\x7d\x58\xe4\xca\xd9\xf4\xe6\x98\x74\x3c\x34\x26\x90\xd9\x22\x61\xa9\xc3\xb1\x21\x92\x3d\xd3\x86\x79\xdd\xb3\x79\xa6\x2e\xf5\xd7\x94\x35\x5d\xdf\x5a\x37\xd1\x82\x62\x20\xe0\x22\x3d\x22\x71\x4f\x4f\x63\x86\x34\x2f\x3e\x2a\xfc\x71\x10\xc2\x69\xee\x88\xa3\x73\x1f\x2a\xc4\x31\x42\xdc\xd2\x56\xc3\xae\xc1\x1a\xcb\xad\x1c\x68\xeb\x85\x65\xbd\xa1\xee\xd0\xb6\xa1\x5f\x94\x0a\x74\xaa\x91\x9f\x1f\xba\x3e\xfa\x3b\x83\xf3\xf4\xe7\xe9\x53\x38\x3b\xb4\xbb\xf0\x5e\x0a\x95\x98\x8a\xe0\xec\x80\xe3\xe5\x20\x8f\x25\x9c\x51\x56\x36\x2d\x0e\xa3\xd9\x6c\xd7\x2d\x66\x3a\xe1\x88\x16\x36\x7e\x4f\x5b\x9f\xb3\xae\xf0\x87\x97\x02\x5b\x8c\x4f\x1b\x28\x7e\x3b\x6e\x4d\xff\x70\x6b\x08\xa7\xfa\x7a\xfa\xf3\x4b\x70\x9c\x8e\x78\x79\x37\x28\xee\x51\x56\x1a\x2c\x89\x69\x8d\x44\xf1\x4c\x0e\x72\xa9\x4e\x86\x6f\x36\x46\x7c\xd3\x36\x49\xdf\x9a\x62\xc2\x44\x43\x48\x90\x64\x85\xeb\x9e\x88\xd6\x8e\xc3\xc4\x16\xc4\xb5\x20\xda\xbf\x74\xcb\x14\x4f\x06\x6b\x1c\x7f\x9b\x30\x72\x18\x63\x9a\x5c\xf5\x9e\xca\x8d\x6d\xea\x6b\xb1\xc3\xb5\x2d\x5a\xb8\xd6\x14\x0e\x84\x71\xa3\xd0\x7c\xdb\xe6\x14\x17\xeb\x05\x6c\xfb\x4e\x51\x49\x63\xb7\xaa\x44\xd5\xef\x00\x19\xb9\xb3\x3d\xa0\xd0\xe2\x3d\x76\x7c\x87\xb1\x03\x3a\xb4\x75\x72\x66\xcc\xd4\x1d\x6e\x48\xb7\x9a\xe9\x88\x14\xa4\x25\x40\x98\xc1\x79\xf7\xfe\xf5\xdf\xaf\x6e\x5f\xd9\xf6\xd5\x86\xec\xc8\x1d\xed\xa8\x7a\x30\xd4\xd8\xf5\x77\x1d\x95\x1b\xbd\xcd\x35\xc5\x08\x6c\x90\xde\x27\xcd\xb3\x75\x37\x3a\x34\xb1\x16\xdd\xa1\x65\x15\x27\xac\xe3\x7b\x96\xbe\xdc\xe9\x8a\x30\xf4\x56\x04\x57\xf2\x80\x5b\x60\x6e\x79\x11\x7c\xc7\x98\xa0\x32\x60\x52\x09\x3d\xd3\x4b\xda\xb3\xc9\xec\xb1\xbc\xec\x32\x5b\x27\x06\x2d\x0e\x7b\x23\xe5\x26\x01\x2a\x61\x87\x3e\x4e\xc9\xac\x9a\xb4\xd3\x47\xa3\x65\xaf\x05\xfc\xca\x02\x33\x0d\xba\x79\x7d\x9d\x21\x5c\xbb\x0a\xcd\x51\x73\x7d\xa2\x4b\xc5\xf9\xe6\x54\xcb\x1c\xb6\x6c\x6c\x40\x6a\x87\x83\x64\xa1\x7d\xf9\x8a\x3d\xb8\xa4\xc8\xa0\x91\xd7\xcc\x6a\xd1\x90\x73\x86\x2d\x69\x11\xc8\x9a\xd0\xd8\x0e\x2d\xb5\xa7\xe8\x0f\x4d\x0c\x67\x18\xcf\xcb\x21\x0b\x6d\xb3\x70\x25\x4d\xaf\xaf\x44\x9c\x67\x2b\xa9\x84\x2d\x0a\xec\x1e\xc2\xad\x61\xf4\x2f\xcb\x30\xeb\x5b\xe6\x40\x06\xae\x83\x0c\x77\x85\x81\xb8\xbb\x87\x72\xe2\x2d\x9d\x0b\x74\x93\x71\xce\x8d\x0f\xb7\xa6\xd1\x57\x18\x06\x3c\x41\x5a\x3c\x1e\x5f\x07\x71\x5d\x56\x24\x75\xed\xa2\xed\x20\x66\xb4\x8c\xe4\x71\x70\x51\xda\xa2\x14\xa0\x38\x0c\xe5\x66\xf3\xca\x80\x3b\x0f\xd5\xc6\x17\x0d\x72\x1b\x83\x46\x2e\xfd\x71\x05\x91\x18\xa5\x4c\x6e\x6d\xa4\x13\x20\x6e\xfd\x74\x8c\x59\x73\x34\x9b\x11\x8a\x3a\x7d\x92\x1b\xa8\xfb\x89\x63\x35\x73\x77\x84\x63\x32\xe3\xac\xf3\x55\x55\xb4\x4e\xd7\x44\x23\xe5\xd0\x92\x68\x07\x54\xd3\x31\x7c\x12\x67\x61\xb4\x98\x18\xfa\xe6\x6d\x0a\x7d\x6c\xb0\xf1\x91\xee\xc3\x51\xe7\xc1\x3d\x72\xb9\x27\x77\x90\x4e\x6c\x0b\x83\xb2\x35\xcc\xde\xd0\xd3\x76\x3e\x58\x17\x72\x08\x29\x14\xa3\x8d\x62\x10\x9a\xc5\x8c\xe4\x8f\xfc\x36\x6c\x19\x4b\x0f\x1d\xb6\x8f\x41\xda\x42\xe6\x07\xc8\xb2\x15\x8f\xb6\x20\x66\x32\xf2\x24\xfb\x61\x56\x46\xed\x61\xa6\x9b\x77\x49\x54\x33\x32\xfa\x73\x5c\x07\xd9\x43\xbf\x96\x71\xb0\xcb\xcf\x9f\x34\x0d\x59\x8e\x42\x1e\x95\x21\x33\x96\x50\x76\xb9\x11\xe5\xee\x89\x63\x46\x27\xe9\x1c\x07\x5c\x6c\x26\xb3\x5f\x9c\xc1\x5f\xab\x6d\x65\x97\xa3\xb1\xc2\xe4\x17\x7b\x92\xcf\xba\xea\xe3\xb8\x80\xb5\x31\x90\x66\xe4\x82\xf9\x86\xab\x8c\x2e\x87\x94\x58\x2a\x06\x23\xd3\x55\xd5\xc8\x29\x7b\x4a\x37\x7c\x65\x6f\xcb\xc5\xec\xb4\x03\x60\xe9\x36\xd7\xf4\x8d\x9d\x63\xfb\xce\x92\xcc\x49\xcf\x6c\x33\xcd\x45\xd8\x25\xab\x59\xf5\x7a\x32\xfd\x51\x41\xe6\xb2\x56\x45\x19\x6a\xa1\x08\x91\xff\xdb\x50\x03\x0c\x32\xff\x45\x18\x0f\x99\x1e\x08\xef\x7f\xfa\xf0\x60\x09\x4c\x32\x20\x58\x87\x6a\x6c\x9c\xf0\x31\xd4\x3a\x8b\x65\x81\xdf\x8b\xfa\x71\x15\x18\x75\xe0\x6b\xa6\x50\x30\xd2\x1d\x1f\x14\x4c\x75\x61\x9c\xc5\xf3\x4e\x54\xd0\x68\x85\x69\xfc\xc5\xcf\x08\xe6\xb6\x79\x01\xff\x70\x7e\x93\xf3\x7a\x5d\x6a\xd6\x56\xac\x5b\xd8\x11\xb5\xf1\x9e\xf0\x20\xc4\x7b\x26\xcb\x81\xbb\x51\x6f\xcf\x7a\x5e\x71\x88\x2e\x6f\xed\x3f\x3e\x84\x75\x09\x3f\x0d\x5d\xc4\xac\xd7\xa5\xd6\xdd\x52\xef\x6f\x1f\x1f\xd1\x29\x06\x7e\x5c\xc4\xe8\xe1\xf5\x2e\xa1\xfd\xf3\x0f\xe9\xfd\x1e\xb1\xf1\x35\xe0\xf3\xb3\x2a\x66\xfd\x3b\xbb\xc0\x47\x7b\xc0\x21\x9f\x67\x4c\x22\xbb\xc3\x13\x15\x96\x2c\xcf\xe4\xf8\x14\x8c\x66\x3d\x91\xf8\xa7\xa6\x63\xdf\x39\xf2\xb6\x63\xbf\x8d\x2d\x30\x22\xb6\xee\x86\x1b\x5d\x5e\x71\xc5\x7b\xa6\x63\xa1\x4e\x72\xb7\x4f\x8e\x0c\xb4\x64\xf3\x1c\x69\xa5\xce\x35\x0f\x1d\xe1\xd3\xc3\x23\x04\xb5\x06\xc8\x61\x77\xfa\xc9\x83\x52\xbe\x25\x7a\x7c\x42\xea\x2c\x1c\x78\x64\xb3\x85\x7b\x4a\xd4\x65\x7e\xed\x2c\x31\x52\xee\xe9\x0c\x75\x7c\xee\xe0\x18\xb9\xec\x53\x98\xb1\x13\xc6\x87\x6d\x59\x02\xb7\x69\x80\x9b\x36\x29\xc6\xa0\xea\xc8\xec\xc7\x99\x4b\xba\x6b\x0f\xe6\x87\x31\x7f\xbb\x6c\x46\x74\xb8\x9a\x49\x40\x5f\xdb\x29\x34\x2f\x14\xd1\x86\x1b\xe4\xf0\xf2\x7c\x7c\x26\x24\x61\xf8\x97\x76\xaf\xcc\x22\xef\xa0\x6c\x0f\x68\xcd\x03\xda\xb2\x26\x14\x31\xab\x65\xce\x34\x17\x27\xe2\x61\x1f\xc3\x44\x8e\x95\x8e\xde\xc8\xc9\x35\x94\xbf\x93\x87\xff\xec\xe6\x5d\x3f\x6d\x59\x76\xef\x76\x9c\xb4\xcf\x7f\x3a\xbd\x77\x77\x38\x22\x94\x2a\xde\x6c\xa9\xa3\x54\xa6\xf0\x0a\x26\x4a\x4e\xaa\x73\x5a\xd1\xaa\x6f\x92\x09\x29\x58\x79\x43\x1a\x2c\x61\xf2\xdb\x24\xff\xb1\x18\xc0\x87\x65\xd6\x83\x36\xf0\x49\xd2\xa6\xb4\x49\xcd\xe3\xd1\x67\x4e\x2a\x3d\x71\xd9\xd7\x9e\xe2\xc3\xaa\x58\xee\xd2\xcd\x0e\x35\xba\x19\x67\x23\x01\x7a\x52\x8c\xff\x95\xff\x37\x38\xb0\x8c\xdd\x8d\x35\x0c\x92\x00\x31\xe4\xef\xcb\xae\x42\x4d\xcd\xda\x7e\x3f\xb3\x95\x61\xf1\x3d\x5d\x82\x27\x93\x67\x4c\x5d\xe5\x4d\xbd\x63\x53\x40\x59\x83\x78\xa8\x40\xd4\x5d\x7a\xbd\x3c\x5f\x5f\x9b\x2b\xb6\x5e\x8c\xa1\xdf\xd4\x0d\x4b\x8e\xbe\x82\xd7\x79\xdf\x9e\xfc\x27\x00\x00\xff\xff\x90\x8a\xac\x96\x50\x4c\x00\x00" func migrationcontractstagingCdcBytes() ([]byte, error) { return bindataRead( @@ -85,7 +106,7 @@ func migrationcontractstagingCdc() (*asset, error) { } info := bindataFileInfo{name: "MigrationContractStaging.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbe, 0x3d, 0x21, 0xe2, 0xe6, 0x5c, 0xb4, 0x95, 0x6a, 0x0, 0x52, 0x8a, 0x14, 0xb2, 0xa5, 0x69, 0xc3, 0x58, 0x5b, 0x9c, 0x64, 0xbb, 0xb8, 0x27, 0xbf, 0xca, 0x48, 0xe6, 0x22, 0x97, 0x9a, 0xba}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x75, 0x35, 0x6e, 0xdd, 0x1c, 0x7d, 0x26, 0xc9, 0x92, 0xa0, 0x6f, 0x18, 0xd0, 0x94, 0x7b, 0xc5, 0x1e, 0x9a, 0x64, 0xc3, 0xb5, 0xbe, 0x60, 0x53, 0x5e, 0xe2, 0x68, 0x4f, 0xd9, 0xa3, 0xe0, 0x9b}} return a, nil } @@ -180,6 +201,7 @@ func AssetNames() []string { // _bindata is a table, holding each asset generator, mapped to its name. var _bindata = map[string]func() (*asset, error){ + "DependencyAudit.cdc": dependencyauditCdc, "MigrationContractStaging.cdc": migrationcontractstagingCdc, } @@ -229,6 +251,7 @@ type bintree struct { } var _bintree = &bintree{nil, map[string]*bintree{ + "DependencyAudit.cdc": {dependencyauditCdc, map[string]*bintree{}}, "MigrationContractStaging.cdc": {migrationcontractstagingCdc, map[string]*bintree{}}, }} diff --git a/lib/go/templates/internal/assets/assets.go b/lib/go/templates/internal/assets/assets.go index 05aa235..8e7f9ab 100644 --- a/lib/go/templates/internal/assets/assets.go +++ b/lib/go/templates/internal/assets/assets.go @@ -1,6 +1,6 @@ // Code generated by go-bindata. DO NOT EDIT. // sources: -// scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc (610B) +// scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc (690B) // scripts/migration-contract-staging/get_all_staged_contract_code_for_address.cdc (516B) // scripts/migration-contract-staging/get_all_staged_contract_hosts.cdc (455B) // scripts/migration-contract-staging/get_all_staged_contracts.cdc (406B) @@ -10,35 +10,38 @@ // scripts/migration-contract-staging/get_staging_cutoff.cdc (422B) // scripts/migration-contract-staging/is_staged.cdc (431B) // scripts/migration-contract-staging/is_validated.cdc (496B) -// scripts/test/foo.cdc (61B) +// scripts/test/foo.cdc (69B) // scripts/test/get_current_block_height.cdc (70B) // scripts/test/get_current_block_timestamp.cdc (74B) -// scripts/updater/get_block_update_boundary_from_updater.cdc (401B) -// scripts/updater/get_current_deployment_stage.cdc (395B) -// scripts/updater/get_invalid_hosts.cdc (468B) -// scripts/updater/get_updater_deployment_order.cdc (765B) -// scripts/updater/get_updater_deployment_readable.cdc (1.249kB) -// scripts/updater/get_updater_info.cdc (507B) -// scripts/updater/has_been_updated.cdc (385B) -// scripts/util/get_deployment_from_config.cdc (196B) -// transactions/coordinator/set_block_update_boundary.cdc (415B) -// transactions/delegatee/execute_all_delegated_updates.cdc (687B) -// transactions/delegatee/remove_delegated_updaters.cdc (567B) -// transactions/host/publish_host_capability.cdc (2.303kB) -// transactions/migration-contract-staging/admin/commit_migration_results.cdc (809B) -// transactions/migration-contract-staging/admin/set_staging_cutoff.cdc (606B) -// transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc (1.598kB) -// transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc (2.245kB) -// transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc (2.32kB) -// transactions/migration-contract-staging/stage_contract.cdc (1.841kB) -// transactions/migration-contract-staging/unstage_contract.cdc (1.251kB) -// transactions/test/setup_updater_with_empty_deployment.cdc (467B) -// transactions/test/tick_tock.cdc (220B) -// transactions/updater/delegate.cdc (1.938kB) -// transactions/updater/remove_from_delegatee_as_updater.cdc (1.311kB) -// transactions/updater/setup_updater_multi_account.cdc (2.806kB) -// transactions/updater/setup_updater_single_account_and_contract.cdc (2.951kB) -// transactions/updater/update.cdc (385B) +// scripts/updater/get_block_update_boundary_from_updater.cdc (393B) +// scripts/updater/get_current_deployment_stage.cdc (387B) +// scripts/updater/get_invalid_hosts.cdc (460B) +// scripts/updater/get_updater_deployment_order.cdc (801B) +// scripts/updater/get_updater_deployment_readable.cdc (1.313kB) +// scripts/updater/get_updater_info.cdc (501B) +// scripts/updater/has_been_updated.cdc (377B) +// scripts/util/get_deployment_from_config.cdc (204B) +// transactions/coordinator/set_block_update_boundary.cdc (438B) +// transactions/delegatee/execute_all_delegated_updates.cdc (770B) +// transactions/delegatee/remove_delegated_updaters.cdc (634B) +// transactions/dependency-audit/admin/add_excluded_addresses.cdc (364B) +// transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc (375B) +// transactions/dependency-audit/admin/test_check_dependencies.cdc (463B) +// transactions/host/publish_host_capability.cdc (2.951kB) +// transactions/migration-contract-staging/admin/commit_migration_results.cdc (832B) +// transactions/migration-contract-staging/admin/set_staging_cutoff.cdc (629B) +// transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc (1.641kB) +// transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc (2.337kB) +// transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc (2.341kB) +// transactions/migration-contract-staging/stage_contract.cdc (1.891kB) +// transactions/migration-contract-staging/unstage_contract.cdc (1.274kB) +// transactions/test/setup_updater_with_empty_deployment.cdc (637B) +// transactions/test/tick_tock.cdc (217B) +// transactions/updater/delegate.cdc (2.248kB) +// transactions/updater/remove_from_delegatee_as_updater.cdc (1.757kB) +// transactions/updater/setup_updater_multi_account.cdc (2.926kB) +// transactions/updater/setup_updater_single_account_and_contract.cdc (3.991kB) +// transactions/updater/update.cdc (429B) package assets @@ -108,7 +111,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _scriptsDelegateeCheck_delegatee_has_valid_updater_capCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x90\xc1\x6a\xc3\x30\x10\x44\xef\xfe\x8a\xc1\x87\x62\x41\xf1\x07\x98\xa6\xc6\x4d\x2e\xbd\x15\x42\x3f\x40\x91\xd6\xb6\xa8\x2d\x99\xf5\x8a\x1e\x4a\xff\xbd\x90\xd8\x0a\xb8\xa5\xa5\xd1\x45\x42\x3b\x33\xcc\x5b\x37\x4e\x81\x05\xf9\x51\x74\x47\x76\x1f\xbc\xb0\x36\xf2\x3a\x59\x2d\x34\xe7\x59\x36\xc5\x13\xda\xe8\x31\x6a\xe7\x8b\x78\xfe\xe6\xc6\x5a\xa6\x79\xae\xb0\x3c\xee\x61\x69\xa0\x4e\x0b\xd1\x76\xa4\x2a\x3c\x85\x30\xd4\xf8\xc8\x00\x60\x20\xc1\x12\x82\x1d\x3a\x92\x26\x4a\xdf\x18\x13\xa2\x97\x4d\xba\x2a\x4f\x81\x39\xbc\x3f\xdc\xfd\x58\xad\xbc\xdc\xfc\x58\x9c\x83\xd7\xd3\x72\x18\x2b\xfc\xea\x38\x4a\x60\xdd\xd1\x8b\x96\x3e\x59\x15\xea\x1a\x93\xf6\xce\x14\xf9\x3e\xc4\xc1\xc2\x07\xc1\xa5\x00\xcc\x92\x93\x9a\x33\xb5\xc4\xe4\x0d\xe5\x2a\x51\x39\x8b\xdd\x2a\x28\x3b\x92\xe7\x43\xa1\xb2\x34\x4d\xfb\xf9\x4e\xbd\x5d\xdd\x5f\xdc\x87\x55\xff\x0f\xf2\xe4\xb9\x9d\xfd\x4a\xb0\xa5\x67\x92\xc8\xfe\x2a\x28\x4d\x4f\xe6\xad\x70\xb6\x82\xb3\x2a\xfb\xfc\x0a\x00\x00\xff\xff\x0d\x70\xac\x7b\x62\x02\x00\x00" +var _scriptsDelegateeCheck_delegatee_has_valid_updater_capCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x90\xcb\x6a\xf3\x30\x10\x85\xf7\x7e\x8a\xc1\x8b\x20\xc1\x8f\x1f\xc0\xe4\x42\x2e\x9b\x7f\x57\x08\xed\x7e\x2a\x4d\x6c\x51\x45\x0a\xa3\x11\x5d\x94\xbe\x7b\xc1\x17\x05\x4c\x29\x4d\xb5\x91\xe0\xcc\x39\xa3\xf3\xb9\xeb\x2d\xb2\x40\x7d\x16\xec\xc8\x1e\x63\x10\x46\x23\xcf\x37\x8b\x42\xa9\xae\x2a\x34\x86\x52\x52\xe8\xbd\x86\x4b\x0e\x70\x45\x17\x54\x1e\x64\xde\x5b\xcb\x94\x52\x0b\xd3\xe3\x1f\x58\xf2\xd4\xa1\x10\x2d\x25\xdd\xc2\x21\x46\xbf\x83\x8f\x0a\x00\xc0\x93\xc0\x14\x02\x1b\xe8\x48\xf6\x59\xfa\xbd\x31\x31\x07\x59\x63\x96\x5e\x1d\x22\x73\x7c\x7f\x41\x9f\x49\xc3\x6a\x92\xb6\x8b\xcd\xba\x49\x12\x19\x3b\x6a\x5e\x87\xf1\xf5\xea\xdb\x1a\xcd\x78\xf3\x56\x0d\xcb\xe7\x73\xe1\x78\x6d\xe1\x47\xc7\x79\x8c\x7f\x42\xe9\x8b\x55\xc3\x6e\x07\x37\x0c\xce\xa8\xfa\x18\xb3\xb7\x10\xa2\xc0\xf8\x01\x30\x53\x4e\x69\xc7\x74\x21\xa6\x60\xa8\xd6\xa5\xb9\xb3\xb0\x99\x07\x9a\x8e\xe4\xff\x49\xe9\xaa\xa8\x85\xe1\x63\x64\x96\xe8\x7f\xcb\xe6\x34\xfb\x1e\xa0\x53\x3c\x7f\xe7\x73\x6f\xb9\x24\xc4\x24\x99\xc3\x7d\xa0\x31\x3d\x99\x37\xe5\x6c\x0b\xce\xea\xea\xf3\x2b\x00\x00\xff\xff\xdf\xd4\x12\x32\xb2\x02\x00\x00" func scriptsDelegateeCheck_delegatee_has_valid_updater_capCdcBytes() ([]byte, error) { return bindataRead( @@ -124,7 +127,7 @@ func scriptsDelegateeCheck_delegatee_has_valid_updater_capCdc() (*asset, error) } info := bindataFileInfo{name: "scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7d, 0x26, 0xe4, 0x67, 0x6f, 0xd5, 0x14, 0x69, 0x81, 0x9e, 0x63, 0xd, 0x9e, 0xb6, 0x24, 0xa, 0x2d, 0x85, 0x2a, 0xf5, 0x30, 0xe6, 0x30, 0x5e, 0x80, 0x46, 0xeb, 0xf7, 0x6e, 0x5c, 0x32, 0xc2}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd0, 0xa2, 0xa, 0x64, 0xbd, 0x39, 0xc4, 0x3e, 0xd5, 0x53, 0x53, 0xd2, 0xbe, 0x7a, 0xcc, 0xdd, 0xb2, 0x5c, 0x9d, 0x69, 0x10, 0x16, 0x1, 0x92, 0x3c, 0x3f, 0xa5, 0x65, 0xd5, 0x87, 0xb, 0x5f}} return a, nil } @@ -308,7 +311,7 @@ func scriptsMigrationContractStagingIs_validatedCdc() (*asset, error) { return a, nil } -var _scriptsTestFooCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xca\xcc\x2d\xc8\x2f\x2a\x51\x50\x72\xcb\xcf\x57\xe2\xe2\x2a\x28\x4d\x52\x48\x2b\xcd\x53\xc8\x4d\xcc\xcc\xd3\xd0\xb4\x52\x08\x2e\x29\xca\xcc\x4b\x57\xa8\xe6\x52\x50\x50\x50\x28\x4a\x2d\x29\x2d\xca\x53\x70\xcb\xcf\xd7\x4b\xcb\xcf\xd7\xd0\xe4\xaa\x05\x04\x00\x00\xff\xff\x57\x17\x9b\x30\x3d\x00\x00\x00" +var _scriptsTestFooCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x04\xc0\xb1\x0d\x80\x20\x10\x05\xd0\xfe\xa6\xf8\xa1\x82\xc6\x01\x1c\x80\x05\x9c\x80\x10\x30\x24\x70\xdf\x1c\x50\x19\x77\xf7\xb5\xf1\xd0\x16\x5c\x24\x9d\x48\xca\xb9\xcc\xe9\x53\xef\x01\x75\x2b\x46\x6a\xea\xc3\x89\x6b\x59\xd3\x1b\xaf\x00\x80\x95\xb5\x4d\x11\xc9\xa3\x92\x3e\xc8\xf7\x07\x00\x00\xff\xff\x4d\x05\x79\x54\x45\x00\x00\x00" func scriptsTestFooCdcBytes() ([]byte, error) { return bindataRead( @@ -324,7 +327,7 @@ func scriptsTestFooCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/test/foo.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd0, 0xd0, 0x56, 0x0, 0xef, 0x9, 0xeb, 0xeb, 0xcb, 0x5e, 0x78, 0xa4, 0x23, 0xd5, 0x60, 0x9d, 0xd8, 0x46, 0xf6, 0x5a, 0x24, 0xc5, 0x7f, 0xdb, 0xd5, 0x88, 0xa5, 0xcb, 0xe4, 0xa6, 0x20, 0x59}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6, 0xc4, 0x7c, 0x55, 0x81, 0xfc, 0x99, 0x35, 0xa1, 0xf5, 0x93, 0x7f, 0x88, 0x76, 0xe0, 0xc7, 0x95, 0xb9, 0xad, 0x68, 0x1a, 0x72, 0x2e, 0x90, 0xf7, 0x90, 0x5d, 0x3, 0x4c, 0x9d, 0xb7, 0xd2}} return a, nil } @@ -368,7 +371,7 @@ func scriptsTestGet_current_block_timestampCdc() (*asset, error) { return a, nil } -var _scriptsUpdaterGet_block_update_boundary_from_updaterCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\xb1\x6e\x02\x31\x10\x44\x7b\x7f\xc5\x88\x22\x3a\x37\xd0\x44\x29\x50\x14\x04\x54\xe9\x50\x22\x3e\x60\xcf\xb7\x77\x67\xc5\xd8\x68\xbd\x26\x42\x88\x7f\x8f\xce\x90\x14\x51\x8a\xb8\x1b\xe9\xf9\xcd\x6a\xfc\xe1\x98\x44\x31\x7b\x57\x1a\xb8\xdb\xa6\xa8\x42\x4e\xf7\xc7\x8e\x94\xf3\xcc\x98\xc5\x62\x81\x37\x56\xf1\x7c\xe2\x0c\x1d\x19\x6d\x48\xee\x03\x23\xfb\x61\x54\x94\x0a\xa2\x4d\x25\x76\x24\x67\xf4\x92\x0e\x95\xba\x19\x04\xa4\x35\x0e\xfe\xc4\x11\xeb\xae\x13\xce\x19\x49\x10\x7d\x80\xef\x41\xf1\x87\xf4\x19\x31\x29\xfa\x49\x35\xd5\x1a\x72\x8e\x73\x6e\x28\x04\x8b\xbe\x44\x1c\xc8\xc7\xe6\x56\x28\x77\xd3\xf2\x5b\x69\x97\xd8\xbf\x46\x7d\x7a\x5c\xe1\x62\x00\x40\x58\x8b\x44\x0c\xac\x6b\xe7\x52\x89\xfa\xeb\xa7\x9d\x0f\xac\x5b\x3a\x52\xeb\x83\xd7\xf3\xf3\xc3\xe5\xcf\x05\xe6\xf7\xeb\x76\xa5\x0d\xde\x5d\x5f\x9a\x2a\x9f\xde\x3f\xf0\x1d\xe9\x58\x79\x3b\x6f\x93\x48\xfa\x6c\x6c\x8d\xab\xa9\x7b\x33\xcd\x78\xc3\x37\xf7\xf5\x1a\x6b\xae\xe6\x2b\x00\x00\xff\xff\x3b\x26\xa2\x55\x91\x01\x00\x00" +var _scriptsUpdaterGet_block_update_boundary_from_updaterCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\xb1\x4e\xc3\x40\x0c\x86\xf7\x7b\x8a\x5f\x1d\x50\xb2\xa4\x0b\x62\xa8\x10\x55\xcb\xc4\x56\x81\xfa\x00\xce\xc5\x49\x2c\xae\x77\x95\xcf\x57\x84\xaa\xbe\x3b\x4a\x5a\x18\x10\x03\xde\x2c\x7d\xfe\x7e\xeb\x97\xc3\x31\xa9\x61\xf1\x66\x34\x70\xf7\x9c\xa2\x29\x79\xdb\x1f\x3b\x32\xce\x0b\xe7\x96\xcb\x25\x5e\xd9\x54\xf8\xc4\x19\x36\x32\xda\x90\xfc\x3b\x46\x96\x61\x34\x94\x19\x44\x9b\x4a\xec\x48\x3f\xd1\x6b\x3a\xcc\xd4\xd5\xa0\x20\x9b\xd7\x41\x4e\x1c\xb1\xe9\x3a\xe5\x9c\x91\x14\x51\x02\xa4\x07\xc5\x1f\x52\x32\x62\x32\xf4\x93\x6a\x8a\x75\xe4\x3d\xe7\x5c\x51\x08\x35\xfa\x12\x71\x20\x89\xd5\x35\x50\x6f\xa6\xd5\xb7\xb2\x5e\x61\xff\x12\xed\xe1\x7e\x8d\xb3\x03\x00\x65\x2b\x1a\x31\xb0\x6d\xbc\x4f\x25\xda\xaf\xcb\xba\xf1\x74\xa4\x56\x82\x98\x70\x6e\xda\xa4\x9a\x3e\x1e\xef\xce\x7f\xf6\xd0\xdc\x7e\xdc\x95\x36\x88\xbf\x3c\x55\x73\xc4\x34\xff\xc0\x77\x64\xe3\xcc\xd7\xeb\x66\x60\xdb\x4e\xf5\x5d\x81\xed\xad\xb5\xaa\x76\x17\xf7\x15\x00\x00\xff\xff\xb7\xfc\xde\x23\x89\x01\x00\x00" func scriptsUpdaterGet_block_update_boundary_from_updaterCdcBytes() ([]byte, error) { return bindataRead( @@ -384,11 +387,11 @@ func scriptsUpdaterGet_block_update_boundary_from_updaterCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_block_update_boundary_from_updater.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x15, 0x2f, 0xfa, 0xf8, 0xba, 0xa, 0x18, 0xf7, 0xa2, 0xc6, 0x3c, 0xe2, 0x89, 0xc2, 0xc, 0x47, 0x42, 0x21, 0x36, 0x95, 0xb7, 0xb9, 0xa1, 0xab, 0x17, 0x6a, 0x94, 0x9b, 0x87, 0x9c, 0x28, 0x60}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1d, 0x82, 0xec, 0xbd, 0xe9, 0xb8, 0xb1, 0xe7, 0x6c, 0x25, 0xd2, 0xcd, 0xb, 0x62, 0x1a, 0xd7, 0xec, 0x59, 0x51, 0x99, 0x2c, 0xf1, 0x9a, 0xe6, 0x35, 0x62, 0x81, 0xe0, 0x7, 0xb9, 0xd7, 0xdf}} return a, nil } -var _scriptsUpdaterGet_current_deployment_stageCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\xc1\x6a\x02\x31\x10\x86\xef\x79\x8a\x1f\x0f\x65\x73\xd1\xbb\x94\x8a\xd8\x4b\x6f\xd2\xd2\x07\x88\xc9\xec\x1a\x88\x93\x65\x32\xb1\x88\xf8\xee\x65\xb3\xd6\x43\xe9\xa1\x39\x65\xc8\xf7\x7f\x93\x99\x78\x1a\xb3\x28\x16\x1f\xea\x06\x0a\xbb\xcc\x2a\xce\xeb\xe7\x18\x9c\x52\x59\x18\xb3\x5a\xad\xf0\x4e\x2a\x91\xce\x54\xa0\x47\x82\xaf\x22\xc4\x8a\x40\x63\xca\x97\xd3\x74\x2d\x53\x18\xb9\x6f\xef\x73\x56\xe0\xb4\x95\x43\x3c\x13\x63\x1b\x82\x50\x29\xc8\x02\x8e\x09\xb1\x87\xe3\x07\x19\x0b\x38\x2b\xfa\x5c\x39\x4c\x0d\x8d\xf3\x9e\x4a\xe9\x5c\x4a\x16\x7d\x65\x9c\x5c\xe4\xae\xce\xf4\xdd\xb4\xfe\x51\xda\x35\xde\x58\x37\xb8\x1a\x00\x10\xd2\x2a\x8c\x81\x74\xeb\x7d\xae\xac\xbf\x62\x76\x39\x90\xee\xdc\xe8\x0e\x31\x45\xbd\x3c\x3f\x5d\xff\x1c\x7c\x79\xff\xda\xbe\x1e\x52\xf4\xb7\x97\xae\xc9\xa7\xf3\x0f\x7c\xef\xf4\xd8\x78\xbb\x3c\x64\x91\xfc\xd5\xd9\x56\x6e\x5a\xef\x79\x7b\xaf\x8f\xe5\x35\x61\x67\xcd\xcd\x7c\x07\x00\x00\xff\xff\x93\x20\x91\xe6\x8b\x01\x00\x00" +var _scriptsUpdaterGet_current_deployment_stageCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\x31\x6b\xc3\x30\x10\x85\x77\xfd\x8a\x47\x86\x62\x2f\xf6\x1e\x4a\x43\x48\x97\x6e\xa1\xa5\x3f\x40\x96\xce\x8e\x40\x3e\x99\xd3\x29\xa5\x84\xfc\xf7\x62\x3b\xcd\x50\x3a\x44\x93\x84\xbe\xf7\xde\xdd\x0b\xe3\x94\x44\xb1\xf9\x50\x3b\x90\x3f\x24\x56\xb1\x4e\x3f\x27\x6f\x95\xf2\xc6\x98\xb6\x6d\xf1\x4e\x2a\x81\xce\x94\xa1\x27\x82\x2b\x22\xc4\x0a\x4f\x53\x4c\xdf\xe3\x7c\xcd\xb3\x18\xa9\x5f\xfe\x57\xad\xc0\xea\xf2\x1c\xc2\x99\x18\x7b\xef\x85\x72\x46\x12\x70\x88\x08\x3d\x2c\xdf\xc9\x90\xc1\x49\xd1\xa7\xc2\x7e\x0e\x34\xd6\x39\xca\xb9\xb2\x31\xd6\xe8\x0b\x63\xb4\x81\xab\xb2\xd2\x37\xa7\xed\xaf\x65\xbd\xc5\x1b\xeb\x0e\x17\x03\x00\x42\x5a\x84\x31\x90\xee\x9d\x4b\x85\xf5\x8f\xac\x6e\x9c\x9d\x6c\x17\x62\xd0\x40\xb9\xe9\x92\x48\xfa\x7a\x7e\xba\xfc\xbb\x7e\x73\x1b\xf0\x58\xba\x18\xdc\xf5\xa5\x5a\x22\xe6\xf3\x00\x7e\xb4\x7a\x5a\xf8\x7a\xd7\x0c\xa4\x87\xb5\xb5\xd7\x7b\x69\x8b\x45\x55\x9b\xab\xf9\x09\x00\x00\xff\xff\x56\x0a\x99\xc4\x83\x01\x00\x00" func scriptsUpdaterGet_current_deployment_stageCdcBytes() ([]byte, error) { return bindataRead( @@ -404,11 +407,11 @@ func scriptsUpdaterGet_current_deployment_stageCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_current_deployment_stage.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe5, 0x4a, 0xa7, 0xec, 0xd2, 0xc2, 0x2e, 0xd9, 0x5c, 0xfb, 0x6d, 0xc5, 0x1b, 0xb3, 0x20, 0xba, 0xc2, 0x77, 0xa2, 0xe9, 0xff, 0xf2, 0xc6, 0xcd, 0x9b, 0x1e, 0xe3, 0x1d, 0x6d, 0x59, 0xc7, 0x6f}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe8, 0x23, 0x11, 0x9, 0x18, 0xf0, 0x31, 0x5d, 0xfb, 0x8a, 0x8b, 0xfc, 0x58, 0x9e, 0x19, 0x43, 0x1c, 0xd2, 0xc3, 0xa7, 0x76, 0xf7, 0x21, 0xac, 0x6a, 0x2b, 0xc6, 0x22, 0x70, 0x4f, 0xfc, 0x3}} return a, nil } -var _scriptsUpdaterGet_invalid_hostsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x50\xbd\x6a\xf3\x40\x10\xec\xf5\x14\x83\x8b\x0f\xa9\xb1\x7b\xf3\x11\x63\xdc\x24\x45\xc0\x24\x24\x4d\x48\xb1\xd2\xad\xa4\x05\x79\x4f\xdc\xed\xd9\x04\xe3\x77\x0f\xfa\xb1\x8a\x90\x22\x57\xed\xed\xdc\xfc\xdc\xc8\xa9\xf7\xc1\xb0\x7a\x66\x23\x47\x46\xef\xc2\x97\xb8\xca\xb2\xfb\xfe\xd5\xa8\x61\x77\xf0\x6a\x81\x2a\x7b\xeb\x1d\x19\x0f\xf8\x66\xb3\xc1\x0b\x5b\x0a\x1a\x41\xce\x05\x8e\x91\x23\x7c\x8d\x47\x1f\x2d\xe2\x22\xd6\x82\xc5\x5a\x0e\x10\x3d\x53\x27\x6e\x44\xe0\x03\x58\x2b\xea\x63\xea\xc8\x18\xfb\x64\xed\xbe\xaa\x7c\x52\xc3\x81\x7a\x2a\xa5\x13\x13\x8e\xa8\x83\x3f\xc1\x5a\xc6\x64\x19\x40\x36\x5c\x47\xdf\x46\xce\xac\x77\xd7\x41\x51\xa5\x83\xd4\x50\xaf\x0c\x89\xa8\x7d\x52\x37\xbc\xcc\xfa\x54\xa2\x4e\x8a\x13\x89\xe6\x69\x52\xda\x4f\xbc\x2d\xe6\xa1\xd8\xe2\x63\x1e\x3f\x77\xb8\x66\x00\x10\xc6\x9f\xa1\x61\x9b\xc3\xfd\x20\x17\xeb\x86\x6d\xc9\xfb\xf5\xff\xdf\xf5\xd7\x9e\xd6\x73\xf8\x63\x2a\x3b\xa9\x6e\x0f\xf9\x28\x7e\x3f\x7f\xa0\x1c\xc9\xda\x85\x53\xac\x4b\x1f\x82\xbf\xe4\xc5\xb2\xda\x0d\x39\x9e\xa6\x7e\xc7\xe2\xf3\x22\xbb\x65\xdf\x01\x00\x00\xff\xff\x56\x27\x69\xc1\xd4\x01\x00\x00" +var _scriptsUpdaterGet_invalid_hostsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\x3f\x6b\xc3\x30\x10\xc5\x77\x7f\x8a\x47\x86\x62\x2f\xce\x1e\x4a\x43\xc8\xd2\x0e\x85\xd0\xd2\x2e\xa5\xc3\x45\x3a\xdb\x07\x8a\x64\xa4\x53\x32\x84\x7c\xf7\xe2\x7f\xa5\x94\x0e\xd5\x74\xd2\xe9\xdd\xef\xde\x93\x53\x1f\xa2\x62\xf5\xcc\x4a\x96\x94\xde\x85\x2f\x69\x55\x14\xcb\xfb\xab\x52\xcb\x76\x1f\xbc\x46\x32\xfa\xd6\x5b\x52\x1e\xfa\xeb\xf5\x1a\x2f\xac\x39\xfa\x04\xb2\x36\x72\x4a\x9c\x10\x1a\x3c\x86\xa4\x09\x17\xd1\x0e\x2c\xda\x71\x84\xf8\x33\x39\xb1\x63\x07\x21\x82\xbd\xa1\x3e\x65\x47\xca\xd8\x19\x13\xb2\x57\xec\xa9\xa7\xa3\x38\x51\xe1\x84\x26\x86\x13\xb4\x63\x4c\xb8\x08\xd2\xe1\x3a\x32\x5b\x39\xb3\x5f\x88\xc3\x34\x2f\x0e\xd2\xc0\x07\xcf\x90\x84\x26\x64\x6f\x87\x9f\x05\x19\xc3\x29\x95\xe4\x5c\x85\x26\x7b\x9c\x48\x7c\x99\xa7\x89\xbb\x49\xbf\xc1\x5c\x54\x1b\x7c\xcc\xe5\xe7\x16\xd7\x02\x00\xe2\xe8\x0e\x2d\xeb\xbc\xe4\x2f\x71\x55\x9b\x1f\x4b\xd7\xc7\x10\x63\xb8\xdc\xdf\x5d\xff\x4c\xac\x9e\xad\x1c\xf2\xd1\x89\xb9\x3d\x94\x23\x62\x39\xff\x90\x1c\x48\xbb\x6f\x4d\xb5\xad\x5b\xd6\xa7\x29\xd7\x31\xf0\xb2\x2a\x6e\xc5\x57\x00\x00\x00\xff\xff\x2f\xb6\xbe\xd6\xcc\x01\x00\x00" func scriptsUpdaterGet_invalid_hostsCdcBytes() ([]byte, error) { return bindataRead( @@ -424,11 +427,11 @@ func scriptsUpdaterGet_invalid_hostsCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_invalid_hosts.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3b, 0x2e, 0x3b, 0x19, 0x49, 0x2, 0xb4, 0x38, 0xce, 0x27, 0xe9, 0x1e, 0x69, 0xa3, 0x64, 0x6b, 0x71, 0xd2, 0x65, 0x49, 0x6b, 0x7c, 0x51, 0xa8, 0x10, 0xf7, 0x63, 0xd2, 0xe5, 0x93, 0xbf, 0x5d}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x67, 0x33, 0x1b, 0x15, 0x43, 0x4c, 0xe5, 0x26, 0xc8, 0x97, 0x12, 0x55, 0xd6, 0xbd, 0x7d, 0x73, 0xfa, 0xa5, 0x91, 0x42, 0x36, 0x92, 0xda, 0xd, 0xe0, 0x5, 0xd, 0x53, 0x2c, 0xdb, 0x94, 0x9b}} return a, nil } -var _scriptsUpdaterGet_updater_deployment_orderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\x41\x6e\xb3\x30\x10\x85\xf7\x3e\xc5\x28\x8b\x5f\x20\xfd\x22\xfb\xa8\xb4\x42\xed\x01\xaa\x46\x5d\x45\x59\x4c\x60\x20\x96\xc0\x46\xf6\x38\x55\x15\x71\xf7\xca\x80\xa1\x6e\xd2\x7a\x81\xe4\x99\xf7\xde\x7c\x03\xc8\xae\xd7\x86\x61\xb3\x67\x6c\xa8\x7a\xd6\x8a\x0d\x96\xfc\xde\x57\xc8\x64\x37\x42\x6c\xb7\x5b\x78\x23\x76\x46\x59\xb8\x60\xeb\xc8\x82\xae\x81\xcf\x04\x93\xc6\x00\xf2\x78\x6d\xe4\x85\x14\x14\x55\x65\xc8\x5a\x6f\x13\xbd\x3b\x41\xed\x14\x74\x28\x55\x82\x53\x63\x17\x14\xe9\x0e\x0e\x87\x6b\x11\xaa\x7b\x36\x52\x35\xc3\xf1\xf8\x04\x57\x01\x00\xd0\x12\x03\x96\xa5\x76\x8a\x21\x87\x86\xb8\x70\x7c\x2e\xa6\x42\x08\x4b\x47\x25\x8c\x4f\x59\x8f\x16\x37\x43\xe5\xc1\x9c\x9d\xb4\x31\xfa\xe3\xe1\xdf\xdd\x05\xb3\x79\x89\xc7\xa4\x36\xba\xf3\x18\x7f\x88\xf6\xac\x0d\x36\xf4\x8a\x7c\x4e\x67\xca\x40\x6a\xc8\xba\x96\x7f\x59\x09\x72\x38\x1c\x23\x79\x45\x7d\xab\x3f\x3b\x52\x6c\x21\x0f\xcc\x59\x43\xfc\xb2\x36\x92\x54\x2c\x9e\x5a\x1b\x90\xff\xc1\x7a\x3a\x90\x2a\xf2\xaf\x20\x4b\x3a\x32\xee\xe0\x0e\x49\x0c\x12\x82\xcb\x68\x5b\x1f\x3f\xcd\x89\x83\xfd\xf1\xc1\x19\xf6\x3d\xa9\x2a\xb9\xed\xfa\x13\x67\x65\xcb\x47\xff\x51\x57\xd8\xd1\x8d\x7f\x48\xa3\xd2\x10\xdd\xa6\x17\x1c\x86\x7b\x90\x55\xbd\x2a\xc5\x2a\xf7\x7f\xec\xec\x12\x93\x48\x7c\x6b\x28\xd9\x0a\x31\x88\xaf\x00\x00\x00\xff\xff\x8e\x2e\x68\x02\xfd\x02\x00\x00" +var _scriptsUpdaterGet_updater_deployment_orderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\xc1\x8e\x9b\x30\x10\x86\xef\x7e\x8a\x51\x0e\x11\x48\x15\xb9\x47\x21\x15\x6d\x1f\xa0\x6a\xd4\x5e\xa2\x1c\xa6\x30\x80\x25\xb0\x91\x3d\xce\x6a\x15\xf1\xee\x2b\x03\x0e\xeb\x4d\x76\x39\x20\x79\xe6\x9f\x6f\xfe\xdf\xb2\xec\x07\x6d\x18\x36\x27\xc6\x86\xaa\x9f\x5a\xb1\xc1\x92\xff\x0e\x15\x32\xd9\x8d\x10\xbb\xdd\x0e\xfe\x10\x3b\xa3\x2c\x5c\xb1\x73\x64\x41\xd7\xc0\x2d\xc1\xac\x31\x80\x3c\x1d\x1b\x79\x25\x05\x45\x55\x19\xb2\xd6\x8f\x09\x2c\x4b\xb2\x36\xc1\xae\x4b\xa1\x76\x0a\x7a\x94\x2a\xc1\x59\xb0\x0f\xca\x74\x0f\xe7\xf3\xad\x08\xd5\x13\x1b\xa9\x9a\xf1\x72\xf9\x0e\x37\x01\x00\xd0\x11\x03\x96\xa5\x76\x8a\x21\x87\x86\xb8\x70\xdc\x16\x73\xe1\x80\x8e\xdb\xe4\x87\x36\x46\xbf\xfc\xf3\xde\x52\xd8\x2e\xad\x63\x58\x94\x4e\x14\x98\xfe\xb2\x9e\x70\x6e\x31\x9e\x07\x70\xf6\x7f\x42\x1c\xb6\x4f\x2f\x21\x5b\x82\x1e\x93\xda\xe8\xde\x5b\xfc\x42\x74\x62\x6d\xb0\xa1\xdf\xc8\x6d\xba\x24\x08\x29\x0c\x59\xd7\xf1\x27\x71\x21\x87\xf3\x25\x92\x57\x34\x74\xfa\xb5\x27\xc5\x16\xf2\xe0\x39\x6b\x88\x7f\xad\x8d\x24\x15\xf7\x99\x5a\x1b\x90\xdf\xc0\x7a\x77\x20\x55\x34\xbf\x1a\xb9\xd3\x91\x71\x0f\x4f\x9c\xc4\x46\x02\xb8\x8c\xd2\x7a\xfc\xbc\x27\x06\xfb\xcf\x83\x33\x1c\x06\x52\x55\xf2\xd8\xf5\x5f\xcc\xca\xee\x0f\xe2\x43\x5d\x61\x4f\x0f\xf3\x63\x1a\x95\xc6\xe8\x34\x5f\x70\x58\xee\x8d\xac\xea\x55\x29\x56\xb9\x7f\xd5\xcb\x94\x98\x45\xe2\x5d\x43\xc9\x4e\x88\x51\xbc\x05\x00\x00\xff\xff\x6c\xc5\xe9\x58\x21\x03\x00\x00" func scriptsUpdaterGet_updater_deployment_orderCdcBytes() ([]byte, error) { return bindataRead( @@ -444,11 +447,11 @@ func scriptsUpdaterGet_updater_deployment_orderCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_updater_deployment_order.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2f, 0x6c, 0xab, 0xf7, 0xde, 0xf3, 0x25, 0xc3, 0xd2, 0xe5, 0xac, 0x8b, 0xd7, 0x54, 0x66, 0x81, 0x14, 0x90, 0xc8, 0xb4, 0x9c, 0x8e, 0xea, 0x8e, 0xd9, 0xd, 0x2, 0xfd, 0x9d, 0x3d, 0xab, 0x12}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x27, 0x5d, 0x86, 0xa2, 0xb4, 0x9c, 0x8, 0xb2, 0xfe, 0x70, 0x19, 0x6e, 0x3f, 0xd4, 0x55, 0xdd, 0x1b, 0xab, 0xf, 0x34, 0x72, 0x1d, 0x34, 0xd, 0x5a, 0xe2, 0xc3, 0xf6, 0x41, 0x3f, 0xf5, 0x36}} return a, nil } -var _scriptsUpdaterGet_updater_deployment_readableCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x53\xc1\x8a\xdb\x30\x10\xbd\xeb\x2b\x86\x3d\x14\x1b\x16\xfb\x1e\xea\x96\xb0\xfd\x80\xb2\xa1\xa7\x90\x83\x62\x8d\x1d\x83\x2d\x19\x69\xb4\xa5\x94\xfc\xfb\x32\x92\x6d\xad\xb2\xc9\xea\x10\xac\x79\xf3\xde\xcc\xbc\x8c\x86\x69\x36\x96\xe0\xe9\x40\xb2\x47\xf5\x62\x34\x59\xd9\xd2\x9f\x59\x49\x42\xf7\x24\xc4\xec\xcf\xe0\xc8\xfa\x96\x20\x07\x5f\x51\x2a\x79\x1e\x11\xfe\x0b\x00\x00\xce\x1b\x91\x40\x2a\x65\xd1\xb9\x1d\xec\xe3\x47\x06\x6a\x39\xe1\x0e\x0e\x64\x07\xdd\x67\x40\x6b\x54\x02\x02\x32\xe8\x81\x8a\xf0\xc5\xe7\x56\xf5\x79\x43\x3e\x4a\xa6\x68\xa6\xc7\x81\x72\x69\x93\x8f\xc3\xb1\xab\x16\x45\x68\x56\xed\x1c\x66\x59\x68\x82\x7a\x0e\xb0\x32\x34\xa1\x40\x00\xae\xe2\x2a\x44\x5d\xd7\xf0\x8a\xe4\xad\x76\xf0\x26\x47\x8f\x0e\x4c\x07\x74\x41\x88\x5e\x59\x90\x14\xae\xfd\xf0\x86\x7a\xb3\xa6\xae\xeb\xe0\x6f\xe7\x35\x4c\x72\xd0\xc5\xed\x98\xe5\x0e\x8e\xc7\xfb\xb6\x9f\x4e\x3f\x97\x91\xc2\x4f\xb0\xbe\x6d\x8d\xd7\x04\x0d\xf4\x48\x7b\x4f\x97\x7d\x0c\xac\xb2\x65\x9c\x24\xda\xdb\x05\x8a\x5f\xda\x6b\x56\x72\x75\x36\xd6\x9a\xbf\xdf\xbf\xdd\xdd\x87\x6a\x19\xe7\x47\xd1\x59\x33\xb1\xc1\x5f\x24\x1d\xc8\x58\xd9\xe3\x6f\x49\x17\x76\x7f\xb3\x91\xeb\x5a\x74\x7e\xa4\xaf\xa6\x83\x06\x8e\xa7\x8c\xa3\x70\x1e\xcd\xbf\x09\x35\xf1\xbf\xb6\x74\x5e\xf5\x48\xbf\x12\x50\x94\xa9\x4e\x67\x2c\x38\x6e\x10\x06\x9d\x91\xd3\x26\x6c\xd2\x92\xe4\x0e\x1e\xf5\x92\xb7\xb2\x4a\xb7\x59\x32\xd7\x88\xc5\x72\x75\x3e\xac\x5e\xc9\x79\x46\xad\x8a\x4f\xe0\x7a\xee\xd7\x7e\x9c\xbf\xad\x4a\xde\xc7\xba\xd7\xcf\x0f\x89\xf1\xc1\xdc\xb0\x38\xf8\x98\x12\x5f\xd3\x0d\x85\x83\x7b\xf7\x22\x15\xea\x16\x8b\xf2\x2e\xf9\x73\x34\x8f\x5c\xb3\x5b\x5c\x8a\xd5\x29\x76\x2d\x65\xa7\x4c\x91\xd2\xf9\xc1\x2d\xac\xe5\x2d\x8a\x0f\x80\x1e\x46\x21\xae\xe2\x3d\x00\x00\xff\xff\xcb\x5d\xb2\xa9\xe1\x04\x00\x00" +var _scriptsUpdaterGet_updater_deployment_readableCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x53\xcd\x6e\xa3\x30\x10\xbe\xfb\x29\x46\x3d\x54\x20\x55\x70\x8f\x4a\x57\x51\xf7\x01\x56\x8d\xf6\x14\xe5\x30\x85\x81\x20\x81\x8d\xec\x71\x57\xab\x55\xde\x7d\xe5\x1f\x20\x4e\x49\x7c\x40\x78\xe6\x9b\x6f\xbe\xf9\x71\x3f\x4e\x4a\x33\x3c\x1d\x18\x3b\x6a\xde\x95\x64\x8d\x35\xff\x9e\x1a\x64\x32\x4f\x42\x60\x5d\x93\x31\x19\x0e\x43\x0e\x86\xb5\xad\x19\x52\xd0\x07\x61\x83\x9f\x03\xc1\x3f\x01\x00\x70\x8d\x1f\x88\x01\x9b\x46\x93\x31\x3b\xd8\x87\x9f\x4d\x90\xc4\x91\x76\x70\x60\xdd\xcb\x6e\x13\x50\xab\x66\x05\x78\x44\x2f\x7b\xce\xfc\x9f\xc7\xdf\x64\x79\x59\x3c\xd7\xd4\xab\x35\xe1\x73\x86\x3c\xca\x77\xc7\xd0\xd0\x16\x91\x11\xaa\x99\x3b\x75\x3b\x5a\xa8\x3c\x7b\xea\x70\xcc\x50\xf9\x04\xde\x71\x11\x17\x21\xca\xb2\x84\x0f\x62\xab\xa5\x81\x2f\x1c\x2c\x19\x50\x2d\xf0\x99\x20\xf4\x50\x03\xb2\xbf\x76\xfd\x17\xc9\xa5\x55\x65\x59\x26\xfd\x6f\xad\x84\x11\x7b\x99\xdd\x96\x9b\xef\xe0\x78\xdc\x1e\xcb\xe9\xf4\x23\x96\xe6\x3f\x7e\x24\x75\xad\xac\x64\xa8\xa0\x23\xde\x5b\x3e\xef\x83\xe1\x15\x2d\x9f\xb3\x03\x2b\x8d\x1d\xe5\xf0\x1c\xcd\x6f\x73\xba\x3c\x54\x1a\xda\xdf\x7a\x2a\x1b\xe5\x57\x33\x69\xf1\xa9\xb4\x56\x7f\x5e\x9f\x37\xf7\xa9\x88\xe5\xbe\x65\xad\x56\xa3\x1b\xc0\x03\x50\x14\xf2\x0b\xf9\xec\xa6\xb3\xb4\xd9\xe5\xd5\x64\xec\xc0\x8f\xaa\x86\x0a\x8e\xa7\x24\xa6\xa1\x69\x50\x7f\x47\x92\xec\xa6\x1a\x95\x17\x1d\xf1\xcf\xd5\x91\xe5\x6b\x9e\x56\x69\x30\x4e\x20\xf4\x32\x09\x5e\x37\x65\xa1\x46\xc6\x1d\xdc\xd3\x92\x4a\x99\xa9\xeb\x04\xec\x72\x84\x64\x29\xbb\x3b\x8e\xbd\xc0\x69\x22\xd9\x64\xdf\x9c\xf3\xd9\xce\x7d\x1f\xbf\xac\x50\xaa\x63\xde\xfb\x97\xbb\x81\xe1\x41\xdd\x44\x39\xe3\xfd\x90\xf0\xda\x6e\x42\x9c\x71\x6f\xde\xb1\x21\x59\x53\x96\x6f\x06\x7f\xb7\xa6\x96\x4b\x72\x0b\x4b\x31\x77\xca\x75\x6d\x45\xaf\x48\xb1\xc2\xdd\x83\x8c\x51\xf1\xad\x8a\x2b\x87\xec\x07\x21\x2e\xe2\x7f\x00\x00\x00\xff\xff\xb9\xc2\x9b\x72\x21\x05\x00\x00" func scriptsUpdaterGet_updater_deployment_readableCdcBytes() ([]byte, error) { return bindataRead( @@ -464,11 +467,11 @@ func scriptsUpdaterGet_updater_deployment_readableCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_updater_deployment_readable.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe6, 0x50, 0xfc, 0x89, 0x59, 0xef, 0xa0, 0xaf, 0x81, 0x6, 0x7e, 0x32, 0xce, 0xfc, 0x5b, 0xb3, 0xa7, 0x5b, 0xef, 0x1b, 0xb7, 0x64, 0x96, 0x37, 0x98, 0x8e, 0x20, 0xb7, 0xad, 0xc, 0x9a, 0x7b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xee, 0xb5, 0xc5, 0x0, 0xef, 0x9a, 0x64, 0x33, 0x7c, 0x55, 0xdc, 0x74, 0xd6, 0x91, 0x3d, 0xcb, 0x4, 0xdb, 0x18, 0xd6, 0xec, 0xb8, 0x26, 0x51, 0xd6, 0x83, 0x9, 0x69, 0x6a, 0x6a, 0xea, 0x2f}} return a, nil } -var _scriptsUpdaterGet_updater_infoCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\x4f\x6b\x02\x31\x10\xc5\xef\xf9\x14\xaf\x1e\xca\x06\xca\x7a\x17\x51\xc4\x53\x0f\x05\xb1\x7f\xee\xb3\x9b\xd9\x35\xb0\x26\xcb\x64\xa2\x88\xf8\xdd\x8b\xda\x95\x16\x4a\x6b\x4e\xc9\x1b\xe6\xf7\x5e\x9e\xdf\xf6\x51\x14\xa3\x17\x56\x72\xa4\xf4\xe1\x79\x9f\x46\xc6\x0c\xfa\xab\x52\xcb\x6e\x19\x83\x0a\xd5\xfa\xde\x3b\x52\x3e\xcf\xc7\xe3\x31\xd6\xac\x59\x42\xc2\x55\x95\xe7\xd0\x44\xec\x3c\xef\xd1\x48\xdc\x42\x37\x3c\x4c\x40\x7a\x79\xb6\x7e\xc7\x01\xe4\x9c\x70\x4a\x88\x82\xe0\x3b\xf8\x06\x21\x06\x86\x4f\x68\x62\x0e\xee\x8c\x36\x7d\xae\xd0\xe4\x80\x2d\xf9\x50\x7c\x2d\x4c\xb0\xb8\x5e\xec\x04\xbf\xc6\x2a\xbf\x05\x99\xe3\x68\x00\x40\x2e\x19\xd1\xb2\x2e\xea\x3a\xe6\xa0\x03\xcd\x96\x2d\xeb\x92\x7a\xaa\x7c\xe7\xf5\x30\x7d\x3c\xfe\xc9\x5c\xe5\xaa\xf3\xf5\x13\x7e\xf4\x54\xae\x39\xc5\x6e\xc7\x72\x9a\x15\x17\xb7\xe1\xdc\x81\x5a\x91\x6e\x6e\x3b\xb6\xac\xa2\x48\xdc\x17\xf6\x26\xcd\x4b\xb9\xc2\xcf\x4e\xc5\xdb\xa1\xe7\xe9\xbf\x9f\x9e\x15\xd6\x82\xd2\xc3\x1d\xf5\x98\x93\xf9\x0c\x00\x00\xff\xff\xd6\x25\x52\x00\xfb\x01\x00\x00" +var _scriptsUpdaterGet_updater_infoCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x90\x4f\x6b\x02\x31\x10\xc5\xef\xf9\x14\xaf\x1e\xca\x06\xca\x7a\x17\x51\xa4\xa7\xde\xc4\xfe\xb9\x8f\xd9\x59\x1d\x88\xc9\x32\x99\x55\x8a\xf8\xdd\x8b\xda\x2d\x1e\x4a\x6b\x4e\x93\x17\xde\x2f\x6f\x9e\xec\xba\xac\x86\xd1\x87\xf0\x61\xc5\x25\xc7\x3d\xeb\xc8\xb9\x41\x7e\x35\xda\x70\xf3\x9c\x93\x29\x05\x7b\xef\x1a\x32\x2e\x23\xe7\xc6\xe3\x31\x56\x6c\xbd\xa6\x82\xab\xaa\x2f\xa9\xcd\xd8\x0b\x1f\xd0\x6a\xde\xc1\xb6\x3c\xbc\x80\xec\x72\xdd\xc8\x9e\x13\xa8\x69\x94\x4b\x41\x56\x24\x89\x90\x16\x29\x27\x86\x14\xb4\xb9\x4f\xcd\x19\xed\x28\x04\x2e\xa5\xa2\x18\x3d\xda\x3e\x61\x47\x92\xaa\x6f\xe3\x04\x8b\xeb\xe0\x27\xf8\x35\x5e\x7d\x13\x68\x8e\xa3\x03\x00\xbd\x64\xc5\x86\x6d\x11\x42\xee\x93\x0d\x34\x5f\x07\xea\x68\x2d\x51\x4c\xb8\xd4\xeb\xac\x9a\x0f\xd3\xc7\xe3\x9f\xe4\x65\xbf\x8e\x12\x9e\x70\x5b\x5a\x3d\x0c\xa7\x59\x75\xf9\x72\x38\x77\x90\x96\x64\xdb\x1f\x8f\x9f\xd7\x7a\x45\x9d\xf1\xd5\xdb\x67\xc7\xd3\x7f\xf7\x9c\x55\xde\x83\xca\xc3\x1d\x8d\xb8\x93\xfb\x0a\x00\x00\xff\xff\x84\xec\xec\x9a\xf5\x01\x00\x00" func scriptsUpdaterGet_updater_infoCdcBytes() ([]byte, error) { return bindataRead( @@ -484,11 +487,11 @@ func scriptsUpdaterGet_updater_infoCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/get_updater_info.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x40, 0x13, 0x12, 0xbe, 0x3e, 0xa0, 0xeb, 0x4a, 0xb6, 0x1a, 0xa2, 0x53, 0xc1, 0x2a, 0x46, 0xe7, 0xa3, 0xcd, 0xaf, 0xce, 0xa3, 0x33, 0xbb, 0x86, 0x62, 0x13, 0x4c, 0x63, 0x35, 0xa8, 0x33, 0x7d}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4a, 0x12, 0x5c, 0xb2, 0x86, 0xa5, 0x73, 0xab, 0x4f, 0xe3, 0xc9, 0x43, 0x87, 0x0, 0xcb, 0xc3, 0x2b, 0xcd, 0x51, 0x5b, 0x1d, 0xd4, 0x9f, 0xaa, 0x99, 0x10, 0xc3, 0xdd, 0xc9, 0x9b, 0x74, 0xd4}} return a, nil } -var _scriptsUpdaterHas_been_updatedCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x8f\xb1\x6e\x02\x31\x10\x44\xfb\xfb\x8a\x11\x45\x74\x6e\x8e\x1e\x45\x41\xc0\x0f\xa0\x44\xf9\x80\xc5\xde\x3b\x2c\x99\xdd\x93\xbd\x26\x8a\x10\xff\x1e\x61\x48\x8a\x28\x45\xdc\x8d\xe6\xcd\x8c\x37\x9e\x66\xcd\x86\xc5\x9b\xd1\xc4\x61\xa7\x62\x99\xbc\xbd\xcf\x81\x8c\xcb\xa2\xeb\x96\xcb\x25\x5e\xd9\x72\xe4\x33\x17\xd8\x91\x51\x9b\x07\xaf\xa7\x39\xb1\x45\x15\x14\x23\xab\x05\x3a\x36\xff\x9e\xcd\x20\x6b\x72\x8a\x67\x16\x6c\x42\xc8\x5c\x0a\x34\x43\x62\x42\x1c\x41\xf2\x43\xc6\x02\x51\xc3\xa8\x55\xc2\x6d\xb0\x23\xef\xb9\x94\x9e\x52\x72\x18\xab\xe0\x44\x51\xfa\xfb\x6e\x7e\x34\xad\xbe\x2b\xdd\x0a\x5b\xd5\xb4\xc6\xa5\x03\x80\xcc\x56\xb3\x60\x62\xdb\x78\xaf\x55\xec\x57\xce\x0d\x13\xdb\x8e\x66\x3a\xc4\x14\xed\xf3\xf9\xe9\xf2\xe7\xe5\xc3\xe3\x6f\xfb\x7a\x48\xd1\x5f\x5f\xfa\x56\x7e\x7b\xff\xc0\xf7\x64\xc7\xc6\xbb\xe1\xa0\x39\xeb\x47\xef\x9a\x5c\x0f\x47\x2a\x5b\x66\xb9\xd3\xa1\x77\xdd\xb5\xfb\x0a\x00\x00\xff\xff\x3e\x5f\xda\x57\x81\x01\x00\x00" +var _scriptsUpdaterHas_been_updatedCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x8f\x3d\x6e\x02\x41\x0c\x85\xfb\x39\xc5\x13\x45\xb4\xdb\x2c\x3d\x8a\x82\x20\x17\x40\x89\x72\x00\x33\xe3\x05\x4b\x83\xbd\x9a\xf1\x90\x02\x71\xf7\x88\x85\xa4\x88\x52\xc4\x9d\xf5\x7e\x3e\x5b\x4e\x93\x15\xc7\xe2\xdd\xe9\xc0\xe9\xd5\xd4\x0b\x45\xff\x98\x12\x39\xd7\x45\x08\xcb\xe5\x12\x6f\xec\x45\xf8\xcc\x15\x7e\x64\xb4\x59\x43\xb4\xd3\x94\xd9\xc5\x14\xd5\xc9\x5b\x85\x8d\xb3\x7e\xcf\x16\x90\xcf\xeb\x41\xce\xac\xd8\xa4\x54\xb8\x56\x58\x81\x4a\x86\x8c\x20\xfd\x71\x4a\x85\x9a\x63\xb4\xa6\xe9\x06\x0c\x14\x23\xd7\xda\x51\xce\x3d\xc6\xa6\x38\x91\x68\x77\xe7\x96\x47\xd3\xea\xbb\xb2\x5f\x61\x6b\x96\xd7\xb8\x04\x00\x28\xec\xad\x28\x0e\xec\x9b\x18\xad\xa9\xff\xca\xf5\x43\xa4\x89\xf6\x92\xc5\x85\xeb\xb0\xb7\x52\xec\xf3\xf9\xe9\xf2\xe7\xff\xc3\xe3\xc2\x5d\xdb\x67\x89\xd7\x97\x6e\x46\xdc\xe6\x1f\xf6\x1d\xf9\x71\xf6\xf7\xeb\xe1\x48\x75\xcb\xac\x77\x3d\x75\x7d\xb8\x86\xaf\x00\x00\x00\xff\xff\x01\xab\xf2\x9b\x79\x01\x00\x00" func scriptsUpdaterHas_been_updatedCdcBytes() ([]byte, error) { return bindataRead( @@ -504,11 +507,11 @@ func scriptsUpdaterHas_been_updatedCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/updater/has_been_updated.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6b, 0x9e, 0x84, 0x64, 0x5b, 0x76, 0xed, 0xb, 0xf8, 0xb6, 0xff, 0x40, 0x5c, 0xf9, 0x51, 0x2d, 0xc2, 0xc7, 0xe9, 0xe, 0xcc, 0x1, 0x4e, 0x4c, 0x5a, 0xbc, 0xad, 0xa3, 0x64, 0x24, 0x2c, 0x4d}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1e, 0x75, 0xba, 0x98, 0x31, 0xce, 0x29, 0xad, 0xee, 0x8e, 0xe8, 0xe8, 0xa7, 0x9c, 0xee, 0x5, 0x64, 0x78, 0x77, 0xb4, 0x57, 0xfe, 0x60, 0x26, 0x0, 0x44, 0x85, 0x9a, 0x49, 0x96, 0xe2, 0x46}} return a, nil } -var _scriptsUtilGet_deployment_from_configCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\x8e\x3d\xaa\xc3\x30\x10\x84\x7b\x9d\x62\x70\xf5\xdc\xbc\x03\xb8\x0b\x0e\xb9\x80\x49\x65\x54\x28\xd6\x5a\x08\xa2\x95\x58\xaf\x8b\x20\x74\xf7\x90\x9f\x26\xe0\x6a\x18\x98\xf9\xf8\x62\x2a\x59\x14\xdd\xa4\x2e\x90\x1f\x33\xab\xb8\x45\xaf\xc5\x3b\xa5\xad\x33\xa6\xec\x37\xac\x3b\x23\xb9\xc8\x7f\x4b\xe6\x35\x86\x01\xf3\x5c\x4f\xde\x0b\x6d\xdb\x80\x3a\xa9\x44\x0e\x03\x3e\xd9\x9a\xb5\xfd\x6b\x71\x08\xfc\xff\xed\xd6\xa2\x1a\x00\x10\xd2\x5d\x18\xc7\x9f\x40\x7a\xa6\x72\xcf\x8f\x44\xac\x17\xc9\x69\x7c\x6b\x7c\x6d\x7a\xd3\x9e\x01\x00\x00\xff\xff\x7a\x6c\xf6\x01\xc4\x00\x00\x00" +var _scriptsUtilGet_deployment_from_configCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\x8e\x3b\x0a\xc3\x30\x10\x44\x7b\x9d\x62\x70\x65\x37\x39\x80\xbb\xe0\x90\x0b\x98\x54\x46\x85\x90\xd6\x42\x60\xad\xcc\x6a\x5d\x04\xe3\xbb\x87\x7c\x9a\x80\xab\x61\x60\xe6\xf1\x52\x5e\x8b\x28\x9a\x51\x5d\xa4\x30\x14\x56\x71\x5e\x1f\x6b\x70\x4a\xb5\x31\xc6\x79\x4f\xb5\xb6\x6e\x59\x3a\xcc\x1b\x23\xbb\xc4\xad\x2f\x3c\xa7\xd8\x63\x9a\xf6\x6b\x08\x42\xb5\xf6\xd8\x47\x95\xc4\xb1\xc7\x37\x8f\xc3\xda\xee\xbd\x38\x05\x5f\xfe\xbb\xb5\xd8\x0d\x00\x08\xe9\x26\x8c\xf3\x4f\x24\xbd\xd1\xba\x94\x67\x26\xd6\xbb\x94\x3c\x7c\x34\x7e\x36\x9d\x39\x5e\x01\x00\x00\xff\xff\x16\x16\x9d\xdf\xcc\x00\x00\x00" func scriptsUtilGet_deployment_from_configCdcBytes() ([]byte, error) { return bindataRead( @@ -524,11 +527,11 @@ func scriptsUtilGet_deployment_from_configCdc() (*asset, error) { } info := bindataFileInfo{name: "scripts/util/get_deployment_from_config.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x50, 0x8a, 0x60, 0x62, 0x2b, 0xa9, 0x42, 0x8c, 0xfc, 0xe6, 0x51, 0x2d, 0xa0, 0xd6, 0xc4, 0x78, 0x7c, 0xd1, 0xd5, 0x47, 0x5c, 0x65, 0x4a, 0x6b, 0x1b, 0x69, 0xa6, 0xc0, 0xca, 0xba, 0x42, 0xb8}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xcf, 0x4e, 0x54, 0xce, 0x88, 0x60, 0xe9, 0x4c, 0xa6, 0x9, 0x8d, 0x8d, 0x53, 0xcf, 0x6a, 0xa7, 0xc9, 0x37, 0x88, 0xd2, 0x6d, 0x8d, 0x9b, 0xd4, 0x4d, 0x8b, 0xfc, 0x57, 0x49, 0x9c, 0xe2, 0x1d}} return a, nil } -var _transactionsCoordinatorSet_block_update_boundaryCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x90\xcf\x4a\xc3\x40\x10\xc6\xef\xfb\x14\x9f\x39\x48\x7a\x69\x2f\xe2\x21\x88\xa5\xcd\xc9\x9b\x50\xfa\x00\xd3\xcd\x34\x09\xa6\x33\x61\x76\x42\x10\xe9\xbb\x4b\x88\x95\xa0\x82\x73\xfd\xfe\xec\xef\xdb\xf6\xd2\xab\x39\xb2\x83\x53\xcd\x55\xa9\xe2\x46\xd1\x8f\x7d\x45\xce\x29\x0b\x61\xb3\xd9\x60\xd7\x75\x3a\x26\x78\xc3\x88\x5f\x06\x94\xaa\x56\xb5\x42\xae\x06\x57\x24\x76\x10\x84\x47\x9c\x3a\x8d\x6f\x73\x7e\xaf\x83\x54\x64\xef\x53\x49\x70\x23\x49\x14\xbd\x55\xc9\x85\xc7\x9b\x56\xe0\xf8\x22\xfe\xf8\xb0\xc2\x47\x00\x80\xde\xb8\x27\xe3\x3c\xb5\xb5\xb0\x15\xd8\x0d\xde\xec\x62\xd4\x41\xfc\x66\x99\x6e\x96\xd7\x27\x35\xd3\xf1\xe9\xfe\x4f\xfa\xf5\x82\xf1\x39\x3f\x9b\x5e\x0a\xfc\x6b\x3c\xb8\x1a\xd5\xfc\x4a\xde\xac\xbe\x5f\x9b\x6e\xbb\x4e\xec\xfb\xdf\xe3\xa6\x31\x05\x16\x8b\x7e\xc4\xb6\xe8\x49\xda\x98\x67\xa5\x0e\x5d\x05\x51\xc7\x4c\x0d\xe3\x33\x1b\x4b\xe4\xe9\x03\x17\x08\x77\xd9\x5c\x71\x0d\xd7\xf0\x19\x00\x00\xff\xff\xae\x35\x17\xc7\x9f\x01\x00\x00" +var _transactionsCoordinatorSet_block_update_boundaryCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x90\xb1\x6a\xf3\x40\x10\x84\xfb\x7b\x8a\xf9\x55\x18\xb9\x91\x9b\x9f\x14\x22\xc4\xd8\xae\xd2\x05\x8c\xd3\xaf\x4f\x6b\x4b\x44\xde\x15\x7b\x2b\x44\x08\x7e\xf7\xa0\x28\x0e\x22\x09\x64\xda\x9b\x99\x9b\x6f\x9b\x4b\xa7\xe6\xc8\xf6\x4e\x67\xae\x76\x2a\x6e\x14\xfd\xd0\x55\xe4\x9c\xb2\x10\x56\xab\x15\x36\x6d\xab\x43\x82\xd7\x8c\xf8\x69\xc0\x4e\xd5\xaa\x46\xc8\xd5\xe0\x8a\xc4\x0e\x82\xf0\x80\x63\xab\xf1\x65\xca\x6f\xb5\x97\x8a\xec\x75\x2c\x09\x6e\x24\x89\xa2\x37\x2a\xb9\xf0\x70\x7b\x2b\x71\x78\x14\xbf\xfb\xbf\xc4\x5b\x00\x80\xce\xb8\x23\xe3\x3c\x35\x67\x61\x2b\x41\xbd\xd7\xf9\x56\xcd\x74\x78\xa6\xb6\xe7\x25\x16\x9b\x18\xb5\x17\xbf\x25\x46\x4d\xee\x22\xb9\x1a\x9d\xb9\x38\x7e\xf8\xef\x17\xbf\x42\x15\xb3\xe9\x0f\xf9\xc9\xf4\x52\xe2\x4f\xe3\x7e\x6a\x7e\x22\xaf\x97\x5f\xbf\x8e\x5a\x17\x89\x7d\xfb\x93\x79\x64\x2c\x31\x03\xfd\x16\x5b\xa3\x23\x69\x62\x9e\xed\xb4\x6f\x2b\x88\x3a\xa6\xd5\x30\x3e\xb1\xb1\x44\x1e\xef\x3a\x9b\xf0\x2f\x9b\x2a\xae\xe1\x1a\xde\x03\x00\x00\xff\xff\xde\x83\x6c\xdb\xb6\x01\x00\x00" func transactionsCoordinatorSet_block_update_boundaryCdcBytes() ([]byte, error) { return bindataRead( @@ -544,11 +547,11 @@ func transactionsCoordinatorSet_block_update_boundaryCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/coordinator/set_block_update_boundary.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xba, 0x83, 0x90, 0x4b, 0xc, 0x7a, 0xb5, 0x1f, 0x2b, 0x1a, 0xb, 0x6c, 0x1a, 0x1a, 0xc5, 0x16, 0x62, 0xe5, 0x22, 0xae, 0x29, 0x37, 0xd3, 0x46, 0x6e, 0xa, 0x5b, 0x90, 0xc1, 0xb3, 0x83, 0x6b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe7, 0x5d, 0x99, 0x7, 0xf9, 0x9e, 0x4d, 0xd, 0x11, 0x32, 0xed, 0xdd, 0x7d, 0x43, 0x30, 0xbc, 0xb0, 0xc1, 0xde, 0x7b, 0xd3, 0x36, 0x5, 0xff, 0xf7, 0x1a, 0xd9, 0x2, 0xf, 0x8f, 0x9b, 0x3}} return a, nil } -var _transactionsDelegateeExecute_all_delegated_updatesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x92\xcd\x6a\xdc\x30\x14\x85\xf7\x7e\x8a\xc3\x2c\x5a\x0f\x94\x99\xbd\x69\x1b\xc2\x64\x93\x4d\x29\x84\x3e\xc0\x1d\xf9\xd8\x16\xd8\x92\xb9\xba\xa2\x2d\x21\xef\x5e\x6c\x2b\x6e\x28\x0d\xa3\x8d\x7f\xf4\x9d\x9f\x2b\xe4\xa7\x39\xaa\xe1\xf0\x64\xd2\xb3\xbd\xc4\x60\x2a\xce\x7e\xcc\xad\x18\xd3\xa1\xaa\xce\xe7\x33\xca\x17\x64\x1c\xe1\xb2\x2a\x83\x21\x2d\x7c\x42\xec\xd0\x72\x64\x2f\xc6\x16\xae\xa8\x91\x8b\xc0\x87\xf5\x9f\xf8\xc0\xb6\xb8\x28\x2e\x32\xcb\xd5\x8f\xde\x3c\xd3\x6a\xff\x2d\x1a\x1b\x3c\x76\xb0\x81\x4a\x88\x12\x0c\x31\xf7\xc3\xab\x24\xbd\xc9\xb0\xb8\x60\x48\xbe\x0f\xd4\x8f\x09\x0f\x65\x87\x9f\x60\x83\x4f\x98\xe4\x37\x02\x37\xf0\x4a\xb4\x31\x70\xa9\x71\x15\x73\x43\xc9\x6b\x33\x57\x1b\x95\x90\xc4\x99\x8f\x4b\xcb\x69\xce\x26\xeb\xfb\xe8\x27\x6f\x2b\x59\xbd\x45\x9e\xab\x0a\x00\x46\xda\xde\x86\x0d\x3e\xfc\xf7\xdc\x4e\x7b\xab\x4d\x34\x2b\x67\x51\xd6\x5b\xeb\x06\xf7\xd9\x86\x7b\xe7\x62\x0e\x76\xc4\xf3\x8a\x2c\x2b\x71\xec\x4e\xbb\x39\xbe\x94\x29\x4f\xd7\xa8\x1a\x7f\x7e\xbe\x95\xf5\xb5\xee\x34\x4e\x0d\x6e\x60\x4f\x16\x55\x7a\x7e\x17\x1b\x8e\x7b\xf4\xb2\xee\xee\x30\x4b\xf0\xae\x3e\x5c\x62\x1e\x5b\x84\x68\xd8\xa2\xff\x9e\x32\x94\x1d\x95\xc1\x11\x4b\x58\x69\x78\xd8\x8c\x5e\xb6\x69\xf9\x8b\x2e\x1b\xdf\x1d\xec\xb4\x5d\x8f\x7a\x7b\xe8\xe3\x43\x6a\xfe\x25\x7a\x96\xde\xcb\x6e\x7d\x7c\xb5\x7f\xa9\xfe\x04\x00\x00\xff\xff\xac\x87\xca\xbe\xaf\x02\x00\x00" +var _transactionsDelegateeExecute_all_delegated_updatesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x92\x4f\x8b\xd5\x30\x14\xc5\xf7\xfd\x14\x87\xb7\x18\x5b\x90\xbe\xfd\x43\x1d\xf4\xcd\x66\x36\x22\x0c\xba\xbf\x2f\xbd\x6d\x03\x69\x52\x6e\x6e\x50\x19\xe6\xbb\x4b\x93\xbc\xfa\x14\x45\x30\x9b\xfe\xc9\xb9\xe7\xfc\x72\x5a\xbb\xac\x41\x14\x87\x27\xa5\x89\x87\x73\xf0\x2a\x64\xf4\xf3\x3a\x90\x72\x3c\x34\xcd\xf1\x78\x44\x7d\x02\x39\x07\x93\x44\xd8\x2b\xe2\xa6\x8f\x08\x23\x06\x76\x3c\x91\xf2\x00\x53\xa7\x91\xea\x80\xf5\xf9\x1d\x59\xcf\x43\x75\x11\x9c\x69\xa5\x8b\x75\x56\x2d\xc7\x6c\xff\x31\x28\x9f\xf0\x38\x42\x67\x16\x06\x09\x83\x7d\x48\xd3\x7c\x1d\x89\x37\x19\x1a\x36\x19\xa2\x9d\x3c\xcb\xab\x88\x87\xba\xc3\xaf\xa1\xb3\x8d\x58\xe8\x3b\x3c\x17\xe1\x85\x31\x04\xcf\x1b\xc6\x85\xd4\xcc\x35\x6f\x48\x9c\x6d\x84\x7c\x24\xa3\x36\x6c\x94\xcb\x9a\x94\xf2\xbd\xb3\x8b\xd5\xac\x6c\x6e\x25\xcf\x4d\x03\x00\x8e\x75\xa7\xe1\x13\x28\xe9\xdc\x16\xcc\x6b\x77\x1d\xee\xfe\x58\x66\xbf\xa3\x16\xa7\x55\x78\x25\xe1\xb6\x1c\xa5\x5a\x7d\x08\x22\xe1\xeb\x17\x72\x89\x3b\xdc\xbd\x37\x26\x24\xaf\x1d\x9e\xf3\xc4\xb6\x22\xbb\xb1\xdf\x01\xf0\xb6\x36\xd1\x47\x0d\x42\x13\xf7\x97\x6c\xf0\xe6\xbf\xb8\xde\xb5\x7b\xcc\x75\x8d\x12\x96\x13\xfe\x31\xf7\x54\xb2\x3f\x91\xce\xbf\x18\x74\xb8\xbf\xc7\x4a\xde\x9a\xf6\x70\x0e\xc9\x0d\xf0\x41\x51\x08\x7f\x7e\x38\x08\x8f\x2c\xec\x0d\xe7\xb4\x7a\xa0\x43\x97\xad\x5e\x4a\x57\xfc\x8d\x4d\x52\xfe\x6b\x0f\x7d\xf9\xe3\xda\x72\x91\xc7\x87\x78\xfa\x5d\x31\x71\x05\xdf\x76\xdb\xee\x6a\xff\xd2\xfc\x08\x00\x00\xff\xff\x89\xc6\x67\xeb\x02\x03\x00\x00" func transactionsDelegateeExecute_all_delegated_updatesCdcBytes() ([]byte, error) { return bindataRead( @@ -564,11 +567,11 @@ func transactionsDelegateeExecute_all_delegated_updatesCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/delegatee/execute_all_delegated_updates.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x92, 0xd6, 0x7e, 0x41, 0x66, 0x12, 0x3a, 0xd6, 0x6a, 0xfc, 0x3b, 0x66, 0xc6, 0x16, 0xbc, 0x15, 0x84, 0xc1, 0x4d, 0xbd, 0xf7, 0x8d, 0x4d, 0x31, 0x48, 0xdb, 0x7a, 0x93, 0x8c, 0x87, 0x93, 0x62}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x67, 0x38, 0x9f, 0x3, 0xf, 0x4b, 0xa6, 0xa6, 0x27, 0xc1, 0xae, 0x74, 0x6d, 0x6d, 0x7c, 0xda, 0xed, 0x13, 0x2a, 0x55, 0x7f, 0x19, 0x52, 0xbc, 0x4, 0x82, 0x5a, 0x98, 0x3b, 0x91, 0x0, 0xa9}} return a, nil } -var _transactionsDelegateeRemove_delegated_updatersCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x91\x41\x6b\xc2\x40\x10\x85\xef\xf9\x15\x8f\x1c\xda\x78\x89\x97\xd2\x43\x68\x2b\xa2\x17\x6f\xa5\xe2\xa9\xf4\xb0\x66\x27\xc9\x40\xdc\x0d\xb3\x13\x2d\x14\xff\x7b\x89\xab\x51\x68\xc1\x39\x24\xb0\x3b\xf3\xbe\x37\x6f\x79\xd7\x79\x51\xa4\x6b\x35\x35\xd9\x85\x77\x2a\xa6\xd4\x4d\x67\x8d\x52\x48\x93\x64\x3a\x9d\xe2\x83\x76\x7e\x4f\x01\xf1\x54\xb0\x30\x9d\xd9\x72\xcb\xca\x14\x70\x60\x6d\x50\xf3\x9e\x1c\x56\xcb\x80\x4a\xfc\x0e\xda\x10\x02\xd7\x8e\xe4\x31\x60\x49\x2d\xd5\x46\x89\x06\xad\x44\xc5\xb8\x60\x4a\x65\xef\x32\x39\xe9\xae\x96\xa1\xc0\xe7\x66\xe5\xf4\xf9\xe9\x6b\x82\x9f\x04\x00\x4e\x9f\x96\x14\xf6\x32\x5d\xe0\xe1\x5f\x8f\xf9\x55\x7f\x1c\xec\x84\x3a\x23\x94\x45\x0f\x05\xe6\xbd\x36\xf3\xb2\xf4\xbd\xd3\x0b\x60\xa8\x40\x6d\x95\x8f\x00\xbc\x9e\x3d\xe7\x5b\x2f\xe2\x0f\x2f\xf7\x78\x6f\xd9\xb0\x6c\x81\x3b\x6d\x6b\xf5\x62\x6a\x7a\x37\xda\x4c\x46\xf4\x50\xb3\x19\x3a\xe3\xb8\xcc\xd2\x85\xef\x5b\x0b\xe7\x15\x11\x7d\xcd\x0c\x42\x15\x09\xb9\x92\x62\xb2\xd1\x61\x1a\x85\x8e\xc9\xe9\x47\xdf\x54\xf6\x4a\x37\x8b\x55\x5e\xc0\x16\xec\x30\x46\x7c\x73\xfb\x77\xf5\x3c\xb6\x5d\xa8\xf6\xfc\xd0\x19\xdb\x02\x6c\xaf\xae\x8f\x67\xec\x31\xf9\x0d\x00\x00\xff\xff\xb7\x8e\x0c\x80\x37\x02\x00\x00" +var _transactionsDelegateeRemove_delegated_updatersCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x92\xb1\x6b\xeb\x30\x10\xc6\x77\xff\x15\x1f\x1e\xde\xb3\x17\x67\x79\xbc\xc1\xb4\x0d\x6d\xb2\x64\x2b\x0d\xe9\x52\x3a\x28\xd6\xd9\x16\x38\x92\x39\x9d\x93\x42\xc9\xff\x5e\x6c\xd9\x4e\x4a\x0b\xa5\x37\x48\x20\xe9\x7e\xdf\x77\x77\x32\x87\xd6\xb1\x20\xde\x8a\xaa\x48\xaf\x9c\x15\x56\x85\xec\x5a\xad\x84\x7c\x1c\x45\x8b\xc5\x02\x4f\x74\x70\x47\xf2\x08\xa7\x8c\x95\x6a\xd5\xde\x34\x46\x0c\x79\x9c\x8c\xd4\xa8\xcc\x91\x2c\x36\x6b\x8f\x92\xdd\x01\x52\x13\xbc\xa9\x2c\xf1\x5f\x8f\x35\x35\x54\x29\x21\xea\x59\x91\xb0\xb2\x5e\x15\x62\x9c\x4d\x78\xe0\x6e\xd6\x3e\xc7\xcb\x6e\x63\xe5\xff\xbf\xd7\x14\xef\x11\x00\x0c\x4b\x43\x02\x3d\x65\xe7\x50\x9d\xd4\x49\xf0\x92\xe2\xcf\xb7\x86\xb3\x8b\xd8\x4c\x69\x99\x5a\xc5\x94\x04\x43\x23\xe6\xc1\x31\xbb\xd3\xb3\x6a\xba\x9e\x75\x5f\x14\xae\xb3\x32\x89\xf7\xe1\xa9\x29\xb3\x59\x1c\xb7\x63\x3d\x99\x17\xc7\xaa\xa2\x6c\x3f\x00\x6e\x7e\xe5\xe9\x2e\x99\xf1\x53\xf4\xed\xca\xf1\x43\xde\x36\x68\x3e\x2a\xa9\x3f\x01\x52\x2c\x97\x68\x95\x35\x45\x12\xaf\x5c\xd7\x68\x58\x27\x08\xce\x2e\x6d\x07\x53\x49\x4c\xb6\xa0\x30\x9c\x50\x48\x9c\x0e\xa8\x73\x34\x6c\xf4\x46\x45\x27\x74\x55\x7f\xe9\x18\x46\xc3\x58\xcc\x53\xba\xba\xfd\xda\xa1\x2c\x3c\x9b\x54\xf5\xf8\x57\x12\xa3\x73\x18\x9d\xce\x99\xe7\x51\xf6\x1c\x7d\x04\x00\x00\xff\xff\x8e\xca\x0c\x47\x7a\x02\x00\x00" func transactionsDelegateeRemove_delegated_updatersCdcBytes() ([]byte, error) { return bindataRead( @@ -584,11 +587,71 @@ func transactionsDelegateeRemove_delegated_updatersCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/delegatee/remove_delegated_updaters.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x58, 0xf8, 0x29, 0xad, 0x7c, 0x48, 0x9a, 0x92, 0x3f, 0x52, 0x6c, 0xdd, 0x80, 0x82, 0x3f, 0x5, 0xe8, 0xe6, 0xc7, 0x92, 0xb9, 0xef, 0x7, 0x1a, 0xfd, 0x8a, 0x24, 0x81, 0x5b, 0xf6, 0x52, 0x51}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf9, 0x6, 0x7c, 0xa2, 0x21, 0x5a, 0xf5, 0xbf, 0xde, 0x53, 0xb5, 0x97, 0xa, 0x7b, 0xca, 0xc7, 0x13, 0x68, 0x40, 0x4d, 0x36, 0xce, 0x87, 0x28, 0xba, 0xb2, 0xc, 0x9c, 0x9c, 0x7b, 0xf2, 0x14}} return a, nil } -var _transactionsHostPublish_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x55\xef\x6b\xe3\x46\x10\xfd\xae\xbf\x62\xe2\xc2\x55\x06\xd7\xfe\x6e\x2e\x77\x84\x94\xe3\x0a\xe5\x08\xa4\xfd\x5c\xc6\xab\xb1\x34\x64\xbd\xbb\xcc\x8e\xec\x98\x92\xff\xbd\xac\x7e\xd8\x92\x63\xa5\xc9\xe9\x8b\xb1\xbd\xf3\xde\xbc\x37\xf3\xb4\xbf\xa0\xb5\xfe\x70\x67\x8c\xaf\x9d\xfe\xc9\xee\x89\x5d\x99\x65\xbc\x0b\x5e\x14\x66\x8f\x8a\x25\x15\xf7\xde\xa9\xa0\xd1\xbf\x43\x81\x4a\x71\x96\x65\xab\xd5\x0a\xd2\xe1\x08\x5a\x11\x44\x2e\x1d\xc9\xaf\x11\xee\x6a\xad\x3a\x28\x40\x57\x00\x39\x83\x21\xd6\x36\x55\x01\x3b\x40\xf8\xee\xa3\x82\x50\xf4\xb5\x18\x5a\x40\xa8\x37\x96\x63\xc5\xae\xec\xff\xbb\xc7\x80\x1b\xb6\xac\x47\xd8\x7a\x69\xe1\x03\x19\xde\x32\x15\x0d\xad\x90\xe1\xc0\xe4\x74\x09\x7f\x55\x1c\xe1\xe0\x6b\x9b\x98\x70\x63\xa9\x39\x7e\x3a\x00\xea\x81\x9e\xc9\xd4\x4a\x80\xb2\x61\x15\x94\x23\x98\x4e\x0c\xd4\xad\x1a\xf0\x6e\x2c\x62\x43\x15\xda\xed\x32\x91\x65\x2a\xe8\x22\x1a\x65\xef\xf2\xae\xd7\x6f\x5e\xd6\x70\x57\x14\x42\x31\xce\xe1\xdf\x2c\x03\x00\x08\x42\x01\x85\xf2\x16\x64\x3d\x34\xe2\x74\x26\x3d\xab\x15\xfc\x4e\xc2\x7b\x82\x80\x5a\xc5\x46\xe2\xd0\xb4\x4f\x17\x26\x30\xc5\x05\x70\x41\x4e\x79\x7b\x4c\x2e\x8d\x05\x7a\x37\x70\xf0\x44\x62\x49\x01\x5b\xc0\x7b\x0c\x0f\xc2\x7b\x54\x7a\x40\xad\xe0\x16\x06\xdf\xf2\x53\x41\xff\x74\x44\x9c\x14\x5c\x1f\xfd\xdd\x09\xf6\x9f\xd9\xd2\x78\x67\x50\x3b\xcd\x4b\x6c\x2d\x59\xaa\x7f\x54\x61\x57\xe6\xf3\xf9\x88\x60\x7e\x33\x6a\xb0\xf2\x51\xa7\x5b\xfb\xff\x4e\x92\x4f\xe7\x1e\xce\xb3\x19\xf2\xcf\x6f\x46\xce\x3f\x92\xd6\x61\xb8\x60\xde\x41\xed\x0a\x12\xdb\x58\x9b\x74\xa4\xcf\xd4\x59\xef\xdf\xa9\x9c\xb7\x70\xd3\x09\x2d\x49\xcf\x18\x9f\x3f\x0d\xc6\xf7\x25\xbf\x6a\xfb\x7c\x69\x2a\x32\x4f\x79\xda\x84\xa1\x23\x1d\x5e\xed\x2c\xbb\xa7\x89\xd2\x6b\x05\xe9\x78\xc7\xf8\x9e\xaa\xf4\x7c\xfd\x0a\x01\x1d\x9b\x7c\xf6\x20\x7e\x63\x69\x07\xb6\x8d\xfa\x68\xfb\xce\xb2\x66\x67\x88\x97\x89\xbd\x82\x5b\xf8\x69\x43\xce\x63\xc1\x18\x49\x86\x32\x7a\xaf\x16\xb0\xa3\x18\xb1\xa4\x35\xcc\xfe\x70\x7b\xb4\x5c\x4c\xf4\x0a\x42\x2a\x4c\x7b\x2a\x66\xf3\x2b\xf3\xbe\x78\xe3\x1c\x04\x43\xe8\x93\x14\x84\xf6\xec\xeb\x68\x9b\xd7\xc2\x96\xcb\x5a\xa8\xe8\x35\x82\x49\x14\xd8\x70\x0c\xf7\xa0\x53\xad\xc7\x40\x39\xea\x1a\xae\xae\xe7\x32\xd1\x3e\xaa\x17\x2c\x5b\xc9\x70\x7b\x0b\x8e\xed\xf5\x15\x88\xb8\xa7\xd7\x71\xfc\xfc\xdb\x04\xb6\x11\x42\xa5\x1f\x74\x48\x24\x03\xef\xd6\x83\xf1\xcc\x17\xaf\xf0\xd4\xbf\xb3\xd9\x71\x6e\xaf\x6c\xc2\x74\x1a\xa6\xf1\xbf\xe4\x17\x91\x7f\x5f\x2c\x2e\x8b\xa6\x02\xf1\x21\xea\x05\x28\x4a\x49\xef\x1e\xde\x44\x18\x12\xea\x5b\x49\xf8\x88\x19\xaf\x22\xd1\x81\xbf\x95\x87\xcb\x0b\x73\x2a\x08\xdf\xd8\xa1\xb5\xc7\xfe\xae\x68\x56\xff\xb2\x56\x7d\xf3\x73\xbf\xfb\x5a\xa1\xc2\x81\xad\x85\xa8\x5e\xda\x8b\xb5\x15\x20\xd9\x85\xfb\xec\x36\xfe\x79\xd9\x61\x8f\xb7\xb8\xd3\x30\x5e\x45\x87\x3b\x9a\x32\xbe\xc1\xfa\xde\x56\x75\x9d\xfd\xc0\x1d\x3d\x08\x6d\xf9\xf9\xed\x97\xfd\x98\xe4\x74\x47\xae\xe1\x7c\x3c\x1b\xef\xf4\x4b\xf6\x92\xfd\x17\x00\x00\xff\xff\x61\x05\xe9\x2d\xff\x08\x00\x00" +var _transactionsDependencyAuditAdminAdd_excluded_addressesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x8f\xbd\x4e\x2b\x31\x10\x85\xfb\x7d\x8a\xb9\x5b\xe4\x7a\x9b\x7d\x80\x15\x62\x65\x7e\x7a\x24\x24\x1a\x44\x31\x78\x86\xc4\xd2\xae\xc7\x1a\x8f\x05\x08\xe5\xdd\x51\x70\x12\x21\x8a\xb8\x3a\xc5\xf1\x99\xef\x8b\x6b\x16\x35\xe8\xef\x38\x73\x22\x4e\xe1\xd3\x57\x8a\xd6\x77\x9d\x29\xa6\x82\xc1\xa2\x24\x87\x44\xca\xa5\x70\x99\xe0\xd9\xb7\xfc\x32\xc0\x57\x07\x00\x90\x95\x33\x2a\xbb\x12\xb7\x89\x75\x02\xac\xb6\x73\x37\xa2\x2a\xef\x4f\xb8\x54\x1e\x60\xe3\x43\x90\x9a\xec\xf4\xe3\xf0\x5a\x7b\x2c\x26\x8a\x5b\x1e\x5f\x7f\xfa\x57\x9b\x3f\x18\xa3\xa7\x35\xa6\x58\x4c\xd1\x44\xaf\xdd\x9b\xca\x3a\xc1\xc5\xd2\x63\x5b\x7c\x40\xdb\x0d\xf3\x88\x44\xf7\x1f\x61\xa9\xc4\xe4\x4f\x0e\xbf\x6d\xce\x71\x38\x93\xcd\x33\x64\x4c\x31\xb8\xfe\x56\xea\x42\x90\xc4\xa0\xe1\x5d\x3e\x0c\x07\xb8\xa3\xd7\xff\x02\x47\xb3\x7f\x7d\x5b\xde\x77\xfb\xee\x3b\x00\x00\xff\xff\x6d\xfb\xa6\x63\x6c\x01\x00\x00" + +func transactionsDependencyAuditAdminAdd_excluded_addressesCdcBytes() ([]byte, error) { + return bindataRead( + _transactionsDependencyAuditAdminAdd_excluded_addressesCdc, + "transactions/dependency-audit/admin/add_excluded_addresses.cdc", + ) +} + +func transactionsDependencyAuditAdminAdd_excluded_addressesCdc() (*asset, error) { + bytes, err := transactionsDependencyAuditAdminAdd_excluded_addressesCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "transactions/dependency-audit/admin/add_excluded_addresses.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xca, 0xc7, 0x29, 0xa9, 0x25, 0x5f, 0x20, 0x67, 0x78, 0xdf, 0x13, 0x90, 0xbc, 0xec, 0x51, 0x9f, 0x3c, 0xd9, 0xbd, 0x2c, 0xfa, 0x19, 0x3c, 0xd2, 0x6f, 0x31, 0x7c, 0x86, 0x45, 0x5f, 0x62, 0x93}} + return a, nil +} + +var _transactionsDependencyAuditAdminSet_unstaged_cause_panicCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x8f\x41\x4b\xc4\x40\x0c\x85\xef\xfd\x15\xb1\x87\x75\x7a\xe9\x0f\x28\x62\xe9\xea\xdd\x05\xd1\x7b\x9c\x89\xed\x40\x9b\x0c\x99\x0c\x22\xb2\xff\x5d\xba\x5d\x17\xf5\xb0\xb9\x25\x79\xef\xf1\xbd\xb8\x24\x51\x83\xfa\x91\x12\x71\x20\xf6\x9f\x43\x09\xd1\xea\xaa\x32\x45\xce\xe8\x2d\x0a\xbb\x3c\x49\x99\xc3\x01\x39\xfa\x0e\xf6\x22\x73\x03\x5f\x15\x00\x40\x52\x4a\xa8\xe4\x72\x1c\x99\xb4\x03\x2c\x36\xb9\xbd\xa8\xca\xc7\x2b\xce\x85\x1a\xd8\x0d\xde\x4b\x61\xfb\x71\xac\xb3\xa9\xdb\x6c\xa2\x38\x52\xfb\x76\xd2\xdf\xed\xfe\x31\xb4\x43\x58\x22\xc7\x6c\x8a\x26\x7a\xef\xde\x55\x96\x0e\xae\x8a\x9e\xb7\xc4\x03\xda\xd4\xf4\x6d\x26\x3b\x21\x3f\xf1\x0b\x67\xc3\x91\xc2\xc5\x1c\x29\xff\x2d\xf5\x6b\x69\x2e\x9c\x7d\x0f\x69\xbd\xb8\xfa\x61\xfd\x02\x8b\xc1\x06\x7b\x1d\x03\x56\xd4\x73\xcb\xdb\x0c\xe7\x9e\x37\xf5\x96\x7c\xac\x8e\xd5\x77\x00\x00\x00\xff\xff\xa4\x32\xd6\x10\x77\x01\x00\x00" + +func transactionsDependencyAuditAdminSet_unstaged_cause_panicCdcBytes() ([]byte, error) { + return bindataRead( + _transactionsDependencyAuditAdminSet_unstaged_cause_panicCdc, + "transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc", + ) +} + +func transactionsDependencyAuditAdminSet_unstaged_cause_panicCdc() (*asset, error) { + bytes, err := transactionsDependencyAuditAdminSet_unstaged_cause_panicCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x41, 0x2a, 0x20, 0x60, 0x49, 0x17, 0xc6, 0xaf, 0xd7, 0x32, 0x8c, 0xef, 0x2a, 0x74, 0x1d, 0x95, 0xda, 0xdf, 0x58, 0xea, 0x81, 0x60, 0xee, 0x68, 0x21, 0xee, 0x74, 0x3d, 0xb0, 0xc5, 0x39, 0x62}} + return a, nil +} + +var _transactionsDependencyAuditAdminTest_check_dependenciesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x90\xc1\x4a\xc3\x40\x10\x86\xef\x79\x8a\x31\x87\x9a\x40\xc9\x03\x04\x31\xc4\xf6\x2c\x42\xc1\x8b\xf4\xb0\xee\x8e\xc9\x62\x33\x13\x66\x26\x88\x4a\xdf\x5d\x9a\xa4\x12\xa5\x74\x4f\x0b\xf3\xcd\xf0\x7f\x7f\xec\x7a\x16\x83\x74\x8b\x3d\x52\x40\xf2\x9f\xf5\x10\xa2\xa5\x49\x62\xe2\x48\x9d\xb7\xc8\x94\x85\xf3\x34\xa2\xd6\x21\x08\xaa\xa2\x96\xf0\x32\xff\xf7\x6b\x58\x12\x8f\xae\x1b\xa7\x3b\x93\x48\xcd\x7e\x0d\x6e\xb0\x96\x25\x7e\xa1\x2c\x97\x72\xf8\x4e\x00\x00\x7a\xc1\xde\x09\x66\x1a\x1b\x42\x29\x47\x3a\x7b\x60\x11\xfe\x78\x76\x87\x01\x73\x58\xd5\xde\xf3\x40\x76\xde\x38\xbd\x89\x2e\xd4\x58\x5c\x83\xc5\xeb\xc8\xdf\xad\xfe\x79\x14\x75\xe8\x22\x45\x35\x71\xc6\x72\x9f\xbd\x09\x77\x25\x5c\x85\x76\xd3\xc5\x27\x67\x6d\x5e\x15\x86\x6a\x9b\x16\xfd\xfb\x76\x21\x78\xb9\x8f\x0b\x25\xfc\x51\xcf\x7f\xb3\x57\x15\xf4\x8e\xa2\xcf\xd2\x0d\x0f\x87\x00\xc4\x06\x93\xc0\xf5\x68\x70\x8a\x3f\x9b\xdf\x2a\xcc\xee\x37\xe9\x74\xf9\x98\x1c\x93\x9f\x00\x00\x00\xff\xff\xa4\xad\xb1\xdb\xcf\x01\x00\x00" + +func transactionsDependencyAuditAdminTest_check_dependenciesCdcBytes() ([]byte, error) { + return bindataRead( + _transactionsDependencyAuditAdminTest_check_dependenciesCdc, + "transactions/dependency-audit/admin/test_check_dependencies.cdc", + ) +} + +func transactionsDependencyAuditAdminTest_check_dependenciesCdc() (*asset, error) { + bytes, err := transactionsDependencyAuditAdminTest_check_dependenciesCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "transactions/dependency-audit/admin/test_check_dependencies.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x49, 0x18, 0xac, 0xc8, 0xd0, 0xca, 0xcd, 0x4, 0x83, 0x86, 0xbb, 0xac, 0x9d, 0x37, 0x5c, 0xeb, 0xc7, 0xb0, 0x7b, 0xf8, 0x6f, 0x9d, 0x88, 0x27, 0x5b, 0x11, 0xed, 0xca, 0x93, 0xd, 0xe7, 0x13}} + return a, nil +} + +var _transactionsHostPublish_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x56\x5d\x6f\xe3\x36\x10\x7c\xd7\xaf\xd8\xb8\x40\x2a\x01\xae\xfc\x6e\x24\x17\x5c\x53\x1c\x2e\x40\x71\x08\xe0\xb6\xaf\xc5\x9a\x5a\x4b\xec\xd1\x24\x41\x52\x76\x8c\x20\xff\xbd\xa0\x44\xea\xc3\x96\x3f\xda\xd3\xcb\xf9\x9c\xe5\xce\xec\xec\x68\xcc\x9f\x50\x08\xb5\xff\xcc\x98\xaa\xa5\xfb\x9d\xcb\xef\x5c\x96\x49\xc2\xb7\x5a\x19\x07\xb3\x95\xc3\x92\x8a\x67\x25\x9d\x41\xe6\xfe\xd4\x05\x3a\xb2\xb3\x24\x59\x2c\x16\xe0\x8b\x2d\xb8\x8a\xc0\xf2\x52\x92\xf9\xd9\x42\x68\x03\x28\x0b\x20\xc9\x50\xdb\x5a\xf8\x13\xc0\x25\x20\x7c\x55\xd6\x81\x21\xab\x6a\xc3\x68\x0e\xba\x5e\x0b\x6e\x2b\x2e\xcb\xf8\xb7\x67\xd4\xb8\xe6\x82\xbb\x03\x6c\x94\x69\x5b\x6b\x62\x7c\xc3\xa9\x68\x20\x0d\x31\xae\x39\x49\x97\xc3\x1f\x15\xb7\xb0\x57\xb5\xf0\x48\xb8\x16\xd4\x94\x77\x05\xe0\x14\xd0\x1b\xb1\xda\x11\xa0\x59\x73\x67\xd0\x1c\x80\x85\x41\xa0\x6e\x27\x01\x25\xc7\x03\xac\xa9\x42\xb1\xc9\x3d\x58\xe2\x0c\x4a\x8b\xcc\x71\x25\xd3\xc0\xf5\x8b\x32\x4b\xf8\x5c\x14\x86\xac\xcd\xe0\x3d\x49\x00\x00\xb4\x21\x8d\x86\xd2\xb6\xc9\x12\xb0\x76\x55\xfa\xab\x32\x46\xed\xff\x42\x51\xd3\x1c\x9e\x95\x3e\x84\x8f\x2f\xd6\xd6\x14\x64\xea\xc7\x6d\x04\x56\x42\x90\x09\x15\x2b\xa7\x0c\x96\x34\x5d\xf1\xda\x92\x79\x91\x6b\xf5\xd6\x57\xcc\x61\x85\x3b\x6a\x60\x32\xb8\x0f\x10\x1d\x49\xff\x2c\x16\xf0\x1b\x19\xbe\x23\xd0\xe8\x2a\xdb\x68\x1c\x37\x76\x7f\xb4\x01\x4e\x76\x0e\xbc\x20\xe9\xf8\xe6\xe0\x57\x34\x56\x57\xc9\xc1\xfa\x3a\x00\x41\x0e\xb0\x9b\x2d\xcc\xf0\x8a\xae\x82\x47\x18\xfc\x2f\xed\x0e\xc4\x27\x00\x71\x2f\xdf\xb4\xe7\x7a\xc9\xfe\x9e\xe5\x4c\x49\x86\x2e\x08\x9e\x63\xbb\x8f\xdc\xa9\x95\x33\x5c\x96\x69\x96\x8d\x00\xb2\xbb\x11\xc1\x4a\xd9\xcb\xec\xae\x93\xf9\xda\xb6\xe8\x99\xf4\xf6\x18\xb2\xc8\xee\x7a\xed\x77\x68\x06\xd2\x2c\x07\x56\x7f\x68\xfc\xd2\x76\x8e\x38\xfd\x02\x3f\x3d\xc1\x23\x48\x2e\x86\x4b\x5c\x91\xab\xf5\xf0\x65\x51\x12\x6a\x59\x90\x11\xcd\xa6\xbc\x2c\xfe\x5f\x3f\x68\xc4\xec\x8e\xf3\x4d\x30\x7b\x6e\xdb\x91\x73\x77\xd0\x94\xa2\x5b\x4e\x6f\x2e\x83\xc7\x06\x1f\xde\x47\x9a\xf6\xb5\xf0\x18\x1b\xb2\x81\x77\xf2\x50\x90\x73\xef\xe6\x2b\x23\xa6\xe3\x7d\x1d\xf1\xb3\xb8\xa3\xb4\xc7\x9b\x83\x53\xe7\xb8\x76\x6d\x3e\x80\x84\xa5\x1b\x38\x47\x10\xa6\xf4\xe1\xe1\xe6\x9d\x7c\x4a\x37\x46\x6d\xaf\xb2\x88\xcf\xd3\x13\x68\x94\x9c\xa5\xb3\x17\xb9\x43\xc1\x0b\x50\xeb\x7f\x88\xf9\x2c\x74\x86\xd3\x8e\x0a\x68\xfb\x75\x7e\x9a\x6c\x3c\xb2\x56\x3f\x6a\xef\x31\xb4\x96\xcc\xf0\x30\xdc\xb5\xbb\xbb\xbf\x1f\x50\xbd\xcb\x59\x45\xec\x7b\x9a\xcd\x61\x4b\xd6\x62\x49\x4b\xe8\x88\xc5\x38\x18\x98\xab\x23\x39\xcb\x92\x53\x17\x1e\x65\xfa\xde\xa0\xd6\x31\x2e\xb4\xa1\x1d\x57\xb5\x15\x4d\xf0\x6e\x78\x59\x1b\x2a\x22\x13\x68\xec\x82\x0d\xc6\x2d\xee\x9c\x7c\x11\x73\x0f\x7f\xdd\xad\x53\x8e\x3a\xd9\xd2\xc3\x2f\x67\x30\x98\x21\x74\xf4\x8d\xf6\x1e\x2c\x1d\xbe\xc4\x03\x51\xb3\xf9\x49\x43\xef\xd3\x9b\x58\x8f\xd3\x6a\xb0\xd9\xf8\xc9\x87\x47\x88\xad\x1b\x92\xe3\x3c\xe6\x49\x98\x5c\xd0\xfb\x34\x26\x7f\x44\xdc\xa9\x88\x88\x27\x2e\x45\xc4\x85\x59\xd2\xdb\x1c\x31\xbd\x97\xd3\xe9\xae\x2e\x21\x1c\xf9\xbf\xd9\x71\x61\x92\x18\x27\x13\x92\x8f\x58\xfd\xf7\x1c\x39\xed\x38\x0e\x91\xe3\xe8\x88\x33\xf6\xb9\x11\xbe\xb9\x18\x1a\xc7\x77\xb7\x73\x89\xf1\x85\x4b\x14\xe2\x10\x6f\x0e\x4d\x46\x1c\x9f\x75\xaa\xf9\x3a\x86\x84\xab\xd0\xc1\x9e\x0b\x01\x5e\xed\xf6\x8e\xd7\x6a\x67\x92\x23\x6f\x71\x7f\x1d\xca\x43\xef\xb1\x03\xe3\x10\x63\x2f\x48\xdc\xd2\xb9\x37\xb4\x69\x16\x7e\xe6\x03\xb5\x6f\xb8\xa5\x57\x43\x1b\xfe\x76\xf9\x57\x7f\x0c\xd2\x5d\x99\x96\xd0\x97\x27\x63\x9f\x7d\x24\x1f\xc9\xbf\x01\x00\x00\xff\xff\x00\x86\x3f\x21\x87\x0b\x00\x00" func transactionsHostPublish_host_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -604,11 +667,11 @@ func transactionsHostPublish_host_capabilityCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/host/publish_host_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x13, 0xdd, 0x56, 0xa, 0x87, 0x86, 0xe2, 0x87, 0x7c, 0x86, 0xbe, 0xef, 0xd0, 0x2f, 0x48, 0x5a, 0x14, 0x91, 0x51, 0xd6, 0x3e, 0x77, 0x20, 0x66, 0x9a, 0x78, 0x28, 0xf2, 0x51, 0xb0, 0x88, 0xbc}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb, 0xa0, 0xc8, 0xeb, 0x7c, 0xd3, 0x21, 0x13, 0x4f, 0xa5, 0xbf, 0xd6, 0xea, 0x8, 0x30, 0x61, 0x21, 0x29, 0x65, 0xdf, 0xeb, 0xc7, 0xf0, 0x27, 0xff, 0xce, 0x32, 0xdf, 0x4e, 0x7, 0xc2, 0xbb}} return a, nil } -var _transactionsMigrationContractStagingAdminCommit_migration_resultsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x92\x41\x6b\x14\x41\x10\x85\xef\xf3\x2b\x9e\x73\x58\x36\x20\xb3\x17\xf1\x30\xb8\x86\x65\xd1\x9b\x10\x5c\x3d\x89\x87\x4a\x6f\xcd\x4c\x43\x77\xd7\x50\x5d\x83\x01\xc9\x7f\x97\xd9\xce\xac\x66\x63\xf4\x90\xbe\x35\x54\xd5\x57\xf5\xde\xf3\x71\x14\x35\xd4\x9f\x7c\xaf\x64\x5e\xd2\x5e\x92\x29\x39\x3b\x18\xf5\x3e\xf5\x75\x55\x6d\x36\x1b\xec\x25\x46\x6f\x19\x36\x30\x94\xf3\x14\x2c\x43\x3a\x48\xd7\xb9\x81\x7c\x02\xc7\x29\x90\xf1\x11\x71\x99\x33\xb7\x55\xa6\x94\x32\xb9\xf9\xbf\xce\x89\xc6\x3c\x88\x7d\xf1\x91\xb3\x51\x1c\x5b\x7c\xfd\xe8\xef\xde\xbe\x79\x8d\x8e\x7c\xe0\xe3\x42\xce\x2d\xbe\x1d\x4c\x7d\xea\xbf\x5f\xe1\x67\x05\x54\x00\x10\xd8\x40\xc7\xe8\x53\x8b\xd5\x73\xcb\x36\xbb\xb9\xa0\x3a\xd5\x8f\xca\x23\x29\xaf\xb3\xef\x13\x6b\x8b\xdd\x64\xc3\xce\x39\x99\x92\x95\xa9\xe5\x65\x0e\x5d\x73\x9a\x8b\x2d\x4a\x6d\x73\x2b\xaa\xf2\xe3\xdd\x7f\x30\xef\xd7\x9d\x4a\x6c\xf1\xef\xaa\x83\x89\x52\xcf\x37\x64\xc3\xd5\x19\x3a\xbf\xeb\x6b\x8c\x94\xbc\x5b\xd7\x7b\x99\xc2\x11\x49\x0c\x05\x8c\x53\x23\x94\x3b\x56\x4e\x8e\xeb\xd2\x78\x5f\xee\xe2\x3b\x76\x93\xf1\x5f\x4f\x68\xdc\xc9\xa6\xf3\x46\x9f\x8b\x53\x67\xe9\x5b\x3c\x31\x61\x11\xbf\xbd\x34\xe1\x11\x74\x94\x6c\x7f\x10\x9f\x3d\x39\x50\xb6\x0f\x0f\x51\xb8\xd8\xe2\x55\x73\x01\xc0\x76\x7b\xc9\xc4\x6a\xf5\x42\xc6\x72\xdf\x3c\xfc\x69\xe0\x1e\x19\x50\xdf\xa8\xdc\x06\x8e\x28\xa2\x99\x4f\xfd\xef\xf4\x2e\x21\xaf\x1f\x54\xb8\xaf\x7e\x05\x00\x00\xff\xff\xef\x31\x98\xb4\x29\x03\x00\x00" +var _transactionsMigrationContractStagingAdminCommit_migration_resultsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x92\x4f\x8b\xd4\x40\x10\xc5\xef\xf9\x14\xcf\x1c\x86\x0c\x48\xe6\x22\x1e\x82\xe3\xb2\x0e\x7a\x13\x16\x47\xbd\x88\x87\xda\x9e\x4a\xd2\xd0\x7f\x42\x75\x05\x17\x64\xbf\xbb\x24\xbd\x19\xdd\xac\xa3\x87\xed\x5b\x43\xbd\xfa\x55\xd5\x7b\xd6\x0f\x51\x14\xe5\x47\xdb\x09\xa9\x8d\xe1\x10\x83\x0a\x19\x3d\x2a\x75\x36\x74\x65\x51\xec\x76\x3b\x1c\xa2\xf7\x56\x13\xb4\x67\x08\xa7\xd1\x69\x42\x6c\x11\xdb\xd6\xf4\x64\x03\xd8\x8f\x8e\x94\x4f\xf0\x4b\x9f\x49\x56\xa8\x50\x48\x64\xa6\x7f\x95\x02\x0d\xa9\x8f\xfa\xd9\x7a\x4e\x4a\x7e\x68\xf0\xe5\x83\xbd\x7b\xfd\xea\x25\x5a\xb2\x8e\x4f\x0b\x39\x35\xf8\x76\x54\xb1\xa1\xfb\xbe\xc5\xcf\x02\x28\x00\xc0\xb1\x82\x4e\xde\x86\x06\x9b\x4b\xc3\xd6\xd7\x53\x41\x31\xd7\x0f\xc2\x03\x09\x57\xc9\x76\x81\xa5\x01\x8d\xda\x57\xef\xa2\x48\xfc\xf1\x95\xdc\xc8\x5b\x6c\xae\x8d\x89\x63\xd0\x0c\xc9\x2f\xb1\x6b\xeb\x19\x83\x3d\xb2\xb4\x4e\x1a\x85\x3a\xae\x6f\x67\xf1\x9b\xff\xd0\xdf\x56\xad\x44\xdf\xe0\xdf\x55\xc7\xdc\xf3\x86\xb4\xdf\x9e\xe1\xd3\xbb\xba\xc2\x40\xc1\x9a\xaa\x3c\xc4\xd1\x9d\x10\xa2\x22\x83\x31\x0b\x21\xdc\xb2\x70\x30\x5c\x66\xe1\x7d\x5e\x97\xef\xd8\x8c\xca\x7f\x5d\xa5\x36\xb3\x7b\xe7\x89\x3e\x65\x03\xcf\x8e\x34\x78\xe2\xcd\xe2\x49\xb3\xf6\xe6\x11\x74\x88\x49\xff\x20\x5e\x5c\xd9\x51\xd2\xf7\x0f\x09\x59\x4d\xf1\xa2\x5e\x01\xb0\xdf\xaf\x99\xd8\x6c\x9e\xc9\x58\xf6\x9b\x9a\x3f\xcd\xe1\x23\x03\xca\x1b\x89\xb7\x8e\x3d\xf2\xd1\xd4\x86\xee\x77\xa8\x97\xec\x97\x0f\x57\xb8\x2f\x7e\x05\x00\x00\xff\xff\x1f\x33\x4f\xd9\x40\x03\x00\x00" func transactionsMigrationContractStagingAdminCommit_migration_resultsCdcBytes() ([]byte, error) { return bindataRead( @@ -624,11 +687,11 @@ func transactionsMigrationContractStagingAdminCommit_migration_resultsCdc() (*as } info := bindataFileInfo{name: "transactions/migration-contract-staging/admin/commit_migration_results.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x53, 0xf2, 0x81, 0x97, 0xf5, 0xe7, 0x3b, 0xf8, 0xa6, 0x2b, 0x9, 0xc0, 0x1e, 0x93, 0xc9, 0x14, 0x8c, 0xb8, 0x71, 0x7e, 0xda, 0xb6, 0x94, 0xf9, 0xf3, 0x68, 0x50, 0x97, 0xd2, 0x82, 0x44, 0xd7}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x86, 0xa7, 0xae, 0x13, 0xdd, 0xf8, 0x9, 0x7e, 0x99, 0x3b, 0x8f, 0xa4, 0x36, 0xab, 0x6a, 0x2c, 0xfa, 0x1d, 0x9c, 0xc5, 0x24, 0x5f, 0x60, 0x88, 0x2, 0x1c, 0xf, 0x19, 0x14, 0x99, 0xc6, 0xa8}} return a, nil } -var _transactionsMigrationContractStagingAdminSet_staging_cutoffCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x90\xcf\x4a\xf3\x50\x10\xc5\xf7\x79\x8a\x43\x16\x1f\xe9\x26\xdd\x7c\xb8\x08\xd6\x52\xba\x72\x21\x08\xc5\x07\x98\xde\x4e\x6e\x2e\xa6\x77\xc2\xdc\x09\x55\xa4\xef\x2e\xf9\xa3\x58\xb1\x3a\xdb\x39\xe7\x77\xe6\x4c\x38\x76\xa2\x86\xfc\x21\x78\x25\x0b\x12\xb7\x12\x4d\xc9\xd9\xce\xc8\x87\xe8\xf3\x2c\x5b\x2e\x97\xd8\xb1\x25\x58\xc3\xd8\xb7\xe2\x9e\xd1\x70\xf0\x8d\x81\x0c\xa7\x26\xb8\x06\x6e\x36\x25\x38\x8a\x88\x82\x56\xa2\x67\xc5\x9e\x91\x8c\x3c\x1f\x06\x48\x66\x4a\x31\x91\x1b\x52\x0a\xd7\x9b\xd4\x75\x85\xa7\xfb\x68\x37\xff\x17\x78\xcb\x80\x0c\x00\x5a\x36\xd0\xe1\x18\x62\x85\x7f\xd7\x8e\x2a\x37\x83\x20\x1b\xf5\x9d\x72\x47\xca\x45\x0a\x3e\xb2\x56\xd8\xf4\xd6\x6c\x9c\x93\x3e\xda\x44\x9d\x26\x71\x5b\x97\x23\x17\x2b\x4c\xda\x72\x2f\xaa\x72\xba\xfd\x23\xe6\xae\xa8\x55\x8e\x15\x7e\x57\xed\x4c\x94\x3c\x3f\x92\x35\x8b\xcf\xd0\x61\xd6\x6b\x74\x14\x83\x2b\xf2\xad\xf4\xed\x01\x51\x0c\x53\x30\x46\x23\x94\x6b\x56\x8e\x8e\xf3\xc9\x78\x9e\x7a\xf1\x0b\xbb\xde\xf8\xc7\x0a\x65\xe2\x8f\xf4\xed\xf8\xc7\x82\xac\xc2\xf4\xd2\x0b\x48\x27\xc9\xbe\x10\xae\x56\xf0\xdf\x79\x0b\xac\x56\x33\xb0\xba\xa8\x93\xcf\xba\x79\x89\x13\xa5\xb1\x52\x62\x43\xa7\xd2\xb1\xb6\xaf\xf9\x7c\xc2\x39\x7b\x0f\x00\x00\xff\xff\x69\xc2\x7c\x2c\x5e\x02\x00\x00" +var _transactionsMigrationContractStagingAdminSet_staging_cutoffCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x90\xb1\xce\xd3\x40\x10\x84\x7b\x3f\xc5\xc8\x45\x64\x37\x4e\x83\x28\x2c\x42\x14\x52\x51\x20\x21\x45\xd0\x6f\x2e\xeb\xf3\x09\xe7\xd6\xda\x5b\x2b\x20\x94\x77\x47\xf6\x19\x44\x10\xf9\xff\x6d\x77\x66\xbe\x9d\x0d\xd7\x51\xd4\x50\x7e\x0a\x5e\xc9\x82\xc4\xa3\x44\x53\x72\x76\x32\xf2\x21\xfa\xb2\x28\xb6\xdb\x2d\x4e\x6c\x09\xd6\x33\xce\x83\xb8\x6f\xe8\x39\xf8\xde\x40\x86\x5b\x1f\x5c\x0f\xb7\x9a\x12\x1c\x45\x44\xc1\x20\xd1\xb3\xe2\xcc\x48\x46\x9e\x2f\x73\x48\x61\x4a\x31\x91\x9b\x29\x95\x9b\x4c\xba\xae\xc5\x97\x8f\xd1\xde\xbe\xa9\xf1\xb3\x00\x0a\x00\x18\xd8\x40\x97\x6b\x88\x2d\x36\xcf\x8e\x6a\x0e\xb3\xa0\x58\xf4\xa3\xf2\x48\xca\x55\x0a\x3e\xb2\xb6\xa0\xc9\xfa\xea\x83\xa8\xca\xed\x2b\x0d\x13\xd7\xd8\x1c\x9c\x93\x29\x5a\x86\xe4\x49\x3c\x74\xcd\x82\xc1\x0e\xd9\xda\x24\x13\x25\xcf\xcd\x79\x31\xbf\x7b\x85\xfe\xbe\xea\x54\xae\x2d\x5e\x56\x9d\x72\xe6\x67\xb2\xbe\xfe\x03\x9f\x67\xbf\xc7\x48\x31\xb8\xaa\x3c\xca\x34\x5c\x10\xc5\x90\xc1\x58\x8c\x50\xee\x58\x39\x3a\x2e\xb3\xf1\x9e\xeb\xf2\x77\x76\x93\xf1\x7f\xab\x34\x89\x7f\xd3\x8f\xcb\x7b\x2b\xb2\x16\xf9\xd3\x0f\x21\xa3\x24\xfb\x2b\xe1\x69\x05\xff\x6f\x5e\x8d\xdd\x6e\x0d\x6c\x1f\xea\x94\xab\x6e\x5d\xe2\x46\x69\xa9\x94\xd8\x30\xaa\x8c\xac\xc3\x8f\x72\x3d\xe1\x5e\xfc\x0a\x00\x00\xff\xff\x9f\x79\x02\xab\x75\x02\x00\x00" func transactionsMigrationContractStagingAdminSet_staging_cutoffCdcBytes() ([]byte, error) { return bindataRead( @@ -644,11 +707,11 @@ func transactionsMigrationContractStagingAdminSet_staging_cutoffCdc() (*asset, e } info := bindataFileInfo{name: "transactions/migration-contract-staging/admin/set_staging_cutoff.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe3, 0xc0, 0xad, 0xa2, 0x30, 0xcb, 0xd8, 0x2f, 0x53, 0xdf, 0x23, 0x66, 0xe6, 0xf8, 0x40, 0xa9, 0x73, 0xac, 0x8e, 0xc4, 0x3a, 0xcd, 0x59, 0x66, 0x54, 0x88, 0x9, 0x1f, 0x60, 0x38, 0x64, 0x2b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2e, 0xd, 0x88, 0xea, 0x3b, 0x1f, 0xf8, 0xbd, 0x99, 0xdb, 0xb7, 0xa6, 0x7b, 0x83, 0x28, 0x62, 0x8f, 0xc4, 0xf4, 0xef, 0x5e, 0xab, 0x99, 0x7e, 0xae, 0x3c, 0x26, 0x8b, 0x5b, 0xa5, 0x31, 0xf8}} return a, nil } -var _transactionsMigrationContractStagingDelegatedStagingClaim_published_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x54\x4d\x6f\xdb\x38\x10\xbd\xeb\x57\x0c\xb4\xc0\xae\x0c\x28\xd2\xe6\x6a\x6c\x36\x0d\x0c\x04\xed\xa1\x45\x00\xa7\xe7\x62\x2c\x8d\xa5\x41\x25\x8e\x40\x8e\x9c\x14\x45\xfe\x7b\x41\x52\x96\x3f\xe2\xa4\xa7\xf2\x60\x98\xe4\x70\xde\x9b\x79\x6f\xc4\xfd\x20\x56\x21\xfd\xcc\x8d\x45\x65\x31\x2b\x31\x6a\xb1\xd2\xb5\x62\xc3\xa6\x49\x93\xe4\x2f\x36\x4a\xfe\x88\xc5\x40\x96\x00\x00\xec\xc8\x3a\x16\xb3\x84\xf4\xba\xb8\x2e\xfe\x4d\xf3\x70\xaa\xac\x1d\x2d\x21\x5d\x75\xc8\x3d\x3c\x8c\x9b\x8e\x5d\x4b\x35\x7c\x14\xa7\xb0\xc2\x01\x37\xdc\xb1\xfe\x98\xa2\x6b\x72\x95\xe5\x41\x63\x9e\xf0\xc6\x01\x9e\x07\xc3\xd6\x4a\x0f\xda\xd2\xab\x8b\xc1\xca\x8e\x6b\xb2\x80\xa6\x06\xa7\x62\xc9\x01\x2b\xa0\x86\xe8\xe9\x36\xde\x60\x43\x30\xa0\xb6\xc5\x04\xdd\xa1\x69\x46\x6c\x3c\x57\x32\x57\x5f\xd7\x69\x9e\x2c\x92\xa4\x2c\x4b\x78\x6c\xd9\x81\x5a\x34\x6e\xaa\xb7\xfa\xc3\xbc\x02\x6a\xe0\xe6\xff\x85\xdd\xbd\x58\xe8\xc5\x12\x54\x62\x94\x9e\x35\x07\x47\x14\x1e\x5b\x1a\x04\xae\xa0\x55\x1d\xdc\xb2\x2c\x1b\xd6\x76\xdc\x14\x95\xf4\xa5\x98\x6d\x27\x4f\x65\x35\x89\x77\x35\x0e\x35\x2a\xd9\x39\xe7\x87\x01\x2d\xf6\xd0\x8a\xd3\xbd\x2e\x76\x09\x8f\x2d\x01\xd6\xb5\x25\xe7\x40\xb6\x01\x02\xab\x4a\x46\xe3\xb9\xa2\xc2\x30\x4b\x78\xa9\xd0\xad\xd8\x70\xee\xb8\x31\x64\x8b\x73\x9c\x15\x0e\xeb\x58\xe3\x03\x6a\xfb\xa9\x26\xa3\xbc\xe5\x3d\x2c\xcf\x7b\x18\x9d\x07\x10\xa8\xc9\xf2\x2e\x16\x7a\x2c\x1a\x3c\xb5\x64\xe9\x22\x83\x27\xee\xba\x00\xeb\xd7\x86\xc0\xe1\x8e\xea\xd8\xc8\x23\x0d\xb3\xb3\xaa\xef\x62\xc5\xf9\x6f\x58\xae\xd5\xb2\x69\x16\xf0\x33\x58\x26\xfc\x0c\x96\x06\xb4\x94\xc5\x8a\x97\x70\x37\x6a\x7b\x17\x1b\xb6\x8f\xf3\xab\x2c\x21\x8e\x40\x10\x7c\xee\xe1\x25\xf3\xc4\x4c\xff\x38\x60\xb3\x91\xe7\x39\x43\x47\x1a\x4f\xbe\x60\x4f\x70\xf3\xf6\x78\xfa\x8e\x7c\x4b\x8b\x4a\x4c\x85\x3a\xf1\x2a\x26\x49\x0b\x95\x58\x43\xb6\x58\x9c\x64\x9e\xea\x86\x9b\xbd\x74\x01\xaa\x08\x56\xff\xef\xef\xb7\xa0\x0a\x8f\xf5\x7f\x36\xd3\xca\x67\xa7\x2f\x4f\x7d\x75\x00\xf3\xeb\xf6\x16\x06\x34\x5c\x65\xe9\x2b\xf5\xd0\x81\x11\x85\xad\x8c\xa6\x06\x36\x67\xcd\x48\x17\xc9\x9c\x08\x9d\x23\xab\xd9\x44\xbc\xa8\x5a\xaa\xbe\x67\x8b\x1c\x7a\x72\x2e\xce\xf1\x63\x18\x8f\x8a\x78\x77\xda\x69\xf6\xd9\x76\xd8\x71\x7d\x9c\xaf\x2c\xc1\xab\x7e\xd9\x55\x6c\x4e\xa5\x99\xcc\x98\x47\x83\xb2\x69\x5e\x5b\x54\xcc\x89\xd6\xfe\xd5\x24\xc2\x49\xe3\xdd\xc1\x69\x70\x03\x47\xbe\xcb\xf8\xc8\x78\xef\xd9\xf2\xad\xde\xde\x23\x77\xef\x4f\xd1\x6c\xb9\xf9\x0b\x74\xc0\x4c\x0f\x69\x27\x47\xf8\x49\xda\xb7\x3b\x07\x95\xe5\x31\xf7\x18\xfd\x92\xbc\x24\xbf\x02\x00\x00\xff\xff\x85\xda\x54\x86\x3e\x06\x00\x00" +var _transactionsMigrationContractStagingDelegatedStagingClaim_published_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x54\x4d\x6b\xdc\x4a\x10\xbc\xeb\x57\x34\x7a\xe0\xa7\x05\x59\x7a\xbe\x2e\xcf\x71\xcc\x82\x89\x0f\x09\x86\x75\x72\x0d\xbd\x52\xaf\xd4\x44\x9a\x19\x66\x5a\xb2\x43\xf0\x7f\x0f\x33\xa3\xd5\x7e\x78\xed\x9c\x32\x07\x63\xcd\x47\x57\x75\x55\xf5\x72\x6f\xb4\x15\x48\x3f\x73\x63\x51\x58\xab\x95\x56\x62\xb1\x92\xb5\x60\xc3\xaa\x49\x93\xe4\x1f\x56\x42\x7e\x8b\xb5\x82\x2c\x01\x00\x18\xc9\x3a\xd6\x6a\x09\xe9\x55\x71\x55\xfc\x97\xe6\x61\x57\x58\x3a\x5a\x42\xba\xea\x90\x7b\x78\x18\x36\x1d\xbb\x96\x6a\xf8\xa4\x9d\xc0\x0a\x0d\x6e\xb8\x63\xf9\x39\xdd\xae\xc9\x55\x96\x8d\xc4\x3a\xe1\x8d\x03\x3c\xbd\x0c\x5b\xab\x7b\x90\x96\x5e\x1d\x18\xab\x47\xae\xc9\x02\xaa\x1a\x9c\x68\x4b\x0e\x58\x00\x25\xdc\x9e\x4e\xe3\x09\x36\x04\x06\xa5\x2d\x26\xe8\x0e\x55\x33\x60\xe3\xb9\x92\xba\xfc\xba\x4e\xf3\x64\x91\x24\x65\x59\xc2\x63\xcb\x0e\xc4\xa2\x72\x53\xbf\xd5\x5f\xe6\x15\x50\x03\x37\xff\x5f\xf8\xba\xd3\x16\x7a\x6d\x09\x2a\xad\x84\x9e\x25\x07\x47\x14\x1e\x5b\x32\x1a\x2e\xa1\x15\x31\x6e\x59\x96\x0d\x4b\x3b\x6c\x8a\x4a\xf7\xa5\x56\xdb\x4e\x3f\x95\xd5\x64\xde\xe5\x60\x6a\x14\xb2\x73\xcd\x8f\x06\x2d\xf6\xd0\x6a\x27\x3b\x5f\xec\x12\x1e\x5b\x02\xac\x6b\x4b\xce\x81\xde\x06\x08\xac\x2a\x3d\x28\xcf\x15\x05\xcc\x6c\xe1\xb9\x46\xb7\xda\x86\x7d\xc7\x8d\x22\x5b\x9c\xe2\xac\xd0\xac\x63\x8f\x0f\x28\xed\x7d\x4d\x4a\x78\xcb\x3b\x58\x9e\xbf\x61\x70\x1e\x40\x43\x4d\x96\xc7\xd8\xe8\xa1\x69\xf0\xd4\x92\xa5\xb3\x0c\x9e\xb8\xeb\x02\xac\x5f\x1b\x02\x87\x23\xd5\x51\xc8\x03\x0f\xb3\x93\xae\x6f\x63\xc7\xf9\x1f\x58\xae\xc5\xb2\x6a\x16\xf0\x2b\x44\x26\xfc\x31\x96\x0c\x5a\xca\x62\xc7\x4b\xc0\x41\xda\x2c\x24\xf7\x5e\x6d\xf4\xf3\x9e\x59\x0e\x6b\x1c\xe9\x1b\x76\x03\x2d\xe0\xe2\x36\x6a\xba\x2b\xe5\x57\x59\x42\x9c\x92\x90\x89\x59\xe6\x73\xf9\x8a\x60\xff\x3a\x60\x8f\x31\x57\xe8\x48\xe2\xce\x17\xec\x09\xae\xdf\x9e\x60\x2f\xda\xf7\xb4\xa8\xb4\xaa\x50\x26\xea\xc5\xe4\x7a\x21\x3a\xb6\x99\x2d\x16\x47\x95\x27\x69\xe0\x7a\xe7\x6e\x80\x2a\xc2\x34\xfc\x7f\xf1\x16\x54\xe1\xb1\x3e\x64\x33\xad\x7c\x1e\x86\xe5\x71\xf4\xf6\x60\x7e\xdd\xdc\x80\x41\xc5\x55\x96\xbe\x32\x18\x1d\x28\x2d\xb0\xd5\x83\xaa\x81\xd5\x89\x18\xe9\x22\x99\x0b\xa1\x73\x64\x25\x9b\x88\x17\x55\x4b\xd5\x8f\x6c\x91\x43\x4f\xce\xc5\x51\x7f\x0c\x13\x54\x11\x8f\xc7\x4a\xb3\xaf\x36\x62\xc7\xf5\x61\xbd\xb2\x04\x1f\x8c\xf3\xc1\x63\x75\x6c\xcd\x94\xd7\x3c\x66\x98\x55\xf3\x3a\xc5\x5a\x1d\x79\xed\x5f\x4d\x26\x1c\x09\xef\xf6\x61\x84\x6b\x38\x88\x66\xc6\x07\xd9\x7c\x2f\xb9\x6f\x69\x7b\x87\xdc\xbd\x3f\x68\x73\xe4\xe6\x1f\xa9\x3d\x66\xba\x2f\x3b\x25\x62\x7a\x5a\xf8\xa1\xdb\xc9\x9e\x83\xe8\xe5\x61\x0f\xf1\xd5\x4b\xf2\x92\xfc\x0e\x00\x00\xff\xff\x8f\xb6\x98\xc3\x69\x06\x00\x00" func transactionsMigrationContractStagingDelegatedStagingClaim_published_host_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -664,11 +727,11 @@ func transactionsMigrationContractStagingDelegatedStagingClaim_published_host_ca } info := bindataFileInfo{name: "transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x36, 0xba, 0x5b, 0x4f, 0xb6, 0x12, 0xee, 0x45, 0x75, 0x5e, 0x49, 0x25, 0x9b, 0x87, 0x51, 0x95, 0x35, 0xaa, 0xf, 0x63, 0xec, 0x85, 0x1f, 0xe5, 0xee, 0xcb, 0xab, 0xe9, 0x42, 0x98, 0xb8, 0x49}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x90, 0xdf, 0x1d, 0xaa, 0x40, 0x6f, 0x72, 0xc7, 0xe0, 0xd3, 0xe3, 0x30, 0xf6, 0xde, 0xd9, 0x2d, 0xe4, 0x73, 0x81, 0xee, 0xe3, 0x67, 0x94, 0xe6, 0xd0, 0x96, 0x49, 0xf7, 0xc2, 0x37, 0x93, 0xc5}} return a, nil } -var _transactionsMigrationContractStagingDelegatedStagingSetup_host_optional_publishCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x55\x4d\x8f\xa3\x46\x10\xbd\xf3\x2b\xca\x44\xda\x80\xc4\x40\xf6\x6a\x8d\xb3\x3b\x1a\x65\x95\x3d\x44\x5a\xc5\x93\x73\x54\x86\x02\x4a\xc1\xdd\xad\xee\xc2\xb3\xa3\x68\xfe\x7b\xd4\xd0\xc6\xf8\x03\x8d\x46\x39\x2c\x27\x03\x5d\xef\xbd\x7a\xf5\x0a\xf3\xde\x68\x2b\x10\xff\xc1\x8d\x45\x61\xad\x1e\xb5\x12\x8b\xa5\x6c\x05\x1b\x56\x4d\x1c\x45\x3f\xb1\x12\xf2\x8f\x58\x2b\x48\x22\x00\x80\x03\x59\xc7\x5a\xad\x21\xfe\x98\x7f\xcc\x7f\x89\xb3\xe1\xa9\xb0\x74\xb4\x86\x78\x4b\xd2\x1b\x08\x00\xf0\xbb\x76\x12\x0e\x54\xe4\x4a\xcb\x46\xc6\xd2\x47\xad\x6a\x6e\x7a\x4b\x0e\x10\x96\xf8\x87\x72\x60\x05\xd2\x12\x38\x6e\x14\xd9\x9f\x1d\x60\x59\xea\x5e\x49\x0e\x5f\x6b\x40\x05\x58\x55\x96\x9c\x03\x76\x60\xac\x3e\x70\x45\x55\x06\x08\xc6\xf2\x01\x85\x46\x88\x47\x34\xb8\xe3\x8e\xe5\x05\x9e\xb9\xeb\x60\x47\x60\xfa\x5d\xc7\xae\xa5\x0a\x6a\x6d\x07\x82\x86\x0f\x34\xc1\x65\x40\x0a\x77\x9d\x17\xe1\xdf\x59\x2a\xd9\x30\x29\x01\xd1\xe0\x04\x1b\x82\x32\x68\x75\xa0\x15\xec\xa8\xc5\xae\x06\x5d\xcf\xa4\xe6\xa1\xf1\x0e\x55\xd3\x63\xe3\xcd\x21\x75\xf7\xd7\x36\xce\xa2\x34\x8a\x8a\xa2\x80\xa7\x96\x1d\x88\x45\xe5\x82\xc1\x25\x7a\x28\xe8\x1d\x55\x03\xd1\xe0\x25\x8e\x3d\x58\x72\xba\xb7\x25\xfd\x3f\x3f\x06\xde\x1f\xe0\xc9\xc0\x1b\x7c\xf1\xbf\x87\xfb\x2f\xda\xc2\x5e\xdb\xb1\x8e\xbe\x4b\x06\x8e\x28\x60\x1b\x0d\x77\xd0\x8a\x18\xb7\x2e\x8a\x86\xa5\xed\x77\x79\xa9\xf7\x85\x56\x75\xa7\x9f\x8b\x23\xd3\x5d\x6f\x2a\x14\xb2\x13\xe6\x67\x83\x16\xf7\xd0\x6a\x27\xa7\x0e\xff\x3c\x4a\x5d\xc3\x53\x4b\xa0\x87\x14\x62\x07\x0f\xc1\xab\x30\xb7\x59\x47\x2d\xca\x30\x8d\xb2\x43\xde\x0f\x2f\x4f\xe6\x5c\xd8\x37\xf4\xe3\x07\xed\x07\xe0\x4f\x1e\xb0\xeb\xc9\xfb\xaf\xb8\xcb\x40\xe9\x2b\xbf\x3b\x56\xff\x50\x05\xda\x9e\x40\x47\x53\x66\x59\x48\x16\x3b\x08\xa2\x3f\xa5\xf0\x6f\x34\x04\xcc\x58\x32\x68\x29\x19\xed\x5d\xc3\x43\x2f\xed\xc3\x18\x0a\x7f\x06\xc2\x55\x14\x30\x6d\xdd\x65\xa4\x6a\x50\x44\x15\x55\xd3\x61\xae\x8f\xd3\xda\x69\x6b\xf5\xf3\xfd\x87\xa5\x25\xcd\x3d\xd4\xaf\x49\x6d\xf5\x7e\xbd\xb8\xc9\xc3\xa1\xad\x68\x8b\x0d\x7d\x43\x69\x53\xd8\x6c\xbc\x3d\x33\x79\xfe\x0a\x94\x0e\x0f\x94\xdc\xdf\x2d\x82\x95\x96\x50\xc8\x43\x26\x69\x06\xa2\xdf\xc1\x3b\xd1\xbd\xce\x7d\xf9\x4d\xb9\x1b\xa6\xb8\x71\x01\xa7\x83\xe8\x1c\x59\x49\x6e\x29\x96\x17\x43\x09\xca\x3b\x0d\x78\x7a\x31\x74\xff\xf9\x0d\x63\xd3\xec\x8c\x70\x4f\xce\x8d\x1f\x93\x2f\xc8\xdd\xfc\x3b\x71\xa6\x3e\x9e\x8a\xd2\xdb\x01\x58\xfe\x42\x7e\x38\xa6\xd2\x87\x00\x67\x4b\xc1\x0e\x2a\xaa\x59\x9d\xc7\x64\x21\xa7\xb0\xba\x35\xe0\x8e\x64\x28\xf8\x5a\x91\x12\xae\x99\x2c\x6c\x96\xff\x7f\xbc\xb2\xbf\xe3\xbc\xd4\xaa\x44\x59\x5a\x88\x55\x2e\x7a\x2b\x96\x55\x93\xa4\xe9\x15\x59\x68\xd2\x5b\x0e\x1b\xf8\x76\xba\x4b\x78\x92\xb0\xbe\x90\x94\xae\xa2\x5b\x33\xee\x95\xdf\xdb\x64\x86\x78\x4d\x17\x34\xc2\xe6\x58\xe4\x4b\xde\xdc\x9d\x33\x98\x71\xa3\x27\x8e\xec\xea\xa5\xa0\x6d\xe8\x1d\x51\x3b\x03\x38\x97\x1c\x12\x1d\x54\x7f\x0a\xbb\x9e\xa4\x61\x78\xd9\xcd\xb4\xf9\x96\x2e\x43\x13\xa7\xb7\x1c\x63\xb5\xd3\xdf\xf3\x90\xa6\x23\xcb\x2a\x03\x85\x7b\xba\x34\x3d\x3b\x05\x6d\xbd\x94\xa9\xd5\xe5\xfa\xbe\x46\xaf\xd1\x7f\x01\x00\x00\xff\xff\x3a\x4e\x74\x73\xc5\x08\x00\x00" +var _transactionsMigrationContractStagingDelegatedStagingSetup_host_optional_publishCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x55\x4d\x6f\xe3\x46\x0c\xbd\xeb\x57\x30\x2a\x90\x4a\x80\x22\x75\xaf\x46\xd2\xee\x36\xe8\xb6\x39\x14\x58\xd4\x69\xaf\x05\x2d\x51\x12\xb1\xe3\x19\x61\x86\x72\x36\x28\xf2\xdf\x8b\x19\x8d\xe5\x8f\x5a\x9b\x06\x3d\x74\x4e\xb2\xc4\x79\x7c\x7c\x7c\xa4\x79\x3b\x18\x2b\x90\xfe\xca\x9d\x45\x61\xa3\xef\x8d\x16\x8b\xb5\xac\x05\x3b\xd6\x5d\x9a\x24\xdf\xb0\x16\xf2\xaf\xd8\x68\xc8\x12\x00\x80\x1d\x59\xc7\x46\xaf\x20\x7d\x57\xbe\x2b\xbf\x4b\x8b\xf0\x56\x58\x14\xad\x20\x5d\x93\x8c\x03\x44\x00\xf8\xc5\x38\x89\x01\x0d\xb9\xda\xf2\x20\xd3\xd5\x7b\xa3\x5b\xee\x46\x4b\x0e\x10\x96\xf2\x87\xeb\xc0\x1a\xa4\x27\x70\xdc\x69\xb2\xdf\x3a\xc0\xba\x36\xa3\x96\x12\x1e\x5a\x40\x0d\xd8\x34\x96\x9c\x03\x76\x30\x58\xb3\xe3\x86\x9a\x02\x10\x06\xcb\x3b\x14\x9a\x20\xee\x71\xc0\x0d\x2b\x96\x67\x78\x62\xa5\x60\x43\x30\x8c\x1b\xc5\xae\xa7\x06\x5a\x63\x43\x82\x8e\x77\x34\xc3\x15\x40\x1a\x37\xca\x93\xf0\xdf\x2c\xd5\x3c\x30\x69\x01\x31\xe0\x04\x3b\x82\x3a\x72\x75\x60\x34\x6c\xa8\x47\xd5\x82\x69\x8f\xa8\x96\xb1\x70\x85\xba\x1b\xb1\xf3\xe2\x90\xbe\xf9\x7d\x9d\x16\x49\x9e\x24\x55\x55\xc1\x63\xcf\x0e\xc4\xa2\x76\x51\xe0\x1a\x3d\x14\x8c\x8e\x9a\x90\x28\x68\x89\x53\x0d\x96\x9c\x19\x6d\x4d\xff\x4d\x8f\x90\xf7\x7f\xd0\x24\xe4\x8d\xba\xf8\xe7\xf0\xfb\xa3\xb1\xb0\x35\x76\xba\x47\x5f\xa4\x00\x47\x14\xb1\x07\x03\x37\xd0\x8b\x0c\x6e\x55\x55\x1d\x4b\x3f\x6e\xca\xda\x6c\x2b\xa3\x5b\x65\x9e\xaa\x7d\xa6\x9b\x71\x68\x50\xc8\xce\x98\xef\x07\xb4\xb8\x85\xde\x38\x39\x54\xf8\xdb\x9e\xea\x0a\x1e\x7b\x02\x13\x5c\x88\x0a\x3e\x44\xad\x62\xdf\x8e\x2a\xea\x51\x42\x37\x6a\x85\xbc\x0d\x1f\x0f\xe2\x9c\xc9\x17\xea\xf1\x8d\xf6\x0d\xf0\x91\x3b\x54\x23\x79\xfd\x35\xab\x02\xb4\xf9\x87\xde\x8a\xf5\x67\x6a\xc0\xd8\x03\xe8\x24\xca\x91\x17\xb2\xc5\x0a\x22\xe9\x1f\x72\xf8\x2b\x09\x06\x1b\x2c\x0d\x68\x29\x9b\xe4\x5d\x01\x8e\xd2\x67\x3f\x1a\x6b\xcd\xd3\x1f\x9e\x4a\x01\x6b\xdc\x51\x7c\xfc\x99\x64\x2d\xc6\x62\x47\x07\xf0\x30\x76\x46\x29\xb2\x05\x3c\x38\x37\xd2\x57\x23\x3e\x4d\x9c\x1f\xf4\xc6\x7c\x39\x44\xe4\x70\xfd\x61\x32\xa2\xe7\x05\xf1\x54\x15\xcc\x93\x7e\x6e\xe3\x16\x34\x51\x43\xcd\x1c\xcc\xed\xde\x21\x6e\xca\x5f\x6e\x42\x11\xb7\xd7\x4b\x0b\xa2\xf4\x90\xdf\x67\xad\x35\xdb\xd5\xe2\x16\x09\x41\xb1\xa2\x4f\x28\x7d\x0e\x77\x77\xbe\x35\x47\x34\xfd\x39\x4b\xed\x70\x47\xd9\xed\xcd\x22\x68\x6d\x09\x85\x3c\x74\x96\x17\x20\xe6\x0d\xf9\xe7\xb4\x2f\xc7\x3a\xfd\xa4\xdd\x05\x91\xdc\xb4\x04\xe6\x40\x74\x8e\xac\x64\x5f\x63\x2e\xcf\x03\x65\x28\x6f\x14\xe4\xf1\x79\xa0\xdb\xf7\xaf\x08\x9d\x17\x27\x89\xb7\xe4\xdc\xb4\xd8\x3e\x22\xab\xe3\x9d\x75\x52\x45\x3a\x5f\xca\x2f\x1b\x63\x79\x5b\x5f\xef\x27\xc4\x9b\x03\x8f\x06\x94\x1d\x34\xd4\xb2\x3e\xb5\xcf\xc2\xcc\xc0\xd5\xa5\x86\x2b\x92\x70\xe1\xa1\x21\x2d\xdc\x32\x59\xb8\x5b\xfe\x2f\xf4\xcc\xfe\x4c\xcb\xda\xe8\x1a\x65\x69\x38\xaf\x4a\x31\x6b\xb1\xac\xbb\x2c\xcf\x2f\x26\xbb\xc7\x01\xee\xf6\x1d\xab\xf7\x08\x4c\x6e\x6e\x1f\xfb\x01\x7c\xd5\xf2\x27\xe0\xfe\xfc\xdb\x66\x9f\x5c\x3c\xe5\x18\xbd\x15\x69\x96\x75\x4f\xf5\x67\x6f\xee\x4b\x6d\x0e\x2c\xcf\xdb\x95\xe6\xaf\x4e\x54\x04\x9f\x26\xe6\x88\x56\xc6\x73\x17\x56\x67\x5d\xc9\xaf\x2e\xc2\xb2\xdf\x3f\x65\xb4\xc7\x01\x57\xe3\x96\xce\x11\x8a\x83\x71\x56\x4b\x1e\xb9\x3a\x1f\xcb\x97\xe4\x25\xf9\x3b\x00\x00\xff\xff\x08\x82\xd4\xc7\x21\x09\x00\x00" func transactionsMigrationContractStagingDelegatedStagingSetup_host_optional_publishCdcBytes() ([]byte, error) { return bindataRead( @@ -684,11 +747,11 @@ func transactionsMigrationContractStagingDelegatedStagingSetup_host_optional_pub } info := bindataFileInfo{name: "transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2c, 0xee, 0xe9, 0xff, 0xc1, 0x1f, 0x6c, 0x5b, 0xb7, 0x47, 0x22, 0x54, 0x53, 0xa3, 0x3d, 0xef, 0xb2, 0x3b, 0x6, 0x1d, 0x36, 0x11, 0x94, 0x30, 0x6c, 0x41, 0xf, 0x6f, 0x41, 0x65, 0xd6, 0xf}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x43, 0x24, 0x7, 0xa9, 0xc8, 0xbf, 0xcf, 0x36, 0x47, 0xd5, 0x34, 0xf2, 0x8e, 0x80, 0x97, 0xc0, 0xb7, 0xbd, 0xdb, 0x52, 0xd4, 0xdf, 0xf2, 0xda, 0xd5, 0x8e, 0x94, 0x4, 0x93, 0xd4, 0xc9, 0xb3}} return a, nil } -var _transactionsMigrationContractStagingDelegatedStagingStage_contract_from_stored_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x56\xdb\x6e\xdb\x46\x10\x7d\xd7\x57\x0c\x58\xa0\xa0\x00\x99\x8a\x5f\x89\x38\x69\x20\xd4\x68\x1e\x52\x04\x50\xf3\x01\x23\xee\x88\x1c\x80\xdc\x25\x76\x87\x52\x84\x20\xff\x5e\xec\x2c\x49\x51\x8e\xad\x96\x0f\x36\xbc\x97\x73\xce\x9c\xb9\xac\xb9\xeb\x9d\x17\xc8\xbe\x70\xed\x51\xd8\xd9\x9d\xb3\xe2\xb1\x92\xbd\x60\xcd\xb6\xce\x56\xab\xdf\xd8\x0a\xc5\x25\x76\x16\xf2\x15\x00\xc0\x89\x7c\x60\x67\x4b\xc8\x1e\x8b\xc7\xe2\x5d\xb6\xd1\x55\x61\x69\xa9\x84\x2c\x5e\x25\x98\x80\xe0\x5b\x6f\x50\x08\x9e\xbd\xeb\x60\x2f\xce\x93\x81\xbf\x5c\x10\xd8\x61\x8f\x07\x6e\x59\x2e\xe3\x7d\x43\xa1\xf2\xdc\x4b\x42\x56\x94\x00\xd2\x10\xf4\xde\x9d\xd8\x90\x81\x6a\xc2\xac\x9c\x21\x60\xab\xbb\x21\x29\xbd\x6e\x1e\x9d\x87\x1d\x1a\xb2\x15\xc1\x63\xf1\xee\xba\xd1\x4d\x41\x86\x02\xfe\x69\x38\x40\x8f\x5e\xb8\x1a\x5a\xf4\x20\x1e\x6d\x18\x83\xc4\x10\x86\x8e\x02\xe0\x4b\xa1\xd0\x60\x80\x03\x91\x85\x80\x27\x32\x51\x41\x10\xe7\xb1\xa6\x0d\x60\x80\xb3\x1b\x5a\x03\x07\x52\x59\x15\x06\x52\x29\x58\x55\x6e\xb0\x12\xa0\x6a\x9c\x0b\x51\xa9\x38\x30\xd4\x52\x1d\x6d\x99\xd4\x1f\x07\xab\xe4\xa8\x3c\xe2\x00\xc1\xd0\x09\x84\xb0\x2b\x46\x7f\x5a\xb4\xf5\x80\x75\xb4\x98\xec\xc3\xb7\x7d\xb6\x59\xad\x57\xab\xed\x76\x9b\x82\x59\x46\xc0\x01\x86\x40\x26\xe2\x04\xcd\x06\x5e\x5d\x18\x52\x3e\xfe\x87\x4b\x70\x62\xd4\x00\x7f\x4d\x59\x11\x79\x95\xfb\x4f\x1b\x06\x1f\x43\x46\x01\x79\x45\x47\xe0\xda\x92\x81\xc3\x05\xd0\x4e\x5e\xa4\xd3\xb3\x99\xb5\x47\x2b\x64\x00\xad\x49\x74\xaf\x58\x1f\x33\x46\xa3\x18\xe5\x5d\x64\x25\x34\x6a\xbc\xa0\xaf\x49\xa6\xab\x63\x75\xdc\x30\xba\xb3\x4d\x15\x35\x07\x2b\x2e\xe6\x2b\x59\x92\x04\x8c\x81\x2c\xce\x34\x18\x94\x11\x5b\x4f\x68\x2e\x49\xb3\xa1\xbe\x75\x97\x64\x71\x3c\xad\x9c\x23\xd9\xd5\x9c\x67\xe7\xa1\x73\x3e\x81\xd1\x77\xd9\x40\xa0\x54\x1e\x9e\x7a\x07\x0f\xd0\x88\xf4\xa1\xdc\x6e\x6b\x96\x66\x38\x14\x95\xeb\xb6\xce\x1e\x5b\x77\xde\x4e\xf4\x0f\x49\x9c\x9f\x31\xff\xe8\xd1\x63\x07\x8d\x0b\xb2\xc3\x7e\x9f\xea\xef\x2b\x4a\xf3\xd9\x90\x15\x3e\x32\xf9\x52\xcd\xe2\xf9\xef\xb9\x18\x0c\x79\x3e\xd1\xd8\x36\x7a\x11\x7a\x94\x06\xce\x0d\x79\xba\xc6\xb1\xf0\x96\x53\xec\xf1\xd3\x9a\x2f\x96\x1a\x26\x8d\x7f\x63\x47\x89\xd3\x62\x47\xe0\x8e\xf7\x4c\x3e\xb3\x34\xba\x5f\xf3\x89\xac\xb6\xf2\x6b\x98\x3b\x67\x46\xcc\xe9\xe2\x4d\xf7\xab\x1d\x8b\x52\xcb\xef\xfb\xb1\x17\xcf\xb6\xde\xbc\x50\xfc\x72\x35\x71\xa6\xd5\x35\xfc\x48\x5d\x47\xa2\x5e\x97\xf0\xfb\x5b\x43\xb2\x88\xa6\xe9\x61\xfd\xd1\x7b\xea\xd1\x53\xae\x95\xef\x4b\xf8\x34\x48\xf3\x29\x55\xc6\x04\x1a\xbf\x58\xc3\xae\xbf\xa8\x15\x0b\xc3\x8f\x71\x4e\x8e\xc9\x99\xcf\x46\x11\xe1\x1a\x19\x3c\xc1\x22\xce\x9c\x17\x81\xde\xb3\x61\x3d\xe3\xc5\xef\xe3\x47\xe8\xd1\x72\x95\x67\xcf\xc8\xed\xfd\xfa\x50\x51\x37\xa3\xf8\xca\x99\xad\x6f\x64\x8e\x02\xe0\x29\x75\xbe\x2f\x2a\xd7\x5f\xde\x5f\x03\x7c\x7f\xdf\xc6\x0f\x1f\xf2\x48\x56\x2e\xc3\x7d\x4b\xf7\x17\x0e\x3a\x4f\xb5\x66\xab\x45\xcd\xce\x63\x79\xa1\x2d\x50\x7b\x2c\xa2\x38\x78\x9a\x34\x16\x07\xe7\xbd\x3b\xe7\xeb\x05\xe6\x54\xff\x0b\x90\x38\xc5\xd8\x9e\xb0\x65\x33\xe2\xfd\x5c\xe9\x2f\xfa\x4e\xd5\x20\xf4\x22\xa7\xd8\xb6\xbf\xbc\x49\x1b\xc5\xd2\xd9\xbf\x6c\x0c\x7d\xc6\x74\xe0\x9c\xb9\x6d\xa7\xc9\x6c\x06\x3d\xb9\x1c\xce\xf3\x4c\x5e\x32\x7d\x3e\x8e\xef\x60\x98\x47\x93\x0e\x7b\xa3\xb3\x7d\xd9\x61\x93\x08\x1e\x89\x0e\x04\xee\x44\xfe\xec\x59\x84\x6c\x31\x83\xbe\x99\x19\xc5\x9d\x16\xf3\xd4\x0e\xb3\xa1\x1b\xed\xfa\xf2\xa6\xb7\x36\x2a\xad\xbc\xe9\xac\x1b\xef\xfa\xe8\xf3\x8f\xff\x66\xe6\xa0\xff\x08\x98\x1c\x8d\xf1\x14\xc2\x82\xb7\x18\x97\xf2\xf5\x6b\x0a\xd6\xe5\x4d\xd5\x64\x5f\xbd\x3b\xb4\xd4\xc1\xb9\xe1\xf6\xfa\xec\x26\xcb\xb3\x51\xd9\xcf\xd5\xbf\x01\x00\x00\xff\xff\x25\xe1\x38\xb0\x10\x09\x00\x00" +var _transactionsMigrationContractStagingDelegatedStagingStage_contract_from_stored_host_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x56\xdd\x8a\xdb\x48\x13\xbd\xf7\x53\x14\xfa\x20\xc8\xe0\x91\x33\xb7\x22\x93\x7c\x8b\xd9\x61\x73\x91\x25\xe0\xcd\xde\x97\xd5\x65\xa9\x40\xea\x16\xdd\x25\x3b\x26\xe4\xdd\x97\xae\x96\x64\x79\x32\xe3\x5d\x5d\xcc\x30\xfd\x73\xce\xa9\x53\x3f\x3d\xdc\xf5\xce\x0b\x64\x5f\xb8\xf6\x28\xec\xec\xce\x59\xf1\x58\xc9\x5e\xb0\x66\x5b\x67\xab\xd5\xff\xd8\x0a\xc5\x25\x76\x16\xf2\x15\x00\xc0\x89\x7c\x60\x67\x4b\xc8\x1e\x8b\xc7\xe2\x7d\xb6\xd1\x55\x61\x69\xa9\x84\x2c\x5e\x25\x98\x80\xe0\x5b\x6f\x50\x08\x9e\xbd\xeb\x60\x2f\xce\x93\x81\x3f\x5c\x10\xd8\x61\x8f\x07\x6e\x59\x2e\xe3\x7d\x43\xa1\xf2\xdc\x4b\x42\x56\x94\x00\xd2\x10\xf4\xde\x9d\xd8\x90\x81\x6a\xc2\xac\x9c\x21\x60\xab\xbb\x21\x29\xbd\x6e\x1e\x9d\x87\x1d\x1a\xb2\x15\xc1\x63\xf1\xfe\xba\xd1\x4d\x41\x86\x02\xfe\x6a\x38\x40\x8f\x5e\xb8\x1a\x5a\xf4\x20\x1e\x6d\x18\x83\xc4\x10\x86\x8e\x02\xe0\x4b\xa1\xd0\x60\x80\x03\x91\x85\x80\x27\x32\x51\x41\x10\xe7\xb1\xa6\x0d\x60\x80\xb3\x1b\x5a\x03\x07\x52\x59\x15\x06\x52\x29\x58\x55\x6e\xb0\x12\xa0\x6a\x9c\x0b\x51\xa9\x38\x30\xd4\x52\x1d\x6d\x99\xd4\x1f\x07\xab\xe4\xa8\x3c\xe2\x00\xc1\xd0\x09\x84\xb0\x2b\x46\x7f\x5a\xb4\xf5\x80\x75\xb4\x98\xec\xc3\xb7\x7d\xb6\x59\xad\x57\xab\xed\x76\x9b\x82\x59\x46\xc0\x01\x86\x40\x26\xe2\x04\xcd\x06\x5e\x5d\x18\x52\x3e\xfe\x83\x4b\x70\x62\xd4\x00\x7f\x4d\x59\x11\x79\x95\xfb\x77\x1b\x06\x1f\x43\x46\x01\x79\x45\x47\xe0\xda\x92\x81\xc3\x05\xd0\x4e\x5e\xa4\xd3\xb3\x99\xb5\x47\x2b\x64\x00\xad\x49\x74\xaf\x58\x1f\x33\x46\xa3\x18\xe5\x5d\x64\x25\x34\x6a\xbc\xa0\xaf\x49\xa6\xab\x63\x75\xdc\x30\xba\xb3\x4d\x15\x35\x07\x2b\x2e\xe6\x2b\x59\x92\x04\x8c\x81\x2c\xce\x34\x18\x94\x11\x5b\x4f\x68\x2e\x49\xb3\xa1\xbe\x75\x97\x64\x71\x3c\xad\x9c\x23\xd9\xd5\x9c\x67\xe7\xa1\x73\x3e\x81\xd1\x77\xd9\x40\xa0\x54\x1e\x9e\x7a\x07\x0f\xd0\x88\xf4\xa1\xdc\x6e\x6b\x96\x66\x38\x14\x95\xeb\xb6\xce\x1e\x5b\x77\xde\x4e\xf4\x0f\x49\x9c\x9f\x31\xff\xdf\xa3\xc7\x0e\x1a\x17\x64\x87\xfd\x3e\xd5\xdf\x57\x94\xe6\xb3\x21\x2b\x7c\x64\xf2\xa5\x9a\xc5\xf3\xdf\x73\x31\x18\xf2\x7c\xa2\xb1\x6d\xf4\x22\xf4\x28\x0d\x9c\x1b\xf2\x74\x8d\x63\xe1\x2d\xa7\xd8\xe3\xa7\x35\x5f\x2c\x35\x4c\x1a\xff\xc4\x8e\x12\xa7\xc5\x8e\xc0\x1d\xef\x99\x7c\x66\x69\x74\xbf\xe6\x13\x59\x6d\xe5\xd7\x30\x77\xce\x8c\x98\xd3\xc5\x9b\xee\x57\x3b\x16\xa5\x96\xdf\xf7\x63\x2f\x9e\x6d\xbd\x79\xa1\xf8\xe5\x6a\xe2\x4c\xab\x6b\xf8\x91\xba\x8e\x44\xbd\x2e\xe1\xdd\x5b\x43\xb2\x88\xa6\xe9\x61\xfd\xd1\x7b\xea\xd1\x53\xae\x95\xef\x4b\xc0\x41\x9a\x7c\xe7\xfa\xcb\xdf\xd8\x0e\xb4\x86\x77\xbf\xa5\x32\x99\x18\xe2\x17\x0b\xda\xf5\x17\xf5\x65\xe1\xfe\x31\x0e\xcd\x31\x53\xf3\xd9\xa8\x28\x5c\xc3\x84\x27\x58\x04\x9d\xf3\x22\xea\x7b\x9e\xac\x67\xbc\xf8\x7d\xfa\x04\x3d\x5a\xae\xf2\xec\x19\xb9\xbd\x5f\x2c\x2a\xea\x66\x2e\x5f\x39\xb3\xf5\x8d\xcc\x51\x00\x3c\xa5\x31\xe0\x8b\x11\xa8\xa8\x5c\x7f\xf9\x70\x0d\xf4\xc3\x7d\x6f\x3f\x7e\xcc\x23\x69\xb9\x0c\xfb\x2d\xfd\x5f\x38\xe8\x90\xd5\x42\xae\x16\x85\x3c\xcf\xea\x85\xc6\x40\xed\xb1\x88\x22\xe1\x69\xd2\x5a\x1c\x9c\xf7\xee\x9c\xaf\x17\x98\x53\x53\x2c\x40\xe2\x68\x63\x7b\xc2\x96\xcd\x88\xf7\x73\xa5\xbf\xe8\x3b\x55\x83\xd0\x8b\xdc\x62\xdb\xfe\xf2\x50\x6d\x14\x4b\x1f\x84\x65\xb7\xe8\xdb\xa6\x53\xe8\xcc\x6d\x3b\x8d\x6b\x33\xe8\xc9\xe5\xc4\x9e\x07\xf5\x92\xe9\xf3\x71\x7c\x1c\xc3\x3c\xaf\xf4\x05\x30\x3a\xf0\x97\x6d\x37\x89\xe0\x91\xe8\x40\xe0\x4e\xe4\xcf\x9e\x45\xc8\x16\x33\xe8\x9b\x99\x51\xdc\x69\x31\x4f\x3d\x32\x1b\xba\xd1\x51\x50\xde\x34\xdc\x46\xa5\x95\x37\xed\x76\xe3\x5d\x1f\x7d\xfe\xf1\xef\xcc\x1c\xf4\xbf\x03\x93\xa3\x31\x9e\x42\x58\xf0\x16\xe3\x52\xbe\x7e\x4d\xc1\xba\xbc\xa9\x9a\xec\xab\x77\x87\x96\x3a\x38\x37\xdc\x5e\xdf\xe2\x64\x79\x36\x2a\xfb\xb9\xfa\x27\x00\x00\xff\xff\xc0\x3f\x9e\x47\x25\x09\x00\x00" func transactionsMigrationContractStagingDelegatedStagingStage_contract_from_stored_host_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -704,11 +767,11 @@ func transactionsMigrationContractStagingDelegatedStagingStage_contract_from_sto } info := bindataFileInfo{name: "transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc8, 0xf3, 0x87, 0x65, 0x21, 0x2f, 0x78, 0xb9, 0x85, 0x79, 0xb5, 0x82, 0xd2, 0x2f, 0x37, 0xf, 0x63, 0xe9, 0xcb, 0x22, 0x7f, 0x6a, 0x27, 0x1d, 0xc, 0xaa, 0xc9, 0xbc, 0xca, 0x3a, 0xbf, 0xb1}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc0, 0x1e, 0xc7, 0xae, 0xf7, 0x15, 0xf2, 0x42, 0xda, 0x83, 0xe0, 0xe5, 0xcf, 0x80, 0x38, 0x30, 0xe5, 0x2e, 0x49, 0xb3, 0x9f, 0xa4, 0xd7, 0xdf, 0x4b, 0x86, 0xfa, 0x12, 0x3b, 0xd, 0xd2, 0x9d}} return a, nil } -var _transactionsMigrationContractStagingStage_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x55\xd1\x6e\xac\x46\x0c\x7d\xe7\x2b\x5c\x2a\x55\xac\xc4\xc2\xcd\x2b\xba\xa9\x1a\x45\xad\xda\x87\xb6\x57\xda\xe4\x03\x66\x19\x03\x23\xc1\x18\x79\xcc\x6e\xa2\x28\xff\x5e\xcd\x0c\xb0\x6c\xd2\xa4\xed\x43\x79\xd8\x95\x66\xec\x73\x8e\x0f\xb6\x31\xc3\x48\x2c\x90\xfe\x6e\x5a\x56\x62\xc8\xde\x93\x15\x56\xb5\x1c\x44\xb5\xc6\xb6\x69\x92\x7c\x6f\xac\xa0\x3f\x32\x64\x21\x4b\x00\x00\x4e\xc8\xce\x90\xad\x20\xbd\x29\x6e\x8a\x2f\x69\x1e\x4e\xc5\x48\x8f\x15\xa4\x3e\x15\x61\x01\x82\xc7\x51\x2b\xc1\x39\x46\xa3\xab\xd9\x8c\x12\xb3\x43\xa4\x03\xe9\x10\x46\xa6\x93\xd1\xa8\xa1\x5e\xf2\x6a\xd2\x08\xc6\x86\x5b\x17\xd5\x5c\x2e\x1b\x62\xb8\x57\x1a\x6d\x8d\x70\x53\x7c\xb9\x5c\x0c\x4b\x21\xae\x80\x3f\x6d\xff\x1c\xd2\xd7\xdb\x8e\x9c\x40\xad\x2c\x8c\xc8\x0d\xf1\x00\xd2\x19\x07\xb1\xb6\x62\x96\xd8\x2b\xdb\x4e\xaa\xf5\x95\xa0\xdd\x3f\x1e\xd2\x3c\xd9\x25\x49\x59\x96\xf0\xe0\x83\x85\x95\x75\xb3\x1b\xc6\xc1\xe4\x50\x83\x50\x50\x88\xa0\x2e\x54\x53\x28\xfb\x5f\x09\xf5\xe0\x81\xe0\x67\xeb\x26\x46\x90\x4e\x49\x54\xf6\x86\xcc\x99\xd6\xa2\x86\x63\xac\x4a\xd5\x35\x4d\x56\x62\x38\x9d\xad\xbb\xae\x55\x08\x8e\x38\xcb\xd0\xa0\xac\x5e\x70\x2f\x31\x81\xb4\x53\x0e\x54\xcf\xa8\xf4\x33\x1c\x11\x2d\x68\x1c\x7b\x7a\x8e\x65\x05\xf3\x4d\x6b\xbd\xf9\x33\xdf\x45\xee\x2f\xc4\x30\x10\x47\x3c\x7c\x92\x1c\x1c\x62\x48\x61\x1c\x09\xf6\xd0\x89\x8c\xae\x2a\xcb\xd6\x48\x37\x1d\x8b\x9a\x86\x92\x6c\xd3\xd3\xb9\x5c\x14\xec\xa3\x3e\x5e\x31\x7f\x1a\x15\xab\x61\x55\xf8\x87\x1a\xb0\x82\x87\x0e\xc1\xaa\x01\x81\x9a\xcf\x6a\x3c\x1b\xe9\xc2\x7d\x6b\x4e\x68\x43\x03\xfd\x1d\xe6\x3d\xe9\x19\x73\x49\xbc\xea\xb9\x20\x65\x63\x7c\x76\xad\xe5\x20\x6c\x6c\x9b\xbf\x41\x8b\xa7\x3b\x78\x89\x2d\x84\xb1\xd5\x2a\xf8\xe1\xa3\xc1\x2a\x7e\x25\x27\x21\x38\xfc\x8c\x8c\xa3\x62\xcc\xc2\x1b\xe6\x0a\xee\x26\xe9\xee\xa2\xdf\x0b\xa8\x7f\xca\xd2\xcf\x55\x63\x5a\xdf\x26\x1e\x01\x18\x1d\x4d\x5c\x23\x98\x06\x2c\xa2\x46\xbd\x06\x9b\x26\x36\x0c\x17\x47\x62\xa6\xf3\xd7\xcf\xc5\xfc\x98\x35\x4c\x43\x05\x9f\x06\x1d\x84\x58\xb5\xf8\x4d\x49\xb7\x83\xdb\x5b\xb0\xa6\xdf\xc8\xf3\xcf\x4c\xe9\xd4\x09\xb3\xaf\xfb\x0f\xc1\x6a\x46\x25\xe8\x21\xb3\x5d\x0e\x42\xff\x81\x77\xa5\x7b\xdd\xfa\x72\xe7\x3c\xf3\x62\x4a\x83\xec\x47\x6e\x0d\x70\xd8\x37\x45\x98\xfe\xdb\xff\xd7\x94\xef\x92\xa8\x2c\xfc\xe1\x13\xd6\x93\xe0\x9b\x17\xa8\xfa\xfe\xdd\x42\xcb\xc1\x09\xf9\x16\xba\xee\xef\xb0\x03\xc3\xd8\x9e\x4d\xdf\x2f\x3b\x45\x4f\x21\x72\xbb\x56\xd6\x6d\xb2\x65\xfa\xad\x99\x97\xe8\x65\xc0\xc3\x9a\xd2\x61\x2b\x6d\x07\x65\x11\x61\x66\xa2\x23\x02\x9d\x90\xcf\x6c\x44\xd0\x16\x2b\xe8\x87\x36\x04\xdc\xe5\x30\x8b\xbd\xbf\x7a\x9e\x87\xe1\xad\xae\x86\x3a\x0f\xd2\xaa\xab\x31\xda\x6d\xbd\x1b\xfd\xcb\x7a\xf9\x67\x66\xe3\xc2\x57\x44\x67\x4a\x6b\x46\xe7\x36\xbc\xc5\x7c\xe4\x3b\xec\xbd\x82\x5d\x75\xd5\xb7\xe9\x37\xa6\x63\x8f\x03\x9c\x3b\xd3\x5f\xbe\x38\xd1\xf2\x74\x56\xf6\x9a\xfc\x15\x00\x00\xff\xff\x79\xb1\xb2\x7f\x31\x07\x00\x00" +var _transactionsMigrationContractStagingStage_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x55\x51\x8f\xa3\x46\x0c\x7e\xe7\x57\xb8\x54\x3a\x11\x89\xc0\xed\x2b\xba\xad\x7a\x5d\xb5\x6a\x1f\xda\x9e\x94\xbb\xbe\x4f\x18\x03\x23\xc1\x18\x79\x4c\x72\xab\xd5\xfe\xf7\x6a\x66\x80\x90\x6c\x77\xdb\xbe\x1c\x0f\x09\xf2\xd8\xdf\xf7\xd9\x63\x1b\x33\x8c\xc4\x02\xe9\xef\xa6\x65\x25\x86\xec\x03\x59\x61\x55\xcb\x41\x54\x6b\x6c\x9b\x26\xc9\xf7\xc6\x0a\x7a\x93\x21\x0b\x59\x02\x00\x70\x42\x76\x86\x6c\x05\xe9\x5d\x71\x57\xbc\x4f\xf3\x60\x15\x23\x3d\x56\x90\xfa\x50\x84\x05\x08\xbe\x8c\x5a\x09\xce\x3e\x1a\x5d\xcd\x66\x94\x18\x1d\x3c\x1d\x48\x87\x30\x32\x9d\x8c\x46\x0d\xf5\x12\x57\x93\x46\x30\x36\x9c\xba\xa8\xe6\x72\xd8\x10\xc3\x83\xd2\x68\x6b\x84\xbb\xe2\xfd\xe5\x60\x58\x12\x71\x05\xfc\x69\xfb\xc7\x10\xbe\x9e\x76\xe4\x04\x6a\x65\x61\x44\x6e\x88\x07\x90\xce\x38\x88\xb9\x15\xb3\xc4\x5e\xd9\x76\x52\xad\xcf\x04\xed\xfe\xcb\x21\xcd\x93\x5d\x92\x94\x65\x09\x9f\xbd\xb3\xb0\xb2\x6e\xae\x86\x71\x30\x39\xd4\x20\x14\x14\x22\xa8\x0b\xd5\x14\xd2\xfe\x4f\x42\x3d\x78\x20\xf8\xd9\xba\x89\x11\xa4\x53\x12\x95\xdd\x90\x39\xd3\x5a\xd4\x70\x8c\x59\xa9\xba\xa6\xc9\x4a\x74\xa7\xb3\x75\xd7\xb9\x0a\xc1\x11\x67\x19\x1a\x94\xd5\x0b\xee\xc5\x27\x90\x76\xca\x81\xea\x19\x95\x7e\x84\x23\xa2\x05\x8d\x63\x4f\x8f\x31\xad\x50\x7c\xd3\x5a\x5f\xfc\x99\xef\x22\xf7\x17\x62\x18\x88\x23\x1e\x7e\x95\x1c\x1c\x62\x08\x61\x1c\x09\xf6\xd0\x89\x8c\xae\x2a\xcb\xd6\x48\x37\x1d\x8b\x9a\x86\x92\x6c\xd3\xd3\xb9\x5c\x14\xec\xa3\x3e\x5e\x31\x7f\x1c\x15\xab\x61\x55\xf8\x87\x1a\xb0\x82\xcf\x1d\x82\x55\x03\x02\x35\x6f\xe5\x78\x36\xd2\x85\xf3\xd6\x9c\xd0\x86\x06\xfa\x27\xcc\x07\xd2\x33\xe6\x12\x78\xd5\x73\x41\xca\xa6\xf0\xd9\xb5\x96\x83\xb0\xb1\x6d\x7e\x83\x16\xad\x3b\x78\x8a\x2d\x84\xb1\xd5\x2a\x78\xf7\xda\x60\x15\xbf\x92\x93\xe0\x1c\x7e\x46\xc6\x51\x31\x66\xe1\x86\xb9\x02\x35\x49\x97\xfd\x44\xcc\x74\xfe\x4b\xf5\x13\xe6\x70\x50\x27\x0c\xaf\x3b\x78\xf7\x31\xde\xc4\x42\xe7\x9f\xb2\xf4\x13\xd7\x98\xd6\x37\x90\xc7\x06\x46\x47\x13\xd7\x08\xa6\x01\x8b\xa8\x51\xaf\xce\xa6\x89\xad\xc4\x85\x13\x62\xd5\x62\x71\x0c\x54\x1f\xde\x96\xfb\x43\xd6\x30\x0d\x15\xbc\xe9\x74\x88\x88\x9f\x94\x74\x3b\xb8\xbf\x07\x6b\xfa\x8d\x4c\xff\xdc\x50\x3b\x75\xc2\xec\xc3\xfe\x55\xd0\x9a\x51\x09\x7a\xe8\x6c\x97\x83\xd0\xff\xe0\x5f\x69\x9f\xb7\x75\xfa\xe8\xbc\x82\xa5\x48\x0d\xb2\x1f\xce\xd5\xc1\x61\xdf\x14\x61\x4f\xdc\x7f\x9b\x22\x7d\x97\x44\x85\xe1\x0f\xbf\x62\x3d\x09\xde\x5c\xac\xea\xfb\x17\x2b\x30\x07\x2f\xcb\x5b\xae\x26\x22\x6c\xcd\x30\xe8\x67\xd3\xf7\xcb\x16\xd2\x53\xf0\xdc\x2e\xa2\x75\xff\x6c\x99\x7e\x6b\xe6\xb5\x7b\x59\x09\x61\xb1\xe9\xb0\xc7\xb6\xa3\xb5\x88\x30\x33\xd1\x11\x81\x4e\xc8\x67\x36\x22\x68\x8b\x15\xf4\xd5\x32\x04\xdc\xc5\x98\xc5\x69\x59\x6b\x9f\x87\x71\xaf\xae\xd6\x40\x1e\xa4\x55\x57\x83\xb7\xdb\xd6\x6e\xf4\x97\xf6\xf4\xef\xcc\xc6\x85\xef\x8e\xce\x94\xd6\x8c\xce\x6d\x78\x8b\xd9\xe4\x3b\xed\xa5\x82\x5d\x75\xd5\xc7\xe9\x27\xa6\x63\x8f\x03\x9c\x3b\xd3\x5f\xbe\x51\xb1\xe4\xe9\xac\xec\x39\xf9\x3b\x00\x00\xff\xff\xf6\x36\x12\x35\x63\x07\x00\x00" func transactionsMigrationContractStagingStage_contractCdcBytes() ([]byte, error) { return bindataRead( @@ -724,11 +787,11 @@ func transactionsMigrationContractStagingStage_contractCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/migration-contract-staging/stage_contract.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc4, 0x80, 0x51, 0x62, 0xec, 0x72, 0x10, 0x71, 0x9, 0x77, 0xd2, 0x1d, 0xde, 0x18, 0x24, 0x8a, 0xc4, 0x2, 0x46, 0xd0, 0x90, 0x72, 0xde, 0x1e, 0xbe, 0x82, 0xd8, 0xd2, 0xb4, 0x1f, 0xb0, 0x7b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf1, 0x71, 0x61, 0x4, 0xe3, 0xcc, 0xf4, 0xbc, 0xa, 0x1e, 0xfb, 0x72, 0x9b, 0xc6, 0xf7, 0xbf, 0xf6, 0x93, 0xa0, 0xa1, 0x1c, 0x62, 0x1c, 0xc0, 0x6d, 0x4a, 0xc2, 0x84, 0x8b, 0x4f, 0x97, 0xe5}} return a, nil } -var _transactionsMigrationContractStagingUnstage_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x53\x41\x6b\xdc\x4c\x0c\xbd\xfb\x57\xe8\xf3\x07\xc5\x0b\x1b\x3b\xb9\x9a\xb6\x21\x04\x4a\x2f\x6d\x43\x97\xfc\x80\x59\x5b\x1e\x0f\xd8\x92\xd1\xc8\xd9\x94\x92\xff\x5e\x66\xc6\x76\xb2\x34\xc9\xa9\x73\xd8\x05\x49\xef\xe9\xe9\x49\x76\xe3\xc4\xa2\x90\x7f\x73\x56\x8c\x3a\xa6\x5b\x26\x15\xd3\xe8\x41\x8d\x75\x64\xf3\x2c\xfb\xdf\x91\x62\x08\x39\x26\x28\x32\x00\x80\x07\x14\xef\x98\x6a\xc8\xaf\xca\xab\xf2\x32\xdf\xc7\xa8\x3a\x1d\xb0\x86\xfc\x9e\xbc\x1a\x8b\xb0\x52\xc1\xfd\xd4\x1a\xc5\xa5\xaa\x45\xdf\x88\x9b\x34\xe1\x7f\xe2\xc8\x0f\xe8\x41\x7b\x84\x88\x6a\xa1\x59\x61\x0d\xb7\x08\x9d\xf0\xb8\x65\x1d\xd9\x2d\x5d\xc2\x0f\x1a\x7e\xc5\xd4\x86\xe8\xd9\x2b\x34\x86\x60\x42\xe9\x58\x02\xd0\x79\x48\xd2\xcb\xa5\xff\x60\xc8\xce\xc6\x06\xa1\x48\x17\xf7\x87\x7c\x9f\xed\xb2\xac\xaa\x2a\x58\x74\x27\x31\xd6\x3d\x20\x3d\x33\xff\x3b\x19\xb1\xd5\x4d\xa7\x28\x11\xa4\x62\xc8\xa7\xd4\xfe\x9c\xe5\xe4\x86\x01\x88\x61\x60\xb2\x28\x70\xdc\x0c\xea\x58\xe0\xd6\xb4\x48\x0d\xc2\x55\x79\x09\xe3\xba\xbb\xc8\x1d\xf9\xbf\xb0\xc0\xc8\x92\xd8\xf0\x51\xf7\xe0\x11\x23\xbd\xe0\xc4\x70\x01\xbd\xea\xe4\xeb\xaa\xb2\x4e\xfb\xf9\x58\x36\x3c\x56\x4c\xdd\xc0\xa7\x6a\xed\x7f\x31\xc7\xad\x49\xe4\x7c\xa1\xb2\x58\x0b\xbe\x9b\x11\x6b\x38\xa8\x38\xb2\x3b\xf8\x9d\xcc\xc5\x34\x7d\x0d\x1f\xde\xba\xa8\xf2\x2b\x7b\x8d\xc5\xf1\x67\x12\x9c\x8c\x60\xe1\x9d\x25\x94\x1a\x6e\x66\xed\x6f\x9a\x86\x67\xd2\x95\x34\xbc\xe0\x99\x0f\x35\x10\xe0\x20\xd8\xa1\x04\x03\xb6\x02\x8f\x43\x57\x46\xe3\x3f\x41\xe2\x2a\x8f\x2c\xc2\xa7\x8f\xef\x2b\xf9\x5c\x84\xd5\xd6\xf0\x6e\xd1\x41\x59\x8c\xc5\x3b\xa3\xfd\x6e\xeb\x18\xde\xf5\x35\x4c\x86\x5c\x53\xe4\x51\xd6\xc9\x78\x20\x56\xe8\x78\xa6\x16\x1c\x81\x4f\xc0\x3c\xa1\x9e\xb2\xf8\x87\x8f\xd8\xcc\x8a\xe7\xd3\xdd\x9a\x61\xf8\xeb\xb8\xf6\x91\x20\x44\xce\x2e\x23\x7e\x18\xda\x9b\xe5\x46\xd2\xa2\xa0\x9d\x63\xe5\xab\x97\xb1\x75\x7a\x73\xcc\x39\x1d\xff\x1a\x2e\xd2\x16\x37\x57\xf7\x40\x71\xdd\x2f\x97\x7f\x36\xd4\x14\xe6\x7f\x9e\xe8\xbf\x37\x1b\x39\x7f\x88\x67\x5c\x98\xb6\x15\xf4\xfe\x45\x93\x72\x09\x15\xbb\x57\xdb\xd5\x67\xd6\xe7\x77\xc2\xc7\x01\x47\x38\xf5\x6e\x40\x48\xfa\x83\x01\xc9\x8e\x7c\x11\xf7\x94\xfd\x09\x00\x00\xff\xff\xc9\x35\x3f\x02\xe3\x04\x00\x00" +var _transactionsMigrationContractStagingUnstage_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x53\x4d\x6b\xdc\x40\x0c\xbd\xfb\x57\xa8\x2e\x04\x2f\x6c\xbc\xc9\xd5\xb4\x0d\x69\xa0\xf4\xd2\x36\x74\x49\xef\xb3\xb6\x6c\x0f\x8c\x25\xa3\x91\xb3\x29\x25\xff\xbd\xcc\x8c\xed\x64\x69\x92\x53\x7d\xd8\x05\x7d\xbc\xf7\x24\xbd\xb1\xc3\xc8\xa2\x90\x7f\xb3\x9d\x18\xb5\x4c\x37\x4c\x2a\xa6\xd6\xbd\x9a\xce\x52\x97\x67\xd9\x7b\x4b\x8a\x21\x64\x99\xa0\xc8\x00\x00\xee\x51\xbc\x65\xaa\x20\xbf\x2c\x2f\xcb\x8b\x7c\x1b\xa3\x6a\xd5\x61\x05\xf9\x1d\x79\x35\x1d\xc2\x02\x05\x77\x63\x63\x14\xe7\xaa\x06\x7d\x2d\x76\xd4\xd4\xff\x13\x07\xbe\x47\x0f\xda\x23\xc4\xae\x06\xea\xa5\xad\xe6\x06\xa1\x15\x1e\xd6\xac\xa5\x6e\x4d\x97\xf0\x83\xdc\xef\x98\x5a\x3b\x7a\xf6\x0a\xb5\x21\x18\x51\x5a\x96\xd0\x68\x3d\x24\xe9\xe5\xcc\xef\x0c\x75\x93\xe9\x82\x50\xa4\xf3\xbb\x7d\xbe\xcd\x36\x59\xb6\xdb\xed\x60\xd6\x9d\xc4\x74\xf6\x1e\xe9\x09\xf9\xff\xc9\x88\x54\xd7\xad\xa2\xc4\x26\x15\x43\x3e\xa5\xb6\xa7\x28\x47\xeb\x1c\x10\x83\x63\xea\x50\xe0\xb0\x2e\xa8\x65\x81\x1b\xd3\x20\xd5\x08\x97\xe5\x05\x0c\xcb\xed\x22\x76\xc4\xff\xc2\x02\x03\x4b\x42\xc3\x07\xdd\x82\x47\x8c\xf0\x82\x23\xc3\x39\xf4\xaa\xa3\xaf\x76\xbb\xce\x6a\x3f\x1d\xca\x9a\x87\x1d\x53\xeb\xf8\xb8\x5b\xf8\xcf\xa7\x78\x35\x89\x98\xcf\x54\x16\x4b\xc1\x77\x33\x60\x05\x7b\x15\x4b\xdd\x06\xfe\xa4\xe5\x62\x9a\xbe\x82\xb3\xd7\x1c\x55\x7e\x65\xaf\xb1\x38\xfe\x8c\x82\xa3\x11\x2c\xbc\xed\x08\xa5\x02\x33\x69\x5f\x7c\x66\x11\x3e\xfe\x32\x6e\xc2\x0d\x9c\x5d\xd7\x35\x4f\xa4\x0b\x47\xf8\xc2\x0a\x7d\x68\x81\x80\x06\x82\x2d\x4a\xd8\xc7\x5a\xe0\xd1\xb5\x65\xbc\xc3\x47\x48\xd0\xa5\x57\x16\xd3\x61\x79\x88\xe0\x1f\xde\x16\xf8\xa9\x08\x17\xaf\xe0\xcd\xa2\x7d\x42\xbc\x35\xda\x6f\x56\xe6\xf0\x5d\x5d\xc1\x68\xc8\xd6\x45\x1e\xe5\x1d\x8d\x07\x62\x85\x96\x27\x6a\xc0\x12\xcc\x52\xf2\xd4\xf5\x98\xc5\x3f\x7c\xc0\x7a\x52\x3c\x9d\xf2\xc6\x38\xf7\x8f\xe7\xb6\x11\x20\x44\x4e\x0c\x13\xdf\x8b\xf6\x66\xb6\x4e\xba\x1f\x34\x53\xac\x7c\xd1\x30\x2b\xd3\xab\x63\x4e\xe9\x4d\x2c\xe1\x22\x1d\x77\xdd\xee\x16\x28\xba\xe0\xb9\x27\x4e\x86\x1a\xc3\xfc\x4f\x13\xbd\x7b\x95\xc8\xfa\x7d\x74\x77\x61\x9a\x46\xd0\xfb\x67\x24\xe5\x1c\x2a\x36\x2f\xd2\x55\x27\xab\xcf\x6f\x85\x0f\x0e\x07\x38\xf6\xd6\x21\x24\xfd\x61\x01\x69\x1d\xf9\x2c\xee\x31\xfb\x1b\x00\x00\xff\xff\xbd\x79\x5a\x14\xfa\x04\x00\x00" func transactionsMigrationContractStagingUnstage_contractCdcBytes() ([]byte, error) { return bindataRead( @@ -744,11 +807,11 @@ func transactionsMigrationContractStagingUnstage_contractCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/migration-contract-staging/unstage_contract.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x79, 0x40, 0x72, 0x44, 0xa9, 0xa5, 0x89, 0xae, 0xd0, 0x40, 0x8d, 0xd2, 0x7, 0x64, 0x26, 0x7, 0x95, 0xb3, 0x88, 0xbb, 0x80, 0xdd, 0x20, 0x6f, 0x3e, 0xef, 0x3f, 0x2, 0x51, 0xf0, 0xe3, 0xfe}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa0, 0xee, 0xd4, 0x1c, 0x2d, 0xb4, 0x22, 0xb8, 0xf3, 0x12, 0x44, 0x54, 0x68, 0x4b, 0xbf, 0xb9, 0x3c, 0x74, 0xfd, 0xf2, 0xa9, 0xab, 0xae, 0xf5, 0x55, 0xd6, 0x35, 0x2, 0xd7, 0x6e, 0x67, 0xdc}} return a, nil } -var _transactionsTestSetup_updater_with_empty_deploymentCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x8f\xbd\x6e\xeb\x30\x0c\x85\x77\x3d\x05\x91\xc9\x01\xf2\xb3\x07\x59\x7c\x83\x3b\x74\x49\x8b\xda\x9d\x8a\x0e\xac\xc4\xc6\x42\x6d\x51\xa0\xa8\x16\x46\x91\x77\x2f\x1c\x1b\x46\x03\x24\x9c\x24\x1e\xf2\xf0\x7c\xbe\x8b\x2c\x0a\x8b\x4a\xf1\x44\xee\xc0\x41\x05\xad\xbe\x44\x87\x4a\x69\x61\xcc\x76\xbb\x85\xfa\x7f\x55\x43\xfd\x5c\x1e\xab\xf2\x50\x3f\x3c\x1e\x2f\xcd\xaa\xe1\xdc\x3a\xf8\x40\xdf\x02\x07\x18\x37\x64\xe3\x83\xd7\x62\x09\x2e\x13\x28\x03\x75\x51\x7b\x68\x38\x69\x02\x0c\x0e\x1c\xc5\x96\xfb\x8e\xc2\xf0\x17\xc1\x3e\x0d\x5e\x46\x05\x43\x42\xab\x9e\x03\xfc\x18\x00\x80\x28\x14\x51\xa8\x48\xfe\x14\x48\x76\x50\x66\x6d\x4a\x6b\x39\x07\x5d\x4e\x23\x43\xb5\xa4\x90\xc7\xcb\xb0\x5f\xc3\x4d\x88\x8d\x15\x42\xa5\x23\x7d\x4f\x19\x8b\x79\x7d\xa8\xf7\x96\xed\xe7\xa8\xfc\xe3\x1c\x1c\x4a\xbf\xbb\x63\x74\x63\x74\x75\xe5\x75\x01\xdd\xc1\xeb\xdb\x75\xfb\x0f\xf5\x20\xce\xda\x72\x7e\x8d\x98\x9b\x84\x5f\x54\xec\xd7\x13\xd1\x0a\x94\xef\x45\x99\x50\x2a\x65\xc1\x13\x3d\xa1\x36\xa3\xd9\xd9\x9c\xcd\x6f\x00\x00\x00\xff\xff\x24\x61\x75\x76\xd3\x01\x00\x00" +var _transactionsTestSetup_updater_with_empty_deploymentCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x91\x41\x6b\xeb\x30\x0c\xc7\xef\xf9\x14\xa2\x87\x92\x40\x9b\xde\x43\xdf\x83\xbe\xf2\x60\xbb\x74\x63\xc9\x76\x09\x3d\xa8\x89\xd6\x98\xa5\x96\xb1\xe5\x8e\x30\xfa\xdd\x47\xea\x50\x1a\x48\x75\x49\x64\xe9\xff\xb3\xfe\xb2\x3a\x19\xb6\x02\xb3\x5c\xf0\x48\xf5\x96\xb5\x58\xac\xe4\xdd\xd4\x28\xe4\x66\x51\xb4\x5a\xad\xa0\xf8\x9f\x17\x50\xbc\x6d\x76\xf9\x66\x5b\x3c\xbf\xec\xae\x87\x79\xc3\xbe\xad\xe1\x13\x55\x0b\xac\x21\x28\x6c\xaa\xb4\x92\x38\x81\xda\x13\x08\x03\x9d\x8c\x74\xd0\xb0\x13\x07\xa8\x6b\xa8\xc9\xb4\xdc\x9d\x48\xf7\xb9\xb5\xd8\xb9\x9e\x15\x89\x45\xed\xb0\x12\xc5\x1a\x7e\x22\x00\x00\x63\xc9\xa0\xa5\xd8\xa9\xa3\x26\x9b\x01\x7a\x69\xe2\x1c\xcf\xf4\x81\xad\xa7\x04\xe6\x9b\xaa\x62\xaf\x25\x19\xfa\xfb\x68\x49\xc2\x55\x19\x94\x5b\x34\x78\x50\xad\x92\x6e\x3d\x9f\xb4\x96\x3e\xb1\x93\xbf\x7b\xf8\x03\xe5\x7e\x44\xb8\x1b\x31\x83\xb2\x9c\x16\x8f\xf3\xfd\x04\xc6\x87\x7d\xc0\x7a\x09\xd3\x88\xca\x12\x0a\xed\xe8\x7b\xd8\x5c\x7c\x93\xf7\x71\x68\xb9\xfa\x0a\x95\x7f\xec\x75\x8d\xb6\xcb\x1e\x80\x26\x5a\x17\x23\xd6\xb0\x93\xeb\x67\x5c\x19\x79\xbd\x4b\x6e\x4d\xc9\xed\x2f\x3c\x44\xea\x84\x2d\x1e\x29\x75\x78\xa6\x78\xbd\x1c\x5c\x2e\x40\xf8\xd1\x78\x83\xbd\x3c\x08\x5f\x51\x9a\x00\xbd\x44\x97\xe8\x37\x00\x00\xff\xff\x38\x39\xf1\x82\x7d\x02\x00\x00" func transactionsTestSetup_updater_with_empty_deploymentCdcBytes() ([]byte, error) { return bindataRead( @@ -764,11 +827,11 @@ func transactionsTestSetup_updater_with_empty_deploymentCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/test/setup_updater_with_empty_deployment.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6a, 0xac, 0x11, 0x24, 0x6e, 0xa0, 0xd0, 0x7d, 0x59, 0xac, 0x2d, 0xec, 0x48, 0x5c, 0x93, 0x29, 0xcd, 0x74, 0xeb, 0x38, 0xf1, 0x28, 0x14, 0xcf, 0x45, 0x3c, 0x76, 0x2c, 0x77, 0x83, 0xc6, 0x14}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x74, 0x7f, 0x5a, 0x29, 0xe8, 0xfe, 0x8a, 0x3c, 0x21, 0x13, 0x33, 0xb8, 0x78, 0xd, 0xfd, 0x82, 0x57, 0xb2, 0x3a, 0x1c, 0x9e, 0x38, 0x9f, 0x2d, 0xdf, 0xa4, 0xca, 0xab, 0xa1, 0x54, 0x28, 0x9b}} return a, nil } -var _transactionsTestTick_tockCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2c\x8e\xb1\x6e\xc4\x20\x0c\x86\x77\x9e\xc2\xba\x09\x96\x64\xbf\x8d\x9e\x3a\x74\xb9\x4a\x0d\x7d\x00\xea\xb3\x08\x6a\x62\x22\x63\xba\x54\x79\xf7\x0a\x7a\x1e\x3c\x58\xff\xff\x7d\x9e\xe7\x19\xc2\xeb\x12\x20\x7c\xf8\xfb\xe2\x6f\xe1\xed\xfd\x6e\xfa\xf1\xb3\xd2\x03\xb4\xc0\x5e\xf0\x1b\xbe\xb6\xbe\xe3\xe3\x27\x32\xd2\x4e\xac\x90\x19\x94\xaa\x42\x6d\x59\xa9\x17\x8c\x4a\xe4\x1a\x51\x73\x61\xf8\x35\x00\x00\x87\xd0\x11\x85\x6c\xcd\x89\x49\xae\xe0\x9b\xae\x1e\xb1\x34\x56\xf7\x8c\xf4\xd9\x4a\xb2\x97\x97\x61\x58\x29\xa7\xb5\xc3\x51\x86\x66\xbc\x70\x85\xcb\x84\x85\x31\xaa\x4d\xa4\xb7\x26\x42\xac\x23\x6f\xdd\xf4\xdf\x98\xb4\x2c\x2a\x99\x93\x75\xce\x0d\xf0\x69\x4e\xf3\x17\x00\x00\xff\xff\x35\x3a\x18\xf8\xdc\x00\x00\x00" +var _transactionsTestTick_tockCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2c\x8d\x31\x4e\xc6\x30\x0c\x85\xf7\x9c\xc2\xfa\x07\x94\x2c\xed\xde\xad\x54\x0c\x2c\x45\xa2\xe1\x00\xc1\xb5\xd2\x88\xd6\xa9\x1c\x97\x05\xf5\xee\x28\x01\x0f\x1e\xec\xf7\xbe\xaf\xef\x7b\xf0\x2f\x8b\x07\xff\x3e\xce\xcb\x38\xf9\xd7\xb7\xd9\xd4\xe3\x47\xa1\x15\x34\xc3\x91\xf1\x0b\x3e\xf7\xba\xc3\xfa\x1d\x18\xe9\x20\x56\x48\x0c\x4a\x45\xa1\x5c\x49\xa9\x16\x8c\x4a\xe0\x12\x50\x53\x66\xf8\x31\x00\x00\xa7\xd0\x19\x84\x6c\x49\x91\x49\x06\x78\x1a\x11\xf3\xc5\xea\xfe\xff\x75\xf6\x1c\xed\xe3\xb9\xe1\x37\x4a\x71\xab\x64\x94\xe6\x68\xfe\x01\x1e\x1d\x66\xc6\xa0\x36\x92\x4e\x97\x08\xb1\xb6\xbc\x75\xdd\x5f\xa3\xd3\xbc\xa8\x24\x8e\xd6\x39\xd7\xc0\xb7\xb9\xcd\x6f\x00\x00\x00\xff\xff\xa1\xdf\xf4\xb8\xd9\x00\x00\x00" func transactionsTestTick_tockCdcBytes() ([]byte, error) { return bindataRead( @@ -784,11 +847,11 @@ func transactionsTestTick_tockCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/test/tick_tock.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9e, 0x69, 0xa7, 0x2f, 0x63, 0x1b, 0x1b, 0x80, 0xfa, 0xd, 0x26, 0x49, 0x7d, 0xe, 0x13, 0x9e, 0x89, 0x76, 0xd9, 0xac, 0x61, 0x80, 0xb5, 0x8c, 0x82, 0xe3, 0x48, 0x6f, 0x40, 0x9b, 0x7b, 0xbb}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7f, 0x24, 0xdf, 0x75, 0xbf, 0x44, 0xf7, 0xb4, 0xc, 0x2a, 0xf2, 0x21, 0xb, 0x9b, 0x21, 0x34, 0x48, 0xab, 0x5d, 0x43, 0xab, 0xd3, 0xbf, 0xad, 0xd2, 0x54, 0x84, 0x81, 0x52, 0xdf, 0xf8, 0xb3}} return a, nil } -var _transactionsUpdaterDelegateCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x55\x4d\x6b\xe3\x5a\x0c\xdd\xe7\x57\xa8\x5e\xb4\x36\x3c\x9c\xcd\xe3\x2d\xc2\xcb\x0b\x25\x81\x47\x60\x16\x61\x42\xd7\xc3\xcd\xbd\xb2\x23\xea\xe8\x1a\x59\x4e\x27\x94\xfc\xf7\xc1\xf1\x47\xec\xc4\xed\xcc\xc0\x74\x55\x3b\xd2\xd1\x39\xd2\x91\x4c\x87\xdc\x8b\x42\xb0\x55\x93\xa2\x5b\x7a\x56\x31\x56\x5f\x72\x67\x14\x8b\x60\x32\x99\x4e\xa7\xb0\x14\xac\x9e\xc0\x40\x2e\x74\x34\x8a\x50\xff\x2e\xb0\x34\xb9\xd9\x51\x46\x7a\x02\xc3\x0e\x52\x3a\x62\x01\xa4\xa0\x1e\x74\x8f\x30\x0a\x0a\x2b\xcc\x30\x35\x8a\x58\x81\x4f\x54\x0c\x17\xc6\x2a\x79\x86\xf7\xc9\x04\x00\x20\x43\x05\xd7\x06\xcd\xe0\xf1\x7d\x14\x27\xee\x70\x36\xe5\x2e\x23\x7b\xee\x72\xcb\x9a\xdd\xd2\xe4\xb3\x1e\xc3\x7f\x1f\xc7\x61\x1a\x2d\xff\xdd\xa6\xaf\x57\x33\x78\x59\xb3\xfe\xf3\x77\xcd\x2a\x17\xcc\x8d\x60\x58\x50\xca\x28\x33\x78\x2e\x75\xff\x6c\xad\x2f\x59\xa3\x96\x79\xf5\x37\x9d\xc2\x57\x3c\xa2\x28\x50\x72\xe9\x42\x9d\x00\xce\x63\xc1\x4f\x0a\x26\x13\x34\xee\x04\x7b\x73\x44\x30\xdc\xf5\xd2\x7a\x4e\x28\x2d\x05\x5d\x07\x45\x49\x93\x1c\xeb\x29\xc7\xd0\xe8\x6c\xbc\xa5\xad\x86\xad\x7a\x31\x29\x6e\x8c\xee\x23\x98\xcf\x81\x29\x83\xf7\x0e\xed\x22\xc2\x30\xd9\x30\xd8\x5e\x29\x01\x7b\xfd\x84\x4b\x10\x75\xf9\xe7\xbe\xc4\x8a\x01\x71\x89\x71\x1c\x0f\xa4\xff\x8f\x0a\x82\x09\x0a\xb2\xc5\xd6\x07\xb6\xa1\xfb\xd4\x1b\x7e\x3d\xb4\x2e\xb5\xc0\x2c\x89\xbb\xa1\xc3\xfc\x03\xa1\x29\x6a\xfb\xaa\x43\xba\x8e\x38\x8c\xe2\x9d\x17\xf1\x6f\x61\x34\x50\xbd\x58\xb4\xc2\x97\xbe\xcc\xdc\x45\x72\x1d\x78\xe5\x73\x65\x1d\x44\x57\x45\x3d\x3f\x6c\x6a\xef\x57\xcd\x85\x39\xf4\x9e\xc2\x41\xad\xcb\xdc\x1c\xb2\x52\x42\x95\x4d\xc6\x37\xab\x69\xf4\xb7\x20\xb6\x9e\xad\xd1\x7b\x8c\xfb\xa6\xc4\xfe\x8d\x51\x16\xb1\x71\x4e\xb0\x28\x16\xb1\xfa\xad\x0a\x71\x1a\x46\x3d\x85\x1b\xf1\xbb\x0c\x0f\x9d\x1c\xe2\xf4\x93\xfe\xc3\x05\x13\x1a\xc8\x20\xba\xa3\x31\x7c\x13\x3d\x0c\x86\xfd\x85\xf8\x75\xec\x16\x10\x77\x97\x82\x12\x60\x44\x87\x0e\x1e\x41\x50\x85\xf0\x88\x7d\x7f\x3f\x34\x06\xaf\x06\xfb\xcb\xab\x1a\xde\x8f\x24\x8a\xed\x1e\xed\x6b\x18\xdd\x18\xbe\x81\x2f\x39\x23\x7e\x1d\xcb\x1b\x8b\xae\x62\x7f\xca\xe1\xae\x55\xf7\xe0\x7f\xdd\xc5\xa8\x91\x14\x7f\x63\x8d\x27\xe3\xb3\x38\x0f\xf7\xe6\x7a\xf0\x60\x0e\x7f\xaa\xa1\xa3\x25\xd6\xab\xaa\xc2\xb0\x66\xb7\x73\x8b\xaa\xe8\x7a\x35\xb0\xe3\x9a\x8f\x26\x23\x37\xe6\x92\xd6\x0e\x0e\x12\xf1\x87\x86\xf7\x43\xe3\xc1\x73\x6d\x34\xfc\x8e\xb6\x54\xec\x0d\xf5\x66\x27\xda\xff\xc2\xfe\xd1\xbf\x21\x38\x40\xcc\x7d\xa1\x3d\xb8\xfa\x94\x25\x24\x07\x28\x4a\x6b\xb1\x28\x92\x32\x6b\xbf\x3e\xe4\xf9\xa3\xba\xb5\xdb\xc8\xcd\x6e\xda\x73\xb9\xbb\x2a\x25\xce\x20\x18\xd1\xfc\x66\xea\x83\x9b\x8b\xcf\x51\xb2\x53\xf7\x9d\x73\x41\x43\xf2\xfc\x23\x00\x00\xff\xff\x71\xef\x00\x20\x92\x07\x00\x00" +var _transactionsUpdaterDelegateCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x56\x4b\x6f\xe2\x4c\x10\xbc\xf3\x2b\x3a\x3e\x10\x5b\x42\xe6\xf2\xe9\x3b\xa0\x10\xb4\x0b\xd2\x8a\x5b\xb4\x28\x7b\x5d\x35\x33\x6d\x33\x5a\x33\x63\xcd\xb4\x9d\x45\x11\xff\x7d\xe5\xf7\x03\x13\x45\xbb\x39\xe1\x47\xd7\x54\x55\x57\xb7\xa3\xce\xa9\xb1\x0c\xde\x81\x31\x26\xb9\x35\x9a\x2d\x0a\x7e\x4d\x25\x32\x39\x6f\x36\x5b\x2e\x97\xb0\xb5\x54\x5c\x01\x42\x6a\x55\x8e\x4c\x50\x3d\xb7\xb0\xc5\x14\x8f\x2a\x51\x7c\x01\xd4\x12\x62\x95\x93\x03\xc5\xc0\x06\xf8\x44\x30\x09\x0a\x3b\x4a\x28\x46\x26\x2a\xc0\x67\x6c\x51\x3b\x14\xac\x8c\x86\xf7\xd9\x0c\x00\x20\x21\x06\xd9\xbc\xb4\x82\xf9\xfb\x24\x4e\xd8\xe2\xbc\x64\xc7\x44\x89\x6b\x5b\x9b\x55\xec\xb6\x98\xae\x7a\x0c\x9f\x30\xe3\x93\x5f\x15\x37\x50\x01\xcc\xa7\xb1\x6b\x81\xcf\x63\xcc\xfd\x6e\x05\xaf\x7b\xcd\xff\xff\x57\x51\x4d\x2d\xa5\x68\xc9\x77\x2a\xd6\x64\x57\x50\x9e\xf1\xd5\x58\x6b\xde\x7e\x60\x92\xd1\x02\xb6\x26\xbd\xd4\x3f\xf7\xce\x65\x74\x60\x63\x31\xa6\x8e\x57\x79\xb4\x49\x12\xb2\x0b\x28\x95\xb8\x53\xf7\x70\x01\x07\xcc\xa9\xac\x0f\x60\xfe\x45\x08\x93\x69\x0e\x1a\xa3\x8a\xbf\xe5\x12\xbe\x53\x4e\x96\x41\x45\xa5\xe9\x15\x15\x90\x86\x9c\x7e\x64\xc0\xc4\x12\xca\x0b\x9c\x30\x27\x40\xdd\xb6\x4e\x18\x1d\xa9\x38\xb3\x24\x5b\x28\x15\xd5\xc5\xa1\xab\x48\x86\x7c\x49\xc9\x47\x5e\x4d\x77\xb2\x71\xa9\x96\xf4\x82\x7c\x0a\x60\xbd\x06\xad\x12\x78\x6f\x51\x4b\x9b\x50\x2b\xe1\x7b\x87\x8e\x1a\x68\xc3\x1f\x70\xf2\x82\xb6\xfe\xda\x97\x5a\x30\x50\x3a\xa3\x30\x0c\x07\x16\x7c\x23\x06\x4b\x11\x59\xd2\x82\x9a\xf8\x89\x9a\xee\x63\x2f\x73\x55\x56\xda\x52\x47\x49\x14\xb6\x59\x83\xf5\x1d\xa1\x31\x71\x73\xab\x45\xea\x9a\xe4\x07\xe1\xb1\x6c\xb9\x1f\x0c\x54\x6f\x36\x8d\xf0\xad\xc9\x12\x59\x4a\xae\x5e\xec\xf8\x74\xac\xbd\xa0\x53\x34\x4c\x71\xcf\xdf\x92\x61\x7b\xe5\x0f\x8e\x2b\x5b\x28\x49\xb3\x8a\x54\x91\xc5\xe9\x99\x7e\x6d\x61\x6b\xf6\x3f\xbd\x50\x18\x2d\x90\x6f\xd1\x6e\x1d\x0a\xcd\x9b\x26\xbb\x09\x51\x4a\x4b\xce\x6d\x42\x36\x07\xb6\x4a\xc7\x7e\xd0\x93\xfb\x62\xcd\x31\xa1\x73\xab\x4d\xe9\xf8\x83\x66\x40\x89\x09\x35\xa4\x17\xdc\xd0\x18\xde\x09\x1e\x06\x9d\x2f\x87\x6a\x6a\x21\xa9\x08\x34\x91\x24\xb9\x80\x22\xce\x04\x73\xb0\xc4\x56\x51\x4e\x9f\x49\xfc\xa4\xfd\x77\xe2\x3d\xc2\x70\x98\xd3\xad\x99\xf5\x4b\xa2\x61\xa8\xc8\xb5\x15\xaa\x10\xf1\x57\x0b\xca\xff\xf4\x64\x2e\x6e\x18\xb1\xb9\x23\x73\x36\xed\xfe\x75\x38\x36\x5d\x29\xac\xc7\x16\x08\x93\x5e\x9e\xfe\x71\xf7\x3e\xfb\x91\x35\xe7\x7b\x9d\xb8\x33\x69\x5d\xf4\xca\x56\x17\xc9\xbb\xcd\x46\x2f\x63\xe8\x1c\x59\xf6\x47\x82\x42\x71\x22\xf1\xcb\x0f\x16\x70\x26\xe7\x30\xa6\x15\x78\x7b\x9d\x63\xa2\xe4\x54\xd4\x9a\x5c\xf5\xd7\x56\x1f\x71\xbf\x2b\x1c\x1a\x1d\xd1\xac\x8c\x4d\xb1\x5d\xf6\xbb\xc1\x00\x7d\xe6\x2c\x28\xdc\xa9\x7d\x7f\xa8\x0f\xbe\x56\xa3\x41\xbf\x49\x64\x4c\xbd\x94\x8e\xa6\xb8\xf9\xe5\xf7\x3f\x95\x23\x82\x03\xc4\xd4\x38\xee\xc1\x55\x9b\x38\x52\xf6\x0c\x2e\x13\x82\x9c\x8b\xb2\xa4\xf9\x66\x2b\xa3\xef\x9d\x5b\xd9\xaa\xe4\x6a\x64\x4f\x39\x57\x6c\xb3\xc2\xe7\x09\xcd\x6f\x58\x7d\x2f\x52\x6b\x52\xb2\xc9\xa5\xfd\xef\x40\x7a\x35\xc9\xeb\x9f\x00\x00\x00\xff\xff\xa8\x52\xf4\x6f\xc8\x08\x00\x00" func transactionsUpdaterDelegateCdcBytes() ([]byte, error) { return bindataRead( @@ -804,11 +867,11 @@ func transactionsUpdaterDelegateCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/updater/delegate.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x42, 0xe4, 0x57, 0xf7, 0xee, 0x20, 0x63, 0xeb, 0xc7, 0xa7, 0x7, 0x4c, 0x10, 0x83, 0x26, 0x4c, 0xd, 0x4c, 0xc0, 0x32, 0x47, 0x7b, 0x7b, 0x5d, 0xee, 0xf6, 0x6b, 0x55, 0xd3, 0x99, 0xff, 0xd0}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe3, 0xc9, 0xdf, 0x6c, 0x7c, 0x5e, 0x37, 0x8e, 0x85, 0x5a, 0xc6, 0xd, 0xdd, 0x89, 0x76, 0x22, 0x7f, 0x2d, 0x9d, 0xad, 0xef, 0xfe, 0x22, 0x68, 0xa, 0x26, 0x58, 0x8d, 0x3e, 0x8b, 0xca, 0x87}} return a, nil } -var _transactionsUpdaterRemove_from_delegatee_as_updaterCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x41\x8f\xda\x3c\x10\xbd\xe7\x57\xcc\xe6\xb0\x9b\x48\xfb\x85\xcb\xa7\x1e\xa2\x52\x84\xe0\xc2\x0d\x75\xb5\xe7\xca\xd8\x43\xb0\x1a\xc6\xd1\x78\x02\x5d\xad\xf8\xef\x55\x12\x13\x12\xc8\x4a\xf5\x01\xc9\x86\x79\x6f\xde\x9b\x37\xd8\x63\xe5\x58\x20\x7e\x13\x55\xa0\x59\x39\x12\x56\x5a\xde\x2b\xa3\x04\x7d\x1c\x45\xb3\xd9\x0c\x7e\xa2\xb0\xc5\x13\x7a\x50\x04\xdd\x57\x0c\x2b\x55\xa9\x9d\x2d\xad\x7c\xc0\x9e\xdd\x11\xe4\x80\xe0\x6d\x41\xc8\x2f\x1e\x94\xd6\xae\x26\x79\x05\xe5\x7d\x7d\xb4\x54\x80\x23\x04\xeb\xa1\x62\xfc\x4f\x3b\xda\xdb\xa2\x66\x34\xaf\xa0\xc8\x00\xe3\xd1\x35\xe0\x56\x7a\xa4\x96\x76\x8d\x25\x16\x4a\x10\xc1\x52\x0b\x3f\xd9\x23\xe8\x70\xbf\x92\x66\x4d\x71\x24\xac\xc8\x2b\x2d\xd6\x11\x7c\x46\x00\x00\xed\x47\x89\x02\xe6\x8a\x9b\xc3\xf3\xe7\x24\x66\xd6\x53\x6f\xeb\x5d\x69\xf5\xa5\xaf\xad\x3b\xf5\x2b\x55\xe5\x03\x07\xbe\x3f\x4f\xc3\x04\xaf\x7e\xdc\x97\x6f\xd6\x39\xbc\x6f\x48\xbe\xfd\x7f\xeb\xac\x62\xac\x14\x63\xd2\x79\x98\xc3\xb2\x96\xc3\xb2\x53\x94\x06\x05\xcd\xf1\x58\xee\xb3\x5e\x01\xcc\xa7\x4d\xc9\x0a\x94\xeb\x53\xaf\xe5\xd6\x6f\x92\x66\x3b\xc7\xec\xce\x49\xda\x03\x37\x67\xb1\x80\x4a\x91\xd5\x49\xbc\x72\x75\x69\x80\x9c\x40\xf7\xc3\xc1\x30\x18\xf7\xc8\x48\x1a\xe3\x34\xea\xab\x07\xe2\xb6\x6c\x4f\x4a\x70\xab\xe4\x00\x73\x18\xdc\x92\x11\x57\x73\xac\x41\x12\xbb\xb7\x8d\xde\xe9\x04\x06\x07\x7f\xc5\x99\x76\xa4\x95\x3c\x62\x3c\x9a\x92\xb9\x33\x21\x2f\x32\x65\x0c\xa3\xf7\x8b\x4c\xdc\x9b\xb0\xa5\x22\x49\x07\x0a\xb7\xec\x76\x25\x1e\x7b\x39\x4d\x48\xaf\x51\x7a\xf1\x70\x97\x00\x68\x31\x21\x40\xc6\xe9\x43\x1b\xe3\x97\xf4\x29\x1a\x4f\xec\x96\x1b\x98\x87\x35\x69\x67\xf4\xcf\x11\x4a\x1e\xdd\x4d\x27\x29\x36\xeb\x86\x61\xcc\xd9\x4f\x7b\xd1\x90\x6e\xd6\x23\x23\x36\x74\x52\xa5\x35\x53\x8b\xcd\x61\xf1\x4d\xb7\x98\x5d\xdf\x4f\x41\xfd\xa5\x93\x88\x7f\x50\xd7\x82\x5f\x46\x34\xeb\xd6\x7b\x79\x1d\x65\x32\x5c\xa1\xbb\x3e\x47\xc0\x95\xf3\xf2\x35\xaa\x3e\xa0\xfe\x9d\x58\x93\xdf\x89\x4f\x61\x3e\x07\xb2\x65\x0e\xf1\x84\xa0\xb3\xf2\x6d\xa8\x2b\x76\x15\x72\xf9\x11\xfe\x7b\x82\xbe\x7e\xe6\x71\xe8\xe3\x12\xfd\x0d\x00\x00\xff\xff\x8f\x8c\x82\x8b\x1f\x05\x00\x00" +var _transactionsUpdaterRemove_from_delegatee_as_updaterCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x95\x4f\x6f\xe2\x3c\x10\xc6\xef\x7c\x8a\x69\x0e\x6d\x22\xf5\x4d\x2f\xaf\xf6\x10\x95\xa2\x2e\x5c\xb8\xa1\xad\xba\xd7\xd5\x60\x0f\xc1\xda\x60\x5b\xe3\x49\xbb\xa8\xea\x77\x5f\xe5\x2f\x09\x84\x53\x4f\xeb\x03\xc2\x01\x3f\x33\xcf\xcf\x33\x13\x73\xf0\x8e\x05\xa2\x17\xc1\x9c\xf4\xd2\x59\x61\x54\xf2\xea\x35\x0a\x85\x68\x36\x7b\x78\x78\x80\x1f\x24\x6c\xe8\x8d\x02\xa0\x85\xe6\x27\x86\x25\x7a\xdc\x9a\xc2\xc8\x11\x76\xec\x0e\x20\x7b\x82\x60\x72\x4b\x7c\x17\x00\x95\x72\xa5\x95\x7b\xc0\x10\xca\x83\xb1\x39\x38\x4b\x60\x02\x78\xa6\xff\x94\xb3\x3b\x93\x97\x4c\xfa\x1e\xd0\x6a\x60\x3a\xb8\x4a\xdc\x48\xaf\x54\x87\x5d\x51\x41\x39\x0a\x11\x18\x5b\xcb\x4f\xe6\x08\xaa\xdd\x77\x41\xd3\xea\xf0\x4c\x18\x6d\x40\x25\xc6\x59\xf8\x98\x01\x00\xd4\x1f\x05\x09\xe8\x4e\x37\x83\xdb\x8f\x49\xcd\xb4\x0f\xbd\x29\xb7\x85\x51\x9f\xfd\xd9\xb2\x71\xbf\x44\x9f\x0d\x08\x3c\x62\x29\xfb\xb8\x39\xdc\x49\x25\x70\x3b\xad\xdd\x02\x7c\x3a\xd7\x5c\xaf\x32\x78\x5d\x5b\xf9\xf6\xff\x29\x5d\xcf\xe4\x91\x29\x6e\xc0\x66\x50\xc7\xf9\xee\x98\xdd\xfb\x4f\x2c\x4a\xba\x87\xa5\xf3\xc7\xfa\x6b\x02\xb7\xcf\x0d\x80\xa4\x35\x5c\xad\x40\xc5\x2e\xed\x0d\xc3\x7c\x9a\x61\x9a\x93\x74\x8f\x7a\xeb\x27\x7b\x71\x92\x6e\xeb\x98\x71\xd2\x0b\x57\x6b\xb1\x00\x8f\xd6\xa8\x38\x5a\xba\xb2\xd0\x60\x9d\x40\xf3\xc7\xc1\xdd\x31\xed\x88\xc9\x2a\x8a\x92\x59\x7f\x7a\x60\x7b\xc3\xe6\x0d\x85\x36\x28\x7b\x98\xc3\x60\x17\x8f\x62\x55\xcb\x68\xb2\x62\x76\xa6\x22\x31\x5d\xb0\x2d\xdb\x5f\x51\xaa\x9c\x55\x28\x97\x1a\x97\x50\x52\xf7\x6e\x89\x17\x29\x6a\xcd\x14\xc2\x22\x15\xf7\x22\x6c\x6c\x1e\x27\x03\x87\x1b\x76\xdb\x82\x0e\xbd\x9d\xaa\xa6\xbb\xca\xbb\x0b\x70\x56\x30\x50\x6b\x42\x2b\x19\x25\x17\x69\x8c\x9f\x24\x37\x53\x64\x96\xe8\x5f\xc4\x31\xe6\x1d\x9c\xc1\xee\x0b\x70\x4e\xf7\xfa\x0f\x62\x1a\x17\xf6\x09\x14\xcc\xdb\xe1\x93\x86\x06\x52\xaa\x9c\x3f\x3e\x7e\xb1\x45\x9f\xe2\x6a\x20\x65\xd3\x17\x72\xad\x17\x4e\x08\xea\xa9\x59\x11\xb8\x9c\x99\xc3\x66\x18\x5a\x59\xaf\x2a\x27\x63\x6f\x7d\xf3\x2d\xaa\x3e\x5d\xaf\x46\xc0\xd7\xf6\x0d\x0b\xa3\xa7\xc6\x72\x9b\x00\xe9\x66\xac\x36\x7c\x6e\x5a\xca\x9f\x4d\x7c\xfa\x43\xaa\x14\xba\x3a\x31\xd2\x66\x38\x3f\x77\xc5\x13\x0f\x07\xe0\x59\x9e\x23\x61\xef\x82\x5c\x57\x55\x7b\x52\xbf\x63\xa3\xb3\x33\xf3\x09\xcc\xe7\x60\x4d\x91\x41\x34\x61\xe8\x1d\x43\x3d\x63\x3c\x3b\x4f\x5c\x1c\xdb\x37\x47\xeb\xaf\xaf\xad\xa8\xcd\xe3\x73\xf6\x37\x00\x00\xff\xff\x06\x23\x5f\x56\xdd\x06\x00\x00" func transactionsUpdaterRemove_from_delegatee_as_updaterCdcBytes() ([]byte, error) { return bindataRead( @@ -824,11 +887,11 @@ func transactionsUpdaterRemove_from_delegatee_as_updaterCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/updater/remove_from_delegatee_as_updater.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x12, 0x82, 0xcc, 0xc2, 0xab, 0x3a, 0xf1, 0xf5, 0x97, 0x37, 0xf6, 0x14, 0xc7, 0xa6, 0x83, 0x2f, 0xcd, 0x44, 0xee, 0x72, 0xc8, 0xe, 0x1f, 0xd1, 0xd1, 0x1b, 0xb3, 0x18, 0x90, 0x71, 0x9a, 0x55}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7c, 0x9, 0x5, 0x5a, 0x5a, 0x51, 0x4b, 0x3c, 0xc8, 0x7b, 0xe9, 0x8d, 0x8f, 0xad, 0x92, 0x5c, 0xfa, 0x99, 0xf2, 0xe4, 0xfe, 0x4, 0xe2, 0xaa, 0x58, 0x8e, 0x17, 0x12, 0x8d, 0xe4, 0x94, 0x2e}} return a, nil } -var _transactionsUpdaterSetup_updater_multi_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x56\x4d\x6f\xe3\x36\x10\xbd\xfb\x57\xcc\xe6\xb0\xb5\x01\xc7\xb9\x14\x3d\x18\x49\xd3\x34\xdd\x22\x7b\x68\x1a\x6c\x76\x7b\x09\x7c\x18\x93\x23\x89\x88\x44\x0a\xe4\xc8\x89\x10\xf8\xbf\x17\x43\x7d\x44\xb2\x95\x20\xeb\x8b\x4d\xcd\xd7\x9b\x79\x8f\x23\x9b\xa2\x74\x9e\xe1\xe4\x1f\x62\xd4\xc8\xf8\x9f\xa1\xa7\x70\x32\x9b\x75\xcf\xef\x19\x53\xd2\xd7\xce\xb2\x47\xc5\x3f\x4a\x8d\x4c\x62\x3f\x3b\x3b\x83\x6f\xc4\xde\xd0\x8e\x02\xdc\xb8\xc0\x70\x8d\x25\x6e\x4d\x6e\xd8\x50\x80\xc4\xbb\x02\x38\x23\x50\x6d\xe8\x69\xe6\x02\x1b\x9b\x02\x2a\xe5\x2a\xcb\x01\xd0\x6a\xc0\x10\x4c\x6a\xe5\x37\x54\x31\x37\x68\x2a\x73\x57\x17\x64\x19\x8c\x95\xe7\x64\x15\x96\xa1\xca\x51\xa2\x63\xdd\x06\x85\x5f\xc1\xf7\xcc\x04\xd0\x54\xb8\x98\x00\xf5\x0e\xad\x22\x0d\x0a\x03\xc1\x53\x46\x9e\xde\xca\xbb\x73\xb9\xc0\x46\xb0\xc4\x4f\xce\x3f\x82\x4b\xc4\x81\xac\x16\x7b\x07\x39\x00\x2a\xef\x42\x88\x45\x8b\x2a\x67\x53\xe6\x04\x87\x7d\xac\xc4\x1c\x5d\x6e\xff\xfd\xfe\xe5\x7e\x3d\xa8\x74\xed\x6c\x62\x52\x30\x01\x9c\xd7\xe4\x49\x2f\x63\xd3\x32\x96\xf8\x40\x2c\x55\x20\x0d\xec\x40\x13\x93\x2f\x8c\xa5\x81\xd9\x25\xa3\x11\x06\x99\x88\x3c\x78\xad\x10\x8b\xc3\x17\x54\x19\x90\x65\x5f\x77\x1e\xe8\x3d\xd6\x50\x54\x81\x61\x4b\x40\xcf\xa8\x38\xaf\xc1\x59\x82\x47\xaa\x4f\x77\x98\x57\x04\x25\x1a\xbf\x6c\xe7\x24\x31\x8f\x54\x0b\xa0\x18\xae\xb5\xa7\x10\x3a\x00\x18\x82\x53\x06\x59\x66\xdb\x62\x89\x75\x2d\x16\x14\x3b\x52\x4e\x53\x03\x25\x52\xc2\x1e\x6d\x40\xc5\xc6\x59\xc0\x3c\x38\x49\x50\x15\x24\xb9\x91\x01\xf3\xbc\x4f\xd3\x4f\xf3\xaa\xe2\xec\xaa\x99\xe8\x58\x48\x19\xee\x08\xb6\x44\x16\xca\x6a\x9b\x9b\x90\x91\x86\xc4\xf9\x88\x4b\xb4\x43\x3e\xd6\x65\x07\x2a\x47\x53\x34\x6c\x0c\x00\xcc\xb7\xb9\x53\x8f\x37\x64\xd2\x8c\xff\x74\x95\xd5\xe8\xeb\x35\xfc\xf8\x6a\xf9\xb7\x5f\x2f\x97\x3d\x90\xab\xa6\x63\x0a\x6b\x78\x68\x7f\x6f\x96\x47\x54\xae\xe1\xe1\xe1\xa5\x35\xaf\xe1\xe5\x9e\xbd\xb1\xe9\x1a\x9a\xef\xfd\x7e\xb3\x59\xc0\xcb\x6c\x06\x00\x50\x7a\x2a\xd1\xd3\xbc\x81\xb8\x1e\xf6\x27\x3e\xd0\x7e\xce\xce\xe0\x6a\x2b\x17\xcd\x24\x9d\xac\x85\x03\xcc\x3d\xa1\xae\x05\x5d\x62\xd2\xca\x93\x16\x62\x9b\x5c\xbf\x84\x4e\x7a\x7d\x16\x93\xb4\xb6\x15\xd7\x25\xcd\x91\x05\xd2\xc4\xbd\x5d\xb5\x25\xee\xd9\x79\x4c\xe9\x0e\x39\x5b\xc0\xa7\x0b\xb0\x26\x1f\x60\x8a\xf0\xd1\x1a\x35\x3f\xe9\x20\x4d\xe0\x41\x06\x7a\x2e\x49\x89\x28\x4a\xe4\xec\xd3\xc9\xa2\xcf\xb0\x9f\x0d\x1b\xbc\x16\x5e\x22\xeb\x6f\xac\x89\x5e\x0c\xd8\x91\xd0\x87\xe7\xd4\x48\xe4\x1a\x4b\x61\xa6\x8f\xad\xcf\x3f\x4f\x77\x28\x25\x7e\xdf\xc0\x05\x3c\x6c\x46\x49\x02\x91\x9d\xe2\x78\xec\x29\xc2\xea\xb4\x6f\xec\xb1\x38\x0e\xa6\x24\x73\x1f\xe6\x5d\x49\x00\x1a\x1b\xe6\x6d\x92\xc5\x41\x80\x7c\xc4\xc7\xd8\x8a\x46\x86\xfd\xe8\x34\xe8\x7a\x0d\x1f\xec\x19\x2e\x3a\x0d\x18\xbb\x75\xcf\xab\x78\x1b\xde\x8d\x98\x1f\x41\x9b\x76\x8e\xf9\x6e\x1a\x38\x2d\x92\x5b\x2c\xe8\xce\x53\x62\x9e\xa5\x65\x85\xdc\xea\x7c\xd5\xf6\xbd\x62\xd7\xdc\x89\xf9\x62\xb1\x3c\x2a\x53\x7a\xb7\x33\x5a\x6e\x45\xeb\x3e\xf2\x58\xc0\xe5\x65\xa7\xbf\x5b\x77\xa0\x99\x1a\x12\xb9\xc3\x42\xce\x57\x81\x15\x19\x6b\x6a\x8b\x22\xb1\xbb\x9a\x27\x1d\xae\x09\x40\x8b\x51\xb9\x4e\x5d\x2b\x2c\x65\xff\xcf\xdb\xf3\xd8\x69\xcc\x72\xeb\xd9\x71\x3c\x3b\x26\x51\x54\xef\x6c\x60\x5f\x29\x1e\xbe\x79\x3a\xb9\x27\x26\x1d\xa9\xf3\xd5\x45\xb4\xf9\x30\xcd\xc3\xf8\xbc\x11\xe9\x4e\x3b\xa6\xc4\x7f\xf5\x09\xff\xf6\xae\x68\x96\xd7\xfc\x70\x9b\x2d\x66\xd3\x80\x65\xb5\x36\x6f\x4d\xbf\x84\x20\xfb\x57\x76\x7c\x6e\xec\x63\xb3\x83\xd5\x80\x8f\x51\x1b\x6a\x04\xc4\xaf\xe1\x8f\x77\xd7\x10\x9c\x9f\xbe\xd1\x81\xf2\x84\x4c\xb7\xf4\xd4\x7a\x1e\x4b\x35\x6e\xf5\xc6\xfa\xba\xd5\x27\x56\xbd\x88\x69\xba\xc6\x44\x86\x63\xa9\x8a\x1a\xc2\xba\x17\xc9\xb1\xc3\x88\xb9\xc1\x61\x2c\xe9\xfe\xd4\x5e\x13\x19\xea\xb8\xa7\xf3\xd3\x83\xe1\x8d\x4b\xb1\xfb\xf8\x4a\x9f\xbd\x59\xb6\xb2\x42\xe2\xfc\xdd\x44\x77\x91\xe1\xf8\x6a\x38\x0c\x97\xe0\xf3\xcf\x2f\x1f\x08\x5f\xc2\xe8\xff\xe4\xea\x1b\x05\xf9\xc7\xe5\xf7\x07\x4b\xe7\x83\x48\x0e\x66\x81\x3e\xa5\x9f\x78\xc5\x1d\xcc\x63\x3f\xdb\xcf\xfe\x0f\x00\x00\xff\xff\x5a\xae\xd8\xad\xf6\x0a\x00\x00" +var _transactionsUpdaterSetup_updater_multi_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x56\x41\x6f\xe3\x46\x0f\xbd\xeb\x57\x70\x7d\xc8\x67\x01\x8a\x72\xf9\xd0\x83\x91\x34\xcd\xa6\x5b\x24\x97\x34\xd8\xec\xee\x25\xf0\x81\x1e\x51\xd6\x20\xd2\x8c\x30\x33\x72\x22\x04\xfe\xef\x05\x47\x23\x59\xb2\x95\x6d\x8b\xe6\x12\x49\xc3\x21\x1f\x1f\x1f\x49\xcb\xaa\xd6\xc6\xc1\xe2\x87\xa4\xd7\xaf\x64\x75\xb9\x23\xb3\x88\xa2\xfe\xf3\x93\xc3\x2d\x65\xb7\x5a\x39\x83\xc2\x7d\xaf\x33\x74\x64\x17\x51\x74\x71\x71\x01\x5f\xc9\x19\x49\x3b\xb2\x70\xa7\xad\x83\x5b\xac\x71\x23\x4b\xe9\x24\x59\xc8\x8d\xae\xc0\x15\x04\x22\x5c\x3d\x2f\xb4\x75\x52\x6d\x01\x85\xd0\x8d\x72\x16\x50\x65\x80\xd6\xca\xad\xe2\x67\x68\xbc\x6f\xc8\xa8\x2e\x75\x5b\x91\x72\x20\x15\x7f\x27\x25\xb0\xb6\x4d\x89\x7c\xdb\xc7\xed\x50\x98\x14\xbe\x15\xd2\x42\x46\x95\xf6\x0e\x30\xdb\xa1\x12\x94\x81\x40\x4b\xf0\x5a\x90\xa1\x8f\xfc\xee\x38\x4d\x0b\x08\x8a\xdc\xab\x36\x2f\xa0\x73\x36\x20\x95\xf1\x79\x0f\xd9\x02\x0a\xa3\xad\xf5\x41\xab\xa6\x74\xb2\x2e\x09\x8e\xf3\x48\xf9\xd8\x9b\x3c\xfc\xf9\xed\xcb\xd3\x6a\x14\xe9\x56\xab\x5c\x6e\x41\x5a\xd0\x26\x23\x43\x59\xe2\x93\x66\x5a\xfc\x07\x3e\x69\x2c\x65\xe0\x34\x64\xe4\xc8\x54\x52\xd1\xe8\x58\xe7\x13\x0a\x2d\x33\xc2\x1f\x0e\x11\x7c\x70\xf8\x82\xa2\x00\x52\xce\xb4\xbd\x05\x1a\x83\x2d\x54\x8d\x75\xb0\x21\xa0\x37\x14\xae\x6c\x41\x2b\x82\x17\x6a\xcf\x77\x58\x36\x04\x35\x4a\x93\x04\x9e\xf8\xce\x0b\xb5\x0c\xc8\x5f\xcf\x32\x43\xd6\xf6\x00\xd0\x5a\x2d\x24\x3a\xe6\x36\x60\xf1\x71\x15\x56\xe4\x33\x12\x3a\xa3\x0e\x8a\x2f\x89\x33\xa8\x2c\x0a\x27\xb5\x02\x2c\xad\x66\x07\x4d\x45\xec\x1b\x1d\x60\x59\x0e\x6e\x06\x36\x6f\x3a\x36\xa7\x22\x2a\x70\x47\xb0\x21\x52\x50\x37\x9b\x52\xda\x82\x32\xc8\xb5\xf1\x98\x58\x37\x64\xc0\x69\x1f\x56\x94\x28\xab\xae\x12\xa3\xe0\xcb\x4d\xa9\xc5\xcb\x1d\xc9\x6d\xe1\x3e\xeb\x46\x65\x68\xda\x15\x7c\xbf\x57\xee\x97\xff\x5f\x27\x03\x88\x9b\x2e\x5b\xb2\x2b\x78\x0e\xcf\xeb\xe4\xa4\x8c\x2b\x78\x7e\x7e\x0f\xc7\x2b\x78\x7f\x72\x46\xaa\xed\x0a\xba\xff\xfb\xfd\x7a\x1d\xc3\x7b\x14\x01\x00\xd4\x86\x6a\x34\xb4\xec\x20\xae\x00\x1b\x57\x2c\x3f\x6b\x63\xf4\xeb\x0f\x66\x3e\x81\x27\xdc\x51\x78\xbc\xb7\xb6\xa1\x27\xa7\x0d\x6e\x69\x48\xbe\xf5\x0d\xa7\xcb\x92\x4c\x02\xb7\x9c\xdb\xbd\xda\xe8\xb7\xc3\x79\x02\x8f\x1d\x23\x87\x4f\x31\x9c\x05\x12\x19\x08\x84\xbf\x8b\x0b\xb8\xd9\x70\x27\xcb\xbc\xef\x1b\x2e\x32\x96\x86\x30\x6b\x99\x82\x5c\x6e\x1b\x43\x19\x2b\xa7\x03\xfc\x3f\xdb\x6b\x7b\xf0\x22\xf3\x70\x96\xda\x0e\x69\xea\xda\x9a\x96\xe8\x38\xff\x99\x01\x91\x86\x50\x21\xaf\x47\x74\x45\x0c\x9f\xae\x40\xc9\x72\x84\xcd\x73\x85\x4a\x8a\xe5\xa2\x87\x36\x83\x0b\x1d\xd0\x5b\x4d\x82\xd5\x57\xa3\x2b\x3e\x2d\xe2\xc1\xc3\x3e\x1a\x27\xea\x89\xf2\xf2\xfa\x60\x1e\x0d\xaa\xc3\xbe\xe2\xc3\xf5\x92\x3a\x2d\xde\x62\xcd\x32\x38\xd0\x7a\xe9\xab\xd7\xe1\xeb\xb3\x8c\xe1\x6c\x3e\x6d\x8e\xfb\xeb\x1a\xae\xe0\x79\x3d\xf1\x6c\x89\xd4\x9c\xca\xa6\x96\x2c\xed\xbe\xf3\xa4\x3a\x95\xe7\x11\x75\x5c\x94\xb1\xdf\x94\x2f\xa0\x54\x76\x19\x9c\xc4\x47\x17\xf8\x8f\x6d\xa4\x6a\x68\x72\xb0\x9f\xbc\x8d\xa8\x80\xab\xbe\xee\x92\xf5\x97\xfa\x36\xfb\xf7\x8c\x2c\x4f\x60\xcc\x1b\xfb\x20\x77\x5d\xe8\x40\xff\x03\x56\xf4\x68\x28\x97\x6f\x9c\x9e\x40\x17\xba\x2a\x0d\x39\xa6\x4e\x77\x1d\xb8\x8c\xe3\xe4\x24\x4c\x6d\xf4\x4e\x66\xbe\x07\x3b\xf3\x89\x45\x0c\xd7\xd7\xbd\x00\x1f\xf4\x91\x68\x5a\xc8\x79\x62\x70\x21\x7c\xef\xf9\xea\x84\xa1\x83\x83\x82\x56\xb0\xe8\x71\xcd\x00\x8a\x27\xe1\x7a\x79\xa5\x58\xf3\xa6\x59\x86\xf7\xa9\xd1\xb4\xa2\xc1\xb2\xaf\x67\x74\x5a\x30\x96\xbd\x56\xd6\x99\x46\xb8\xf1\x8e\xeb\xf5\x9e\xcb\xed\x44\x89\x07\x13\xd6\xe1\xf3\x7c\x1d\xa6\xef\x6b\x96\xe9\xbc\xe1\x96\xdc\xef\x83\xc3\x3f\x8c\xae\xba\x51\xb9\x3c\x9e\x9d\x71\x34\x0f\x98\x07\x79\xb7\x9f\x4d\x02\x96\xa7\x3d\x6f\x93\x52\xaa\x97\x6e\xe2\x8b\x51\x3d\x26\x69\x88\x09\x10\xb3\x82\xdf\x7e\x3a\x87\xe0\xf2\xfc\x83\x0c\x84\x21\x74\xf4\x40\xaf\xc1\xf2\x54\xaa\x7e\x87\x74\xa7\x87\x1d\x32\xb3\x58\x58\x4c\xf3\x31\x66\x3c\x9c\x4a\x95\xd5\x60\x57\x83\x48\x4e\x0d\x26\x95\x1b\xbd\x4c\x25\x3d\xbc\x1d\xcd\x6b\x26\x77\x9a\xdb\xe5\xf9\x11\x89\xd3\x90\x4e\xff\xf3\xd9\x1e\x9d\x86\xe7\x22\x85\xca\x4e\xe6\x88\x18\x0d\xe5\x01\x9c\xe4\x1d\x78\x79\xf6\xfe\xd3\x78\x7e\xe1\x89\x04\xc6\x3f\x54\xd3\xfe\x61\x7f\x34\x63\xfe\x03\xf2\x39\xa0\xe1\xe7\xc7\xf2\x90\x51\x02\x7f\xbb\xfc\x3a\xc0\x7e\xf7\x45\x5d\xd3\xee\xa3\xbf\x02\x00\x00\xff\xff\x5b\x5d\xc1\x61\x6e\x0b\x00\x00" func transactionsUpdaterSetup_updater_multi_accountCdcBytes() ([]byte, error) { return bindataRead( @@ -844,11 +907,11 @@ func transactionsUpdaterSetup_updater_multi_accountCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/updater/setup_updater_multi_account.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe7, 0x29, 0xa8, 0x79, 0xe2, 0x6a, 0x1f, 0xd2, 0x42, 0x9e, 0x70, 0x4a, 0x1a, 0x6b, 0x65, 0x83, 0x8, 0xf1, 0xb0, 0xd6, 0xc, 0xc0, 0x3f, 0x6a, 0x88, 0xbd, 0xcc, 0x60, 0xd5, 0xe5, 0xe, 0x66}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1e, 0xca, 0xb4, 0x98, 0x92, 0x1e, 0x8a, 0x3a, 0xc, 0x48, 0xab, 0x5, 0xca, 0x7d, 0x81, 0x6e, 0xd3, 0x9f, 0x35, 0xd4, 0x41, 0x1f, 0xaa, 0x82, 0xf6, 0x58, 0x37, 0x9d, 0x5d, 0x8, 0xf9, 0x7a}} return a, nil } -var _transactionsUpdaterSetup_updater_single_account_and_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x56\xc1\x6e\xe3\x36\x10\xbd\xfb\x2b\x26\x29\xb0\xb5\x01\x57\xbe\x14\x3d\x08\x9b\x04\xa9\x51\x60\x17\x68\x83\xa0\xe9\xf6\xb2\xc8\x61\x4c\x4e\x24\xc2\x34\x29\x90\xc3\xa8\x42\xe0\x7f\x2f\x28\xcb\xb2\x14\x49\x89\xb3\x3c\xd8\x20\x35\xf3\xde\xf0\xcd\x0c\xc9\x9f\x50\x6b\x5b\xde\x0a\x61\x83\xe1\x3f\x95\xd9\x2a\x93\xcd\x66\x6a\x57\x58\xc7\x70\xf9\x17\x31\x4a\x64\xfc\x57\x51\xe9\x2f\x4f\xeb\x0f\x8c\x19\xc9\xb5\x35\xec\x50\xf0\xb7\x42\x22\x53\xfc\xbe\x5a\xad\x60\x6d\xcd\x93\xca\x82\x23\x0f\x68\xe0\xf0\xcd\x81\x23\x6f\x83\x13\xb4\x04\xf4\x3e\xec\x94\xc9\xc0\xab\xcc\xc4\x7f\x3c\x90\x83\xf2\xc0\x39\xb5\xd3\x52\x71\x5e\x2f\x88\x86\x06\xd8\x42\xa8\xe1\x12\xf8\x27\x57\x1e\x24\xed\xac\x07\xac\x59\xbd\xda\x15\x9a\x40\xa0\x27\x28\x73\x72\x54\xbb\x46\x0a\x72\x47\x64\x49\x85\xb6\xd5\x8e\x0c\xb7\x24\x68\x64\x77\xd9\x1a\x5d\x81\x32\x42\x07\x19\xc3\x07\xaf\x4c\xa6\x4f\x11\x24\x91\x6a\xc6\x0e\x8d\x47\xc1\xca\x9a\xf9\x46\x5b\xb1\xfd\x42\x2a\xcb\xf9\x77\x1b\x8c\x44\x57\xa5\xf0\xed\xab\xe1\xdf\x7e\xbd\x59\xb6\x7e\x77\xb8\xa3\x14\x1e\xd8\x29\x93\xc5\x55\xd9\xce\x16\xf0\x32\x9b\x01\x00\x14\x8e\x0a\x74\x34\x3f\x44\x9c\xc2\x6d\xe0\xbc\xc9\x4a\x6b\x13\xc7\x6a\x05\x7f\x18\x1f\x1c\xb5\xca\xe6\xe8\xc1\x58\x06\xd4\x8e\x50\x56\xb0\x21\x32\x91\xf9\x90\x04\x09\xc8\x40\xff\x15\x24\x98\x24\x14\xc8\x79\x17\xea\xce\x32\xa5\xf0\xf5\x09\xac\x21\x28\xd1\xb7\x20\x27\xff\x25\x94\xf4\xb3\x84\x12\x4d\x9d\x00\x6d\x51\xc2\x27\x90\xe4\xd9\xd9\x6a\x09\x9b\xc0\xe0\x83\xc8\xe1\x20\x08\xf8\xdc\x06\x2d\x61\x43\xc0\xb8\x25\x13\xa9\xb5\x12\x8a\x75\xd5\xf2\xaa\xa7\x26\x2f\x09\x57\x05\xcd\x91\xa3\x18\x23\xf5\x94\x34\x3b\x7c\x60\xeb\x30\xa3\x7b\xe4\x7c\x01\x17\x57\x60\x94\x86\x97\x16\xad\x16\x0f\x8d\x12\xf3\xcb\xa3\x22\xc3\x4d\x0c\x44\xb8\xb8\x5c\xb4\x08\xfb\xae\x22\x31\x06\x65\x02\xb5\xce\x18\xb7\x95\x24\xc9\x29\x05\x9a\xda\xfa\x59\x63\x71\xef\xd4\x33\x72\x1d\x5d\x0a\x9d\x09\x5c\xc1\xaa\x38\x4c\x57\xa3\xdb\xbb\x6d\x21\x7a\xc8\xb9\xf5\xfc\xc3\x98\x5f\xac\xe7\x5e\xad\x3c\x10\x87\x02\xd6\x58\xe0\x46\x69\xc5\x15\x58\x03\xc1\x48\x72\xba\xea\xb6\x60\x24\x3d\xee\xa9\x9b\xa7\x8b\x26\x51\x19\xf1\x09\xe3\xf3\xa7\x4e\x71\x5e\xcf\x47\xa5\x58\x24\x22\x27\xb1\x9d\x2f\x5e\x65\xaa\xc1\x0b\x46\x2b\xb3\x9d\x70\x1d\x73\x88\xe6\x0d\xe3\x7b\x5e\xfb\x89\x44\xc1\x15\xfc\xf0\x6e\x46\x34\x8d\x52\x77\x4e\xb5\xd2\x61\x51\x44\x29\xe3\x41\x53\x38\x7a\x56\x36\x78\xdd\xaf\xc1\xe6\xcc\x11\x91\x1b\x6b\xf2\x8f\xf7\x44\xa4\xed\x35\xc4\xd5\x58\x43\x34\x58\x1e\x9f\x69\xde\xfb\x10\xc7\xe7\x5f\x26\xb0\x85\x23\x64\xba\xa3\x32\x92\x74\x94\x48\x3b\x2a\x2e\x96\x03\x3c\xb6\x67\x06\xdb\xf3\x1c\x4b\xd8\x74\xc5\x4d\xe3\x5f\xcf\x5f\x75\xcc\x79\xa5\xf7\xda\x69\xaa\xe8\x3e\x44\xbd\x04\x46\x97\xd1\xd9\xc9\x9b\xa8\xd9\x88\xfa\x56\xc1\x7e\x44\x8c\x5e\xe5\xae\xeb\x04\x8f\xdf\xc9\xcd\x49\xd0\xbb\x70\x93\xfa\x7a\x3b\x98\x1f\xaf\xb7\x78\x09\x44\x23\x43\xe5\x11\x68\xf6\x6e\xd9\xbd\x5f\x72\x0d\xd4\xb0\x5a\x47\x42\x48\x61\xe4\xda\x85\x9b\x9b\x09\x8e\x11\x84\x61\x11\x47\xdd\x7c\x0a\xdf\x1b\xed\x1f\x87\x16\xa7\x67\x42\xb4\xfb\x3e\xf8\x1e\xc7\x78\x00\xfd\xf9\x70\x8b\xc7\x81\x52\x3a\xf2\x3e\x3d\xea\xd8\xcc\x87\xa1\x1c\x87\xa9\xdf\x15\xdd\x57\xc6\xb4\xed\xe1\xd5\x11\x7f\x47\x4d\x16\x83\xd5\xc7\xc7\x7e\xbf\xf6\xa1\xa7\x9b\x7e\x78\x6b\xcf\x86\x24\xfd\x66\x7c\x13\xe8\x3e\x6c\xb4\x12\xfd\x7e\xe9\x35\xe8\xcb\x19\xee\x4b\xe8\x3d\x65\x93\xbf\xc9\x5b\xfd\x4c\x6e\x7f\xdd\x4f\xc7\x99\x91\xbc\xd2\xe2\xcd\xa6\x7f\x57\x8f\xfd\x6c\x3f\xfb\x3f\x00\x00\xff\xff\x64\x5d\x0d\xf2\x87\x0b\x00\x00" +var _transactionsUpdaterSetup_updater_single_account_and_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x57\xcb\x6f\xe3\xb6\x13\xbe\xeb\xaf\x98\xf8\xe0\x9f\x04\xe8\xa7\x5c\x8a\x1e\x8c\x3c\xd0\x75\x0b\x24\x97\x60\xd1\x74\xf7\xb2\x08\x8a\x31\x39\xb6\xd8\xd0\xa4\x40\x52\xd6\x0a\x41\xfe\xf7\x82\x7a\xab\x92\x1f\xcd\x56\x87\x44\x92\xc9\xf9\xbe\x79\x7c\xa3\xa1\xd8\x67\xda\x38\x58\x7c\x15\x54\xfc\x4e\x56\xcb\x03\x99\x45\x10\xb4\xaf\x9f\x1d\xee\x88\xaf\xb5\x72\x06\x99\xfb\x92\x71\x74\x64\x17\x41\x70\x7d\x7d\x0d\x6b\xad\xb6\x62\x97\x1b\xb2\x80\x0a\xea\xdf\x0c\x18\xb2\x3a\x37\x8c\x62\x40\x6b\xf3\xbd\x50\x3b\xb0\x62\xa7\xfc\x7f\x64\x4c\xe7\xca\x81\xb0\xe0\x52\xea\x1e\x0b\xe1\xd2\xea\x05\x6b\x60\xc0\x69\xc8\x2b\x73\x09\xfc\x91\x0a\x0b\x9c\xf6\xda\x02\x56\xa8\x56\xec\x33\x49\xc0\xd0\x12\x14\x29\x19\xaa\xb6\x7a\x08\x32\xad\x65\x4e\x99\xd4\xe5\x9e\x94\xeb\x40\x50\xf1\xe1\x6b\xad\x64\x09\x42\x31\x99\x73\x4f\x1f\xac\x50\x3b\xd9\x33\x48\x3c\x54\xe0\x0c\x2a\x8b\xcc\x09\xad\xc2\x8d\xd4\xec\xf5\x81\xc4\x2e\x75\x9f\x74\xae\x38\x9a\x72\x05\x5f\x1e\x95\xfb\xf9\xa7\xfb\xb8\xdb\xf7\x84\x7b\x5a\xc1\xb3\x33\x42\xed\xfc\x5b\xde\x3d\x45\xf0\x16\x04\x00\x00\x99\xa1\x0c\x0d\x85\x35\xe3\x15\x60\xee\xd2\xf0\x93\x36\x46\x17\x5f\x51\xe6\x14\xc3\x5a\x67\x65\x73\xfb\x8c\x07\x6a\x6e\x1f\xad\xcd\xe9\x97\xda\x9b\x35\x66\xb8\x11\x52\xb8\xb2\xca\x8c\x96\x92\x4c\xb3\xe2\xd9\x69\x83\x3b\x9a\x5f\xb1\x96\x28\xf6\x8f\x6a\xa3\xbf\xf7\xbf\xc7\xf0\x39\xdf\x48\x61\xd3\xfe\x55\x04\xcb\x06\xa8\x63\xed\xaf\xeb\x6b\xf8\x4d\xd9\xdc\x50\x97\xeb\x14\x2d\x28\xed\x00\xa5\x21\xe4\x25\x6c\x88\x94\x8f\x45\x5d\x16\x1c\xd0\x01\x7d\xcf\x88\x39\xe2\x90\xa1\x4b\x87\xa6\x9e\xb4\xa3\x15\x3c\x6e\x41\x2b\x82\x02\x6d\x67\xa4\xdf\x1f\x43\x41\xff\xe3\x50\xa0\xaa\x4a\x42\x6a\xe4\xb0\x04\x4e\xd6\x19\x5d\xc6\xb0\xc9\x1d\xd8\x9c\xa5\x50\xa7\x08\x6c\xaa\x73\xc9\x61\x43\xe0\xf0\x95\x94\x87\x96\x82\x09\x27\xcb\x0e\x57\x6c\x9b\x4a\x49\x6c\x1d\xa7\xc4\x95\x19\x85\xe8\x7c\x9a\x66\x2a\x3d\x69\x3c\x6d\xa2\xfa\x19\x5d\x1a\xc1\xd5\x2d\x28\x21\xe1\xad\xb3\x5a\xa5\x15\x95\x60\xe1\xa2\x8d\xcc\xd4\x99\x49\x30\xae\x16\x51\x67\xe1\x7d\x18\x19\xcf\x41\xa8\x9c\xba\xcd\xe8\xdd\x4b\x92\x64\x94\x8a\x5f\xc9\x88\x03\x55\x96\x2c\x6c\xb5\x81\x26\x65\xb0\x84\x07\x6d\x1d\x74\xe9\x14\x64\x63\x10\x9c\x94\x13\xdb\xd2\xcb\xd0\x2b\xc4\x10\x13\x99\xa8\x95\x00\x59\x5d\x00\x42\xed\x3a\x00\x49\x9d\x74\xd6\x98\x0d\xdc\x87\x5b\x18\x3c\x85\xa3\x18\x54\x11\xae\x81\x84\x2f\xed\xf9\xee\xd1\xd7\xf0\x9f\x8b\x84\x69\xc5\xd0\x35\x62\x48\x90\x73\x43\xd6\x26\x4e\xd7\xa2\x09\xa3\x68\x04\x10\x5d\x8d\x08\xa6\xda\xfe\xe7\xec\x1e\x6a\x9b\x1f\xa1\xd6\x3d\x1f\xd0\x0c\x82\xb7\xea\x53\x51\xde\x54\x6a\xaf\xa1\x5a\xe0\x5e\x6d\x77\xf7\x50\x95\xd6\x30\xcd\xcf\xe4\xf2\x6c\x60\xc1\xe7\x2b\x57\x9c\x8c\x2c\x87\xad\xd5\x87\xa2\xc5\xbc\xa4\xda\x67\x73\x1b\xc1\xed\x5c\x69\xf7\x6b\xe1\xb6\x35\xc8\x06\xd5\x95\x34\x0b\x12\xe1\x1b\xd0\x19\x17\xc3\x71\xd8\xfe\xc1\xcf\xe2\x81\xc2\x1e\x2f\x06\xa7\x8f\x71\xed\xb5\x03\x24\x2d\x5d\xc0\xb9\x05\x61\x3a\x2b\x6f\x2e\xce\xc9\x5d\xb8\x35\x7a\x7f\x96\x45\x7b\xdd\xdf\xb7\xad\xe0\x51\x1d\x50\x0a\x0e\x7a\xf3\x17\x31\x07\x86\x9c\x11\x74\x20\x0e\xb5\xbd\xae\xc0\x66\x0d\x0f\xeb\x6c\xd8\x26\xa6\xa5\x51\x89\xbd\xff\xe8\x16\x06\xb3\xac\x55\x79\x66\xe8\x20\x74\x6e\xe5\xb8\x11\x35\x8d\xa2\xca\x21\x56\x31\xf8\x78\x83\xf4\xf0\xe7\x4b\x68\x2e\xcd\x93\xd0\xdd\xfc\xff\x08\x06\x33\x84\x8e\x9e\xa8\xf0\x60\xe1\x50\x59\xfd\xfd\x55\x14\x4f\x0c\xfa\xe2\xb9\x88\xf5\x58\xc9\x33\x5d\xd9\x2b\xba\xe9\x36\x17\xc8\xf9\x38\xe6\x44\xe1\x27\xe2\x3d\xed\x6e\x3f\x12\xdc\x39\xdd\xb6\x3b\x4e\xe9\xf6\x84\x2f\xe1\x65\x15\x31\x9f\x97\xa9\x77\x67\x93\xd0\x6c\xf9\xa8\xa0\x4f\x78\xd2\x6a\x7c\x26\xe4\x23\x56\xff\x5e\xdc\x53\x8b\x63\x65\x77\xe6\xd1\x5a\x32\xdd\xfa\x76\xc6\x58\x2e\x5b\x4e\x57\x09\x4b\x89\xbd\x86\x51\x0c\x7b\xb2\x16\x77\xb4\x82\x8e\xc5\xf8\x83\x5f\xf6\x74\x16\xd1\xa8\x63\xac\x2b\x21\xcd\x8f\xea\xcd\x87\x64\x34\x87\x27\xd5\xd4\x5b\x2f\x6f\xa7\x5e\x3f\x89\xf9\x45\x8a\x8a\xd6\x50\x70\x71\x25\x9e\x97\x78\x63\x72\x5a\xc0\x33\x54\x56\x30\x33\x95\xfb\x24\xcd\x63\xcc\x58\x98\xd6\xa6\x0f\xb7\x5d\xc1\xb7\x36\xec\x2f\xd3\x25\xfd\x31\xc2\x2f\xfc\x36\xf9\xdd\x5f\xf3\x0c\xc6\xcf\x53\x1f\xbb\x62\xa8\x87\x8d\x15\x8c\x87\x8f\x29\x95\xf6\x52\xd5\xb9\x63\x78\x0a\x39\xbe\xb6\x3e\x95\xf8\xbf\xb3\x4b\xa6\x9f\xb4\x97\x97\xb1\x34\xc7\xa6\x8f\x37\xd9\xe9\xec\x1c\x4c\x41\xfc\x1c\x57\x9f\xf5\xcc\xf1\x01\x63\xdc\xa8\x96\x6f\x27\xf1\xaa\xe3\x0c\x8b\x61\x78\xa2\x4d\xda\x9b\xf7\xbb\x71\xd4\x7f\x80\xf9\x1c\xd1\x66\x92\x0e\x7b\x8f\x62\x38\x7b\xb8\xa8\x09\xf7\xdd\xe6\x3d\x78\x0f\xfe\x0e\x00\x00\xff\xff\x8d\x85\x3a\x46\x97\x0f\x00\x00" func transactionsUpdaterSetup_updater_single_account_and_contractCdcBytes() ([]byte, error) { return bindataRead( @@ -864,11 +927,11 @@ func transactionsUpdaterSetup_updater_single_account_and_contractCdc() (*asset, } info := bindataFileInfo{name: "transactions/updater/setup_updater_single_account_and_contract.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc4, 0x2f, 0x9a, 0xed, 0x20, 0x10, 0xd4, 0x1, 0xa2, 0x43, 0x8e, 0x13, 0xc3, 0x5f, 0x2, 0x20, 0x6c, 0x9d, 0xb6, 0xaa, 0xd1, 0x68, 0x83, 0x99, 0x11, 0xab, 0x5b, 0x2e, 0xd, 0x52, 0x6b, 0xc9}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe8, 0xdb, 0x1c, 0xe2, 0xb8, 0x29, 0x47, 0x30, 0xda, 0x1b, 0x6f, 0xf3, 0xdd, 0x8, 0xa5, 0x53, 0x2e, 0x16, 0xd7, 0x2d, 0x52, 0x56, 0x4e, 0xfa, 0xe7, 0x7b, 0x87, 0xb2, 0x4a, 0x17, 0x11, 0x9}} return a, nil } -var _transactionsUpdaterUpdateCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x8f\x41\x4b\xc4\x40\x0c\x85\xef\xf3\x2b\x62\x05\xed\x5e\xda\xfb\x22\x2e\xcb\xe2\xcd\x83\xb0\xf8\x03\xe2\x34\xb6\x83\xdd\x64\xc8\x64\x58\x45\xf6\xbf\x4b\x3b\xa5\x82\xc8\xe6\x98\xbc\xbc\xef\xbd\x5b\x1c\x47\x39\xef\xbd\x97\xcc\xf6\x1c\xf8\x23\x70\xef\xc2\x29\x8a\x1a\x54\x47\xc3\x9e\xba\x83\xb0\x29\x7a\x7b\x8d\x1d\x1a\xa5\xca\xb9\xb6\x6d\xe1\xe9\x93\x7c\x36\x4a\x60\x03\x81\xcf\xaa\xc4\x36\x7e\x41\x9a\x5f\x20\xcf\x5a\x08\x3c\x9f\x53\xe8\x99\xf4\x3e\x41\xb1\x50\x50\x4a\x92\xd5\xd3\xe4\xe4\x4c\x91\x13\x7a\x0b\xc2\xf0\xed\x00\x00\xa2\x52\x44\xa5\xba\xfc\x6d\x61\x9f\x6d\x58\x22\x6e\x16\xc9\x34\xe5\xdc\xbc\x89\xaa\x9c\x1f\xee\xfe\x4d\xdb\x2c\xc8\xc7\xfa\x5d\xe5\xb4\x85\xab\xa2\xa3\x89\x62\x4f\x2f\x68\xc3\x66\xa5\x4c\xb3\x6b\x4a\xa1\xfa\xcf\x7a\x07\x11\x39\xf8\xba\x3a\x48\x1e\x3b\x60\x31\x28\x69\xd6\xa6\x13\xf5\xb7\x7f\x2a\x80\x9b\xaa\xf8\x5c\xdc\xc5\xfd\x04\x00\x00\xff\xff\x3f\xff\x16\x10\x81\x01\x00\x00" +var _transactionsUpdaterUpdateCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x50\xcd\x4a\xc3\x40\x10\xbe\xef\x53\x8c\x11\x6a\x72\x49\xef\x45\x2c\x5a\xbc\x79\x10\x8a\xde\xc7\xcd\x98\x2c\xa6\x33\x61\x76\x96\x2a\xd2\x77\x97\xec\xc6\x0a\x22\xce\x71\xf7\xfb\xbf\xc4\x71\x94\xe3\xad\xf7\x92\xd8\x1e\x02\xbf\x05\xee\x5d\x38\x4c\xa2\x06\xd5\xde\xb0\xa7\x6e\x27\x6c\x8a\xde\x9e\xa6\x0e\x8d\x62\xe5\xdc\x7a\xbd\x86\xfb\x77\xf2\xc9\x28\x82\x0d\x04\x3e\xa9\x12\xdb\xf8\x01\x31\x53\x20\x65\x2c\x04\xce\xdf\x31\xf4\x4c\x7a\x15\xa1\x48\x28\x28\x45\x49\xea\x69\x56\x72\xa6\xc8\x11\xbd\x05\x61\xf8\x74\x00\x00\x93\xd2\x84\x4a\x75\xe1\x6d\x00\x93\x0d\xf5\x9d\xa8\xca\xf1\x19\xc7\x44\x0d\xac\x96\xc4\xcd\xc2\x98\xaf\xa0\xdb\x68\xa2\xd8\x53\xfb\x92\xf1\xd7\x99\x5b\x7c\xbf\x8b\x34\xb0\xfa\xb3\x59\xbb\xc4\xbb\xa9\x5f\x55\x0e\x1b\xf8\x17\xb4\x2f\x36\x8f\x68\x43\x73\x8e\x30\xdf\xb6\x2d\xe5\xeb\x5f\xcf\x5b\x98\x90\x83\xaf\xab\x9d\xa4\xb1\x03\x16\x83\x12\xf1\xbc\xca\xec\xfa\xb3\xd5\xd2\xe3\xa2\x2a\x3a\x27\x77\x72\x5f\x01\x00\x00\xff\xff\x93\x74\x52\x08\xad\x01\x00\x00" func transactionsUpdaterUpdateCdcBytes() ([]byte, error) { return bindataRead( @@ -884,7 +947,7 @@ func transactionsUpdaterUpdateCdc() (*asset, error) { } info := bindataFileInfo{name: "transactions/updater/update.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x81, 0x9c, 0xd1, 0x15, 0x2d, 0xd1, 0x5a, 0xf, 0x7d, 0xfd, 0xfa, 0x5f, 0x2a, 0x94, 0x62, 0xe8, 0xaa, 0x35, 0x8, 0x78, 0x57, 0x4b, 0x99, 0xf7, 0xfe, 0x19, 0x47, 0xf8, 0xde, 0xa4, 0x2, 0xe9}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xef, 0xaa, 0x85, 0xd9, 0xe3, 0xc5, 0x8b, 0x3f, 0x9a, 0x0, 0xd7, 0x1f, 0x85, 0x2b, 0x8b, 0xe6, 0xb5, 0xc5, 0xfe, 0x1f, 0x67, 0x34, 0x49, 0x83, 0x32, 0x4b, 0xc2, 0x5a, 0xce, 0x71, 0xfa, 0xfa}} return a, nil } @@ -1003,6 +1066,9 @@ var _bindata = map[string]func() (*asset, error){ "transactions/coordinator/set_block_update_boundary.cdc": transactionsCoordinatorSet_block_update_boundaryCdc, "transactions/delegatee/execute_all_delegated_updates.cdc": transactionsDelegateeExecute_all_delegated_updatesCdc, "transactions/delegatee/remove_delegated_updaters.cdc": transactionsDelegateeRemove_delegated_updatersCdc, + "transactions/dependency-audit/admin/add_excluded_addresses.cdc": transactionsDependencyAuditAdminAdd_excluded_addressesCdc, + "transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc": transactionsDependencyAuditAdminSet_unstaged_cause_panicCdc, + "transactions/dependency-audit/admin/test_check_dependencies.cdc": transactionsDependencyAuditAdminTest_check_dependenciesCdc, "transactions/host/publish_host_capability.cdc": transactionsHostPublish_host_capabilityCdc, "transactions/migration-contract-staging/admin/commit_migration_results.cdc": transactionsMigrationContractStagingAdminCommit_migration_resultsCdc, "transactions/migration-contract-staging/admin/set_staging_cutoff.cdc": transactionsMigrationContractStagingAdminSet_staging_cutoffCdc, @@ -1105,6 +1171,13 @@ var _bintree = &bintree{nil, map[string]*bintree{ "execute_all_delegated_updates.cdc": {transactionsDelegateeExecute_all_delegated_updatesCdc, map[string]*bintree{}}, "remove_delegated_updaters.cdc": {transactionsDelegateeRemove_delegated_updatersCdc, map[string]*bintree{}}, }}, + "dependency-audit": {nil, map[string]*bintree{ + "admin": {nil, map[string]*bintree{ + "add_excluded_addresses.cdc": {transactionsDependencyAuditAdminAdd_excluded_addressesCdc, map[string]*bintree{}}, + "set_unstaged_cause_panic.cdc": {transactionsDependencyAuditAdminSet_unstaged_cause_panicCdc, map[string]*bintree{}}, + "test_check_dependencies.cdc": {transactionsDependencyAuditAdminTest_check_dependenciesCdc, map[string]*bintree{}}, + }}, + }}, "host": {nil, map[string]*bintree{ "publish_host_capability.cdc": {transactionsHostPublish_host_capabilityCdc, map[string]*bintree{}}, }}, diff --git a/local/normalize_coverage_report.sh b/local/normalize_coverage_report.sh deleted file mode 100755 index 3dde94d..0000000 --- a/local/normalize_coverage_report.sh +++ /dev/null @@ -1,6 +0,0 @@ -sed -i 's/A.0000000000000007.StagedContractUpdates/contracts\/staged-contract-updates\/StagedContractUpdates.cdc/' coverage.lcov -sed -i 's/A.0000000000000007.MigrationContractStaging/contracts\/MigrationContractStaging.cdc/' coverage.lcov -sed -i 's/A.0000000000000008.Foo/contracts\/example\/Foo.cdc/' coverage.lcov -sed -i 's/A.0000000000000009.A/contracts\/example\/A.cdc/' coverage.lcov -sed -i 's/A.0000000000000010.B/contracts\/example\/B.cdc/' coverage.lcov -sed -i 's/A.0000000000000010.C/contracts\/example\/C.cdc/' coverage.lcov \ No newline at end of file diff --git a/scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc b/scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc index 3dd7eaf..089c45c 100644 --- a/scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc +++ b/scripts/delegatee/check_delegatee_has_valid_updater_cap.cdc @@ -1,12 +1,12 @@ import "StagedContractUpdates" -pub fun main(updaterAddress: Address, delegateeAddress: Address): Bool? { - let updater = getAuthAccount(updaterAddress).borrow<&StagedContractUpdates.Updater>( +access(all) fun main(updaterAddress: Address, delegateeAddress: Address): Bool? { + let updater = getAuthAccount(updaterAddress).storage.borrow<&StagedContractUpdates.Updater>( from: StagedContractUpdates.UpdaterStoragePath ) ?? panic("Could not borrow contract updater reference") let id = updater.getID() - let delegatee = getAuthAccount(delegateeAddress).borrow<&StagedContractUpdates.Delegatee>( + let delegatee = getAuthAccount(delegateeAddress).storage.borrow<&StagedContractUpdates.Delegatee>( from: StagedContractUpdates.DelegateeStoragePath ) ?? panic("Could not borrow contract delegatee reference") return delegatee.check(id: id) diff --git a/scripts/test/foo.cdc b/scripts/test/foo.cdc index 59d7b51..ed1ca26 100644 --- a/scripts/test/foo.cdc +++ b/scripts/test/foo.cdc @@ -1,5 +1,5 @@ import "Foo" -pub fun main(): String { +access(all) fun main(): String { return Foo.foo() } \ No newline at end of file diff --git a/scripts/updater/get_block_update_boundary_from_updater.cdc b/scripts/updater/get_block_update_boundary_from_updater.cdc index 07d86b5..b2d7c7a 100644 --- a/scripts/updater/get_block_update_boundary_from_updater.cdc +++ b/scripts/updater/get_block_update_boundary_from_updater.cdc @@ -3,8 +3,7 @@ import "StagedContractUpdates" /// Retrieves the block height update boundary from the Updater at the given Address or nil if an Updater is not found /// access(all) fun main(updaterAddress: Address): UInt64? { - return getAccount(updaterAddress).getCapability<&{StagedContractUpdates.UpdaterPublic}>( + return getAccount(updaterAddress).capabilities.borrow<&{StagedContractUpdates.UpdaterPublic}>( StagedContractUpdates.UpdaterPublicPath - ).borrow() - ?.getBlockUpdateBoundary() + )?.getBlockUpdateBoundary() } diff --git a/scripts/updater/get_current_deployment_stage.cdc b/scripts/updater/get_current_deployment_stage.cdc index 7603dd5..6a8472e 100644 --- a/scripts/updater/get_current_deployment_stage.cdc +++ b/scripts/updater/get_current_deployment_stage.cdc @@ -3,8 +3,7 @@ import "StagedContractUpdates" /// Retrieves the current deployment stage of the Updater at the given Address or nil if an Updater is not found /// access(all) fun main(updaterAddress: Address): Int? { - return getAccount(updaterAddress).getCapability<&{StagedContractUpdates.UpdaterPublic}>( + return getAccount(updaterAddress).capabilities.borrow<&{StagedContractUpdates.UpdaterPublic}>( StagedContractUpdates.UpdaterPublicPath - ).borrow() - ?.getCurrentDeploymentStage() + )?.getCurrentDeploymentStage() } diff --git a/scripts/updater/get_invalid_hosts.cdc b/scripts/updater/get_invalid_hosts.cdc index 50ec3a1..fdeab45 100644 --- a/scripts/updater/get_invalid_hosts.cdc +++ b/scripts/updater/get_invalid_hosts.cdc @@ -2,12 +2,11 @@ import "MetadataViews" import "StagedContractUpdates" -/// Returns addresses of Hosts with either invalid Host or encapsulate AuthAccount Capabilities from the Updater at the +/// Returns addresses of Hosts with either invalid Host or encapsulate Account Capabilities from the Updater at the /// given address or nil if none is found /// -pub fun main(updaterAddress: Address): [Address]? { - return getAccount(updaterAddress).getCapability<&{StagedContractUpdates.UpdaterPublic}>( +access(all) fun main(updaterAddress: Address): [Address]? { + return getAccount(updaterAddress).capabilities.borrow<&{StagedContractUpdates.UpdaterPublic}>( StagedContractUpdates.UpdaterPublicPath - ).borrow() - ?.getInvalidHosts() + )?.getInvalidHosts() } diff --git a/scripts/updater/get_updater_deployment_order.cdc b/scripts/updater/get_updater_deployment_order.cdc index 280203a..92d432a 100644 --- a/scripts/updater/get_updater_deployment_order.cdc +++ b/scripts/updater/get_updater_deployment_order.cdc @@ -2,8 +2,8 @@ import "StagedContractUpdates" /// Returns values of the Updater at the given Address /// -pub fun main(address: Address): [[{Address: String}]]? { - let account = getAuthAccount(address) +access(all) fun main(address: Address): [[{Address: String}]]? { + let account = getAuthAccount(address) if let updater = account.borrow<&StagedContractUpdates.Updater>(from: StagedContractUpdates.UpdaterStoragePath) { let result: [[{Address: String}]] = [] diff --git a/scripts/updater/get_updater_deployment_readable.cdc b/scripts/updater/get_updater_deployment_readable.cdc index f0ef9f1..0682d97 100644 --- a/scripts/updater/get_updater_deployment_readable.cdc +++ b/scripts/updater/get_updater_deployment_readable.cdc @@ -1,9 +1,9 @@ import "StagedContractUpdates" -pub struct ContractUpdateReadable { - pub let address: Address - pub let name: String - pub let code: String +access(all) struct ContractUpdateReadable { + access(all) let address: Address + access(all) let name: String + access(all) let code: String init( address: Address, @@ -18,9 +18,9 @@ pub struct ContractUpdateReadable { /// Returns values of the Updater at the given Address /// -pub fun main(address: Address): [[ContractUpdateReadable]]? { +access(all) fun main(address: Address): [[ContractUpdateReadable]]? { - let account = getAuthAccount(address) + let account = getAuthAccount(address) if let updater = account.borrow<&StagedContractUpdates.Updater>(from: StagedContractUpdates.UpdaterStoragePath) { diff --git a/scripts/updater/get_updater_info.cdc b/scripts/updater/get_updater_info.cdc index f2e04e5..2780167 100644 --- a/scripts/updater/get_updater_info.cdc +++ b/scripts/updater/get_updater_info.cdc @@ -1,12 +1,11 @@ -import "MetadataViews" +import "ViewResolver" import "StagedContractUpdates" /// Returns UpdaterInfo view from the Updater at the given address or nil if none is found /// -pub fun main(address: Address): StagedContractUpdates.UpdaterInfo? { - return getAccount(address).getCapability<&{StagedContractUpdates.UpdaterPublic, MetadataViews.Resolver}>( +access(all) fun main(address: Address): StagedContractUpdates.UpdaterInfo? { + return getAccount(address).capabilities.borrow<&{StagedContractUpdates.UpdaterPublic, ViewResolver.Resolver}>( StagedContractUpdates.UpdaterPublicPath - ).borrow() - ?.resolveView(Type()) as! StagedContractUpdates.UpdaterInfo? + )?.resolveView(Type()) as! StagedContractUpdates.UpdaterInfo? } diff --git a/scripts/updater/has_been_updated.cdc b/scripts/updater/has_been_updated.cdc index 68e6958..496e3ba 100644 --- a/scripts/updater/has_been_updated.cdc +++ b/scripts/updater/has_been_updated.cdc @@ -3,8 +3,7 @@ import "StagedContractUpdates" /// Retrieves the update completion status of the Updater at the given Address or nil if an Updater is not found /// access(all) fun main(updaterAddress: Address): Bool? { - return getAccount(updaterAddress).getCapability<&{StagedContractUpdates.UpdaterPublic}>( + return getAccount(updaterAddress).capabilities.borrow<&{StagedContractUpdates.UpdaterPublic}>( StagedContractUpdates.UpdaterPublicPath - ).borrow() - ?.hasBeenUpdated() + )?.hasBeenUpdated() } diff --git a/scripts/util/get_deployment_from_config.cdc b/scripts/util/get_deployment_from_config.cdc index fb2eaf4..dc19725 100644 --- a/scripts/util/get_deployment_from_config.cdc +++ b/scripts/util/get_deployment_from_config.cdc @@ -1,5 +1,5 @@ import "StagedContractUpdates" -pub fun main(config: [[{Address: {String: String}}]]): [[StagedContractUpdates.ContractUpdate]] { +access(all) fun main(config: [[{Address: {String: String}}]]): [[StagedContractUpdates.ContractUpdate]] { return StagedContractUpdates.getDeploymentFromConfig(config) } \ No newline at end of file diff --git a/tests/dependency_audit_tests.cdc b/tests/dependency_audit_tests.cdc new file mode 100644 index 0000000..43c3555 --- /dev/null +++ b/tests/dependency_audit_tests.cdc @@ -0,0 +1,248 @@ +import Test +import BlockchainHelpers +import "DependencyAudit" + +// NOTE: This is an artifact of the implicit Test API - it's not clear how block height transitions between test cases +access(all) let blockHeightBoundaryDelay: UInt64 = 15 + +// Contract hosts as defined in flow.json +access(all) let adminAccount = Test.getAccount(0x0000000000000007) +access(all) let fooAccount = Test.getAccount(0x0000000000000008) +access(all) let aAccount = Test.getAccount(0x0000000000000009) +access(all) let bcAccount = Test.getAccount(0x0000000000000010) + +// Content of update contracts as hex strings +access(all) let aUpdateCode = "61636365737328616c6c2920636f6e747261637420696e746572666163652041207b0a202020200a2020202061636365737328616c6c29207265736f7572636520696e746572666163652049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e670a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e670a202020207d0a0a2020202061636365737328616c6c29207265736f757263652052203a2049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a7d" +access(all) let aUpdateCadence = String.fromUTF8(aUpdateCode.decodeHex()) ?? panic("Problem decoding aUpdateCode") + +access(all) fun setup() { + var err = Test.deployContract( + name: "MigrationContractStaging", + path: "../contracts/MigrationContractStaging.cdc", + arguments: [] + ) + Test.expect(err, Test.beNil()) + + err = Test.deployContract( + name: "Foo", + path: "../contracts/test/Foo.cdc", + arguments: [] + ) + Test.expect(err, Test.beNil()) + + err = Test.deployContract( + name: "A", + path: "../contracts/test/A.cdc", + arguments: [] + ) + Test.expect(err, Test.beNil()) + + err = Test.deployContract( + name: "B", + path: "../contracts/test/B.cdc", + arguments: [] + ) + Test.expect(err, Test.beNil()) + + err = Test.deployContract( + name: "C", + path: "../contracts/test/C.cdc", + arguments: [] + ) + Test.expect(err, Test.beNil()) + + let excludedAddresses: [Address] = [ + // exclude the admin account + 0x0000000000000007 + ] + err = Test.deployContract( + name: "DependencyAudit", + path: "../contracts/DependencyAudit.cdc", + arguments: [excludedAddresses] + ) + Test.expect(err, Test.beNil()) + + +} + + +access(all) fun testChekDependenciesWithEmptyList() { + let addresses: [Address] = [] + let names: [String] = [] + let authorizers: [Address] = [] + let commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + let events = Test.eventsOfType(Type()) + Test.assertEqual(0, events.length) +} + +access(all) fun testChekDependenciesWithExcludedEntries() { + let addresses: [Address] = [adminAccount.address] + let names: [String] = ["DependencyAudit"] + let authorizers: [Address] = [] + let commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + let events = Test.eventsOfType(Type()) + Test.assertEqual(0, events.length) +} + +access(all) fun testChekDependenciesWithUnstagedEntries() { + let addresses: [Address] = [fooAccount.address] + let names: [String] = ["Foo"] + let authorizers: [Address] = [] + let commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + let events = Test.eventsOfType(Type()) + Test.assertEqual(1, events.length) + + let evt = events[0] as! DependencyAudit.UnstagedDependencies + Test.assertEqual(1, evt.dependencies.length) + Test.assertEqual(fooAccount.address, evt.dependencies[0].address) + Test.assertEqual("Foo", evt.dependencies[0].name) +} + + +access(all) fun testChekDependenciesWithStagedEntries() { + var events = Test.eventsOfType(Type()) + Test.assertEqual(1, events.length) + + let addresses: [Address] = [aAccount.address] + let names: [String] = ["A"] + let authorizers: [Address] = [] + var commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + events = Test.eventsOfType(Type()) + Test.assertEqual(2, events.length) + let evt = events[1] as! DependencyAudit.UnstagedDependencies + Test.assertEqual(1, evt.dependencies.length) + Test.assertEqual(aAccount.address, evt.dependencies[0].address) + Test.assertEqual("A", evt.dependencies[0].name) + + let aStagingTxResult = executeTransaction( + "../transactions/migration-contract-staging/stage_contract.cdc", + ["A", aUpdateCadence], + aAccount + ) + Test.expect(aStagingTxResult, Test.beSucceeded()) + + events = Test.eventsOfType(Type()) + Test.assertEqual(2, events.length) + + commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + events = Test.eventsOfType(Type()) + Test.assertEqual(2, events.length) +} + + +access(all) fun testChekDependenciesWithMixedEntries() { + var events = Test.eventsOfType(Type()) + Test.assertEqual(2, events.length) + + let addresses: [Address] = [adminAccount.address, fooAccount.address, aAccount.address, bcAccount.address] + let names: [String] = ["DependencyAudit", "Foo", "A", "B"] + let authorizers: [Address] = [] + var commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + events = Test.eventsOfType(Type()) + Test.assertEqual(3, events.length) + + let evt = events[2] as! DependencyAudit.UnstagedDependencies + Test.assertEqual(2, evt.dependencies.length) + Test.assertEqual(fooAccount.address, evt.dependencies[0].address) + Test.assertEqual("Foo", evt.dependencies[0].name) + Test.assertEqual(bcAccount.address, evt.dependencies[1].address) + Test.assertEqual("B", evt.dependencies[1].name) +} + +access(all) fun testSetExcludedAddresses() { + var addresses: [Address] = [bcAccount.address] + var commitResult = executeTransaction( + "../transactions/dependency-audit/admin/add_excluded_addresses.cdc", + [addresses], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + var events = Test.eventsOfType(Type()) + Test.assertEqual(3, events.length) + + addresses = [adminAccount.address, fooAccount.address, aAccount.address, bcAccount.address] + let names: [String] = ["DependencyAudit", "Foo", "A", "B"] + let authorizers: [Address] = [] + commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + events = Test.eventsOfType(Type()) + Test.assertEqual(4, events.length) + + let evt = events[3] as! DependencyAudit.UnstagedDependencies + Test.assertEqual(1, evt.dependencies.length) + Test.assertEqual(fooAccount.address, evt.dependencies[0].address) + Test.assertEqual("Foo", evt.dependencies[0].name) +} + +access(all) fun testSetPanic() { + let shouldPanic: Bool = true + var commitResult = executeTransaction( + "../transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc", + [shouldPanic], + adminAccount + ) + Test.expect(commitResult, Test.beSucceeded()) + + var events = Test.eventsOfType(Type()) + Test.assertEqual(1, events.length) + + let evt = events[0] as! DependencyAudit.PanicOnUnstagedDependenciesChanged + Test.assertEqual(true, evt.shouldPanic) +} + + +access(all) fun testChekDependenciesWithUnstagedEntriesPanics() { + let addresses: [Address] = [fooAccount.address] + let names: [String] = ["Foo"] + let authorizers: [Address] = [] + let commitResult = executeTransaction( + "../transactions/dependency-audit/admin/test_check_dependencies.cdc", + [addresses, names, authorizers], + adminAccount + ) + Test.expect(commitResult, Test.beFailed()) + // not sure how to test this: + // Test.expect(commitResult.error!.message, Test.contain("panic: This transaction is using dependencies not staged for Crescendo upgrade coming soon! Learn more: https://bit.ly/FLOWCRESCENDO. Dependencies not staged: A.0000000000000008.Foo") ) +} diff --git a/tests/migration_contract_staging_tests.cdc b/tests/migration_contract_staging_tests.cdc index 7ced197..4d4abd1 100644 --- a/tests/migration_contract_staging_tests.cdc +++ b/tests/migration_contract_staging_tests.cdc @@ -13,11 +13,11 @@ access(all) let bcAccount = Test.getAccount(0x0000000000000010) // Content of update contracts as hex strings access(all) let fooUpdateCode = "61636365737328616c6c2920636f6e747261637420466f6f207b0a2020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a202020202020202072657475726e2022626172220a202020207d0a7d0a" access(all) let fooUpdateCadence = String.fromUTF8(fooUpdateCode.decodeHex()) ?? panic("Problem decoding fooUpdateCode") -access(all) let aUpdateCode = "61636365737328616c6c2920636f6e747261637420696e746572666163652041207b0a202020200a2020202061636365737328616c6c29207265736f7572636520696e746572666163652049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e670a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e670a202020207d0a0a2020202061636365737328616c6c29207265736f757263652052203a2049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a7d" +access(all) let aUpdateCode = "61636365737328616c6c2920636f6e747261637420696e746572666163652041207b0a202020200a2020202061636365737328616c6c29207265736f7572636520696e746572666163652049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e670a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e670a202020207d0a0a2020202061636365737328616c6c29207265736f7572636520696e746572666163652052203a2049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a7d" access(all) let aUpdateCadence = String.fromUTF8(aUpdateCode.decodeHex()) ?? panic("Problem decoding aUpdateCode") -access(all) let bUpdateCode = "696d706f727420412066726f6d203078303030303030303030303030303030390a0a61636365737328616c6c2920636f6e74726163742042203a2041207b0a202020200a2020202061636365737328616c6c29207265736f757263652052203a20412e49207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a202020200a2020202061636365737328616c6c292066756e206372656174655228293a204052207b0a202020202020202072657475726e203c2d637265617465205228290a202020207d0a7d" +access(all) let bUpdateCode = "696d706f727420412066726f6d203078303030303030303030303030303030390a0a61636365737328616c6c2920636f6e74726163742042203a2041207b0a202020200a2020202061636365737328616c6c29207265736f757263652052203a20412e52207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a202020200a2020202061636365737328616c6c292066756e206372656174655228293a204052207b0a202020202020202072657475726e203c2d637265617465205228290a202020207d0a7d" access(all) let bUpdateCadence = String.fromUTF8(bUpdateCode.decodeHex()) ?? panic("Problem decoding bUpdateCode") -access(all) let cUpdateCode = "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" +access(all) let cUpdateCode = "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" access(all) let cUpdateCadence = String.fromUTF8(cUpdateCode.decodeHex()) ?? panic("Problem decoding cUpdateCode") // Block height different to add to the staging cutoff @@ -103,7 +103,7 @@ access(all) fun testStageContractSucceeds() { let evt = events[0] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(fooAccount.address, evt.address) Test.assertEqual(fooUpdateCadence, evt.code) - Test.assertEqual("Foo", evt.contract) + Test.assertEqual("Foo", evt.contractIdentifier) Test.assertEqual("stage", evt.action) } @@ -154,7 +154,7 @@ access(all) fun testStageContractViaHostCapabilitySucceeds() { let evt = events[0] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(fooAccount.address, evt.address) Test.assertEqual(fooUpdateCadence, evt.code) - Test.assertEqual("Foo", evt.contract) + Test.assertEqual("Foo", evt.contractIdentifier) Test.assertEqual("stage", evt.action) } @@ -189,17 +189,17 @@ access(all) fun testStageMultipleContractsSucceeds() { let cEvt = events[1] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(bcAccount.address, cEvt.address) Test.assertEqual(cUpdateCadence, cEvt.code) - Test.assertEqual("C", cEvt.contract) + Test.assertEqual("C", cEvt.contractIdentifier) Test.assertEqual("stage", cEvt.action) let bEvt = events[2] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(bcAccount.address, bEvt.address) Test.assertEqual(bUpdateCadence, bEvt.code) - Test.assertEqual("B", bEvt.contract) + Test.assertEqual("B", bEvt.contractIdentifier) Test.assertEqual("stage", bEvt.action) let aEvt = events[3] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(aAccount.address, aEvt.address) Test.assertEqual(aUpdateCadence, aEvt.code) - Test.assertEqual("A", aEvt.contract) + Test.assertEqual("A", aEvt.contractIdentifier) Test.assertEqual("stage", aEvt.action) let aAccountStagedContractNames = getStagedContractNamesForAddress(aAccount.address) @@ -239,7 +239,7 @@ access(all) fun testReplaceStagedCodeSucceeds() { let evt = events[4] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(fooAccount.address, evt.address) Test.assertEqual(fooUpdateCadence, evt.code) - Test.assertEqual("Foo", evt.contract) + Test.assertEqual("Foo", evt.contractIdentifier) Test.assertEqual("replace", evt.action) } @@ -270,7 +270,7 @@ access(all) fun testUnstageContractSucceeds() { let evt = events[5] as! MigrationContractStaging.StagingStatusUpdated Test.assertEqual(fooAccount.address, evt.address) Test.assertEqual("", evt.code) - Test.assertEqual("Foo", evt.contract) + Test.assertEqual("Foo", evt.contractIdentifier) Test.assertEqual("unstage", evt.action) assertIsStaged(contractAddress: fooAccount.address, contractName: "Foo", invert: true) @@ -419,7 +419,7 @@ access(all) fun getAllStagedContractCodeForAddress(contractAddress: Address): {S ?? panic("Problem retrieving result of getAllStagedContractCodeForAddress()") } -access(all) fun tickTock(advanceBlocks: UInt64, _ signer: Test.Account) { +access(all) fun tickTock(advanceBlocks: UInt64, _ signer: Test.TestAccount) { var blocksAdvanced: UInt64 = 0 while blocksAdvanced < advanceBlocks { diff --git a/tests/staged_contract_updater_tests.cdc b/tests/staged_contract_updater_tests.cdc index 8dc2040..7b24572 100644 --- a/tests/staged_contract_updater_tests.cdc +++ b/tests/staged_contract_updater_tests.cdc @@ -11,13 +11,13 @@ access(all) let aAccount = Test.getAccount(0x0000000000000009) access(all) let bcAccount = Test.getAccount(0x0000000000000010) // Account that will host the Updater for contracts A, B, and C -access(all) let abcUpdater = Test.createAccount() +access(all) let abcUpdater = Test.getAccount(0x0000000000000010) // Content of update contracts as hex strings access(all) let fooUpdateCode = "61636365737328616c6c2920636f6e747261637420466f6f207b0a2020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a202020202020202072657475726e2022626172220a202020207d0a7d0a" -access(all) let aUpdateCode = "61636365737328616c6c2920636f6e747261637420696e746572666163652041207b0a202020200a2020202061636365737328616c6c29207265736f7572636520696e746572666163652049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e670a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e670a202020207d0a0a2020202061636365737328616c6c29207265736f757263652052203a2049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a7d" -access(all) let bUpdateCode = "696d706f727420412066726f6d203078303030303030303030303030303030390a0a61636365737328616c6c2920636f6e74726163742042203a2041207b0a202020200a2020202061636365737328616c6c29207265736f757263652052203a20412e49207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a202020200a2020202061636365737328616c6c292066756e206372656174655228293a204052207b0a202020202020202072657475726e203c2d637265617465205228290a202020207d0a7d" -access(all) let cUpdateCode = "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" +access(all) let aUpdateCode = "61636365737328616c6c2920636f6e747261637420696e746572666163652041207b0a202020200a2020202061636365737328616c6c29207265736f7572636520696e746572666163652049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e670a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e670a202020207d0a0a2020202061636365737328616c6c29207265736f7572636520696e746572666163652052203a2049207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a7d" +access(all) let bUpdateCode = "696d706f727420412066726f6d203078303030303030303030303030303030390a0a61636365737328616c6c2920636f6e74726163742042203a2041207b0a202020200a2020202061636365737328616c6c29207265736f757263652052203a20412e52207b0a202020202020202061636365737328616c6c292066756e20666f6f28293a20537472696e67207b0a20202020202020202020202072657475726e2022666f6f220a20202020202020207d0a202020202020202061636365737328616c6c292066756e2062617228293a20537472696e67207b0a20202020202020202020202072657475726e2022626172220a20202020202020207d0a202020207d0a202020200a2020202061636365737328616c6c292066756e206372656174655228293a204052207b0a202020202020202072657475726e203c2d637265617465205228290a202020207d0a7d" +access(all) let cUpdateCode = "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" access(all) fun setup() { var err = Test.deployContract( @@ -111,6 +111,7 @@ access(all) fun testSetupMultiContractMultiAccountUpdater() { [nil, contractAddresses, deploymentConfig], abcUpdater ) + Test.expect(setupUpdaterTxResult, Test.beSucceeded()) // Confirm UpdaterCreated event was properly emitted // TODO: Uncomment once bug is fixed allowing contract import @@ -363,7 +364,7 @@ access(all) fun jumpToUpdateBoundary(forUpdater: Address) { tickTock(advanceBlocks: updateBoundary - currentHeight, admin) } -access(all) fun tickTock(advanceBlocks: UInt64, _ signer: Test.Account) { +access(all) fun tickTock(advanceBlocks: UInt64, _ signer: Test.TestAccount) { var blocksAdvanced: UInt64 = 0 while blocksAdvanced < advanceBlocks { diff --git a/transactions/coordinator/set_block_update_boundary.cdc b/transactions/coordinator/set_block_update_boundary.cdc index a16d653..601158e 100644 --- a/transactions/coordinator/set_block_update_boundary.cdc +++ b/transactions/coordinator/set_block_update_boundary.cdc @@ -3,8 +3,8 @@ import "StagedContractUpdates" /// Allows the contract Coordinator to set a new blockUpdateBoundary /// transaction(newBoundary: UInt64) { - prepare(signer: AuthAccount) { - signer.borrow<&StagedContractUpdates.Coordinator>(from: StagedContractUpdates.CoordinatorStoragePath) + prepare(signer: auth(BorrowValue) &Account) { + signer.storage.borrow<&StagedContractUpdates.Coordinator>(from: StagedContractUpdates.CoordinatorStoragePath) ?.setBlockUpdateBoundary(new: newBoundary) ?? panic("Could not borrow reference to Coordinator!") } diff --git a/transactions/delegatee/execute_all_delegated_updates.cdc b/transactions/delegatee/execute_all_delegated_updates.cdc index 5c10cfc..b90d1ce 100644 --- a/transactions/delegatee/execute_all_delegated_updates.cdc +++ b/transactions/delegatee/execute_all_delegated_updates.cdc @@ -6,11 +6,12 @@ import "StagedContractUpdates" /// transaction { - let delegatee: &StagedContractUpdates.Delegatee + let delegatee: auth(UpdateContract) &StagedContractUpdates.Delegatee - prepare(signer: AuthAccount) { - self.delegatee = signer.borrow<&StagedContractUpdates.Delegatee>(from: StagedContractUpdates.DelegateeStoragePath) - ?? panic("Could not borrow Delegatee reference from signer") + prepare(signer: auth(BorrowValue) &Account) { + self.delegatee = signer.storage.borrow( + from: StagedContractUpdates.DelegateeStoragePath + ) ?? panic("Could not borrow Delegatee reference from signer") } execute { diff --git a/transactions/delegatee/remove_delegated_updaters.cdc b/transactions/delegatee/remove_delegated_updaters.cdc index 8b66336..0255f60 100644 --- a/transactions/delegatee/remove_delegated_updaters.cdc +++ b/transactions/delegatee/remove_delegated_updaters.cdc @@ -4,11 +4,12 @@ import "StagedContractUpdates" /// transaction(removeIDs: [UInt64]) { - let delegatee: &StagedContractUpdates.Delegatee + let delegatee: auth(Remove) &StagedContractUpdates.Delegatee - prepare(signer: AuthAccount) { - self.delegatee = signer.borrow<&StagedContractUpdates.Delegatee>(from: StagedContractUpdates.DelegateeStoragePath) - ?? panic("Could not borrow Delegatee reference from signer") + prepare(signer: auth(BorrowValue) &Account) { + self.delegatee = signer.storage.borrow( + from: StagedContractUpdates.DelegateeStoragePath + ) ?? panic("Could not borrow Delegatee reference from signer") } execute { diff --git a/transactions/dependency-audit/admin/add_excluded_addresses.cdc b/transactions/dependency-audit/admin/add_excluded_addresses.cdc new file mode 100644 index 0000000..b9089a7 --- /dev/null +++ b/transactions/dependency-audit/admin/add_excluded_addresses.cdc @@ -0,0 +1,8 @@ +import "DependencyAudit" + +transaction(addresses: [Address]) { + prepare(signer: auth(BorrowValue) &Account) { + signer.storage.borrow<&DependencyAudit.Administrator>(from: DependencyAudit.AdministratorStoragePath)?.addExcludedAddresses(addresses: addresses) + ?? panic("Could not borrow DependencyAudit.Administrator from signer's storage!") + } +} diff --git a/transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc b/transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc new file mode 100644 index 0000000..2680820 --- /dev/null +++ b/transactions/dependency-audit/admin/set_unstaged_cause_panic.cdc @@ -0,0 +1,8 @@ +import "DependencyAudit" + +transaction(shouldPanic: Bool) { + prepare(signer: auth(BorrowValue) &Account) { + signer.storage.borrow<&DependencyAudit.Administrator>(from: DependencyAudit.AdministratorStoragePath)?.setPanicOnUnstagedDependencies(shouldPanic: shouldPanic) + ?? panic("Could not borrow DependencyAudit.Administrator from signer's storage!") + } +} diff --git a/transactions/dependency-audit/admin/test_check_dependencies.cdc b/transactions/dependency-audit/admin/test_check_dependencies.cdc new file mode 100644 index 0000000..3a2ac88 --- /dev/null +++ b/transactions/dependency-audit/admin/test_check_dependencies.cdc @@ -0,0 +1,8 @@ +import "DependencyAudit" + +transaction(dependenciesAddresses: [Address], dependenciesNames: [String], authorizers: [Address]) { + prepare(signer: auth(BorrowValue) &Account) { + signer.storage.borrow<&DependencyAudit.Administrator>(from: DependencyAudit.AdministratorStoragePath)?.testCheckDependencies(dependenciesAddresses, dependenciesNames, authorizers) + ?? panic("Could not borrow DependencyAudit.Administrator from signer's storage!") + } +} diff --git a/transactions/host/publish_host_capability.cdc b/transactions/host/publish_host_capability.cdc index 33065c1..266e348 100644 --- a/transactions/host/publish_host_capability.cdc +++ b/transactions/host/publish_host_capability.cdc @@ -2,47 +2,53 @@ import "StagedContractUpdates" -/// Links the signer's AuthAccount and encapsulates in a Host resource, publishing a Host Capability for the specified +/// Links the signer's Account and encapsulates in a Host resource, publishing a Host Capability for the specified /// recipient. This would enable the recipient to execute arbitrary contract updates on the signer's behalf. /// transaction(publishFor: Address) { - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, CopyValue, IssueAccountCapabilityController, IssueStorageCapabilityController, PublishInboxCapability, SaveValue) &Account) { - // Derive paths for AuthAccount & Host Capabilities, identifying the recipient on publishing - let accountCapPrivatePath = PrivatePath( + // Derive paths for Account & Host Capabilities, identifying the recipient on publishing + let accountCapStoragePath = StoragePath( identifier: "StagedContractUpdatesAccountCap_".concat(signer.address.toString()) )! - let hostPrivatePath = PrivatePath(identifier: "StagedContractUpdatesHost_".concat(publishFor.toString()))! + let hostCapStoragePath = StoragePath(identifier: "StagedContractUpdatesHostCap_".concat(publishFor.toString()))! + var accountCap: Capability? = nil // Setup Capability on underlying signing host account - if !signer.getCapability<&AuthAccount>(accountCapPrivatePath).check() { - signer.unlink(accountCapPrivatePath) - signer.linkAccount(accountCapPrivatePath) - ?? panic("Problem linking AuthAccount Capability") + if signer.storage.type(at: accountCapStoragePath) == nil { + accountCap = signer.capabilities.account.issue() + signer.storage.save(accountCap, to: accountCapStoragePath) + } else { + accountCap = signer.storage.copy>(from: accountCapStoragePath) + ?? panic("Invalid object retrieved from: ".concat(accountCapStoragePath.toString())) } - let accountCap = signer.getCapability<&AuthAccount>(accountCapPrivatePath) - assert(accountCap.check(), message: "Invalid AuthAccount Capability retrieved") + assert(accountCap != nil && accountCap!.check(), message: "Invalid Account Capability retrieved") // Setup Host resource, wrapping the previously configured account capabaility - if signer.type(at: StagedContractUpdates.HostStoragePath) == nil { - signer.save( - <- StagedContractUpdates.createNewHost(accountCap: accountCap), + if signer.storage.type(at: StagedContractUpdates.HostStoragePath) == nil { + signer.storage.save( + <- StagedContractUpdates.createNewHost(accountCap: accountCap!), to: StagedContractUpdates.HostStoragePath ) } - if !signer.getCapability<&StagedContractUpdates.Host>(hostPrivatePath).check() { - signer.unlink(hostPrivatePath) - signer.link<&StagedContractUpdates.Host>(hostPrivatePath, target: StagedContractUpdates.HostStoragePath) + var hostCap: Capability? = nil + if signer.storage.type(at: hostCapStoragePath) == nil { + signer.storage.save( + signer.capabilities.storage.issue(StagedContractUpdates.HostStoragePath), + to: hostCapStoragePath + ) } - let hostCap = signer.getCapability<&StagedContractUpdates.Host>(hostPrivatePath) + hostCap = signer.storage.copy>(from: hostCapStoragePath) + ?? panic("Invalid object retrieved from: ".concat(hostCapStoragePath.toString())) - assert(hostCap.check(), message: "Invalid Host Capability retrieved") + assert(hostCap != nil && hostCap!.check(), message: "Invalid Host Capability retrieved") // Finally publish the Host Capability to the account that will store the Updater signer.inbox.publish( - hostCap, + hostCap!, name: StagedContractUpdates.inboxHostCapabilityNamePrefix.concat(publishFor.toString()), recipient: publishFor ) diff --git a/transactions/migration-contract-staging/admin/commit_migration_results.cdc b/transactions/migration-contract-staging/admin/commit_migration_results.cdc index 6fe9139..a3cac76 100644 --- a/transactions/migration-contract-staging/admin/commit_migration_results.cdc +++ b/transactions/migration-contract-staging/admin/commit_migration_results.cdc @@ -6,8 +6,8 @@ transaction(snapshotTimestamp: UFix64, failedContracts: [String]) { let admin: &MigrationContractStaging.Admin - prepare(signer: AuthAccount) { - self.admin = signer.borrow<&MigrationContractStaging.Admin>(from: MigrationContractStaging.AdminStoragePath) + prepare(signer: auth(BorrowValue) &Account) { + self.admin = signer.storage.borrow<&MigrationContractStaging.Admin>(from: MigrationContractStaging.AdminStoragePath) ?? panic("Could not borrow Admin reference") } diff --git a/transactions/migration-contract-staging/admin/set_staging_cutoff.cdc b/transactions/migration-contract-staging/admin/set_staging_cutoff.cdc index 6c67efb..328b44f 100644 --- a/transactions/migration-contract-staging/admin/set_staging_cutoff.cdc +++ b/transactions/migration-contract-staging/admin/set_staging_cutoff.cdc @@ -6,8 +6,8 @@ transaction(cutoff: UInt64) { let admin: &MigrationContractStaging.Admin - prepare(signer: AuthAccount) { - self.admin = signer.borrow<&MigrationContractStaging.Admin>(from: MigrationContractStaging.AdminStoragePath) + prepare(signer: auth(BorrowValue) &Account) { + self.admin = signer.storage.borrow<&MigrationContractStaging.Admin>(from: MigrationContractStaging.AdminStoragePath) ?? panic("Could not borrow Admin reference") } diff --git a/transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc b/transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc index 71fe2f8..835bb30 100644 --- a/transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc +++ b/transactions/migration-contract-staging/delegated-staging/claim_published_host_capability.cdc @@ -18,7 +18,7 @@ import "MigrationContractStaging" /// transaction(hostPublisher: Address, hostCapStoragePathIdentifier: String) { - prepare(signer: AuthAccount) { + prepare(signer: auth(ClaimInboxCapability, SaveValue) &Account) { // Claim the published Capability from the signer's inbox let inboxName = "MigrationContractStagingHost_".concat(signer.address.toString()) let hostCap = signer.inbox.claim<&MigrationContractStaging.Host>(inboxName, provider: hostPublisher) @@ -29,6 +29,6 @@ transaction(hostPublisher: Address, hostCapStoragePathIdentifier: String) { // Store the Host Capability in the signer's storage, deriving the storage path on the publisher's address let storagePath = StoragePath(identifier: hostCapStoragePathIdentifier) ?? panic("Failed to derive the storage path from the provided identifier") - signer.save(hostCap, to: storagePath) + signer.storage.save(hostCap, to: storagePath) } } diff --git a/transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc b/transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc index 39f2b29..b360428 100644 --- a/transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc +++ b/transactions/migration-contract-staging/delegated-staging/setup_host_optional_publish.cdc @@ -18,28 +18,25 @@ import "MigrationContractStaging" /// transaction(hostCapabilityRecipient: Address?) { - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, SaveValue, GetStorageCapabilityController, IssueStorageCapabilityController, PublishInboxCapability) &Account) { // Configure Host resource if needed - if signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { - signer.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) + if signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { + signer.storage.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) } // Ensure Host resource is setup assert( - signer.type(at: MigrationContractStaging.HostStoragePath) == Type<@MigrationContractStaging.Host>(), + signer.storage.type(at: MigrationContractStaging.HostStoragePath) == Type<@MigrationContractStaging.Host>(), message: "Failed to setup Host resource" ) // Configure a private Host Capability & publish if a recipient is defined if hostCapabilityRecipient != nil { let hostIdentifier = "MigrationContractStagingHost_".concat(hostCapabilityRecipient!.toString()) - let privatePath = PrivatePath(identifier: hostIdentifier)! - - signer.unlink(privatePath) - let hostCap = signer.link<&MigrationContractStaging.Host>( - privatePath, - target: MigrationContractStaging.HostStoragePath + let hostCap = signer.capabilities.storage.issue<&MigrationContractStaging.Host>( + MigrationContractStaging.HostStoragePath ) - assert(hostCap?.borrow() != nil, message: "Failed to link Host Capability") - signer.inbox.publish(hostCap!, name: hostIdentifier, recipient: hostCapabilityRecipient!) + assert(hostCap.check(), message: "Failed to issue Host Capability") + signer.storage.save(hostCap, to: StoragePath(identifier: hostIdentifier)!) + signer.inbox.publish(hostCap, name: hostIdentifier, recipient: hostCapabilityRecipient!) } } } diff --git a/transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc b/transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc index bffee0d..0993675 100644 --- a/transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc +++ b/transactions/migration-contract-staging/delegated-staging/stage_contract_from_stored_host_capability.cdc @@ -23,11 +23,11 @@ import "MigrationContractStaging" transaction(hostCapStoragePathIdentifier: String, contractName: String, contractCode: String) { let host: &MigrationContractStaging.Host - prepare(signer: AuthAccount) { + prepare(signer: auth(CopyValue) &Account) { // Copy the Capability from storage let storagePath = StoragePath(identifier: hostCapStoragePathIdentifier) ?? panic("Failed to derive the storage path from the provided identifier") - let hostCap = signer.copy>(from: storagePath) + let hostCap = signer.storage.copy>(from: storagePath) ?? panic("Missing Host capability in storage") self.host = hostCap.borrow() ?? panic("Host Cap in storage is invalid") } diff --git a/transactions/migration-contract-staging/stage_contract.cdc b/transactions/migration-contract-staging/stage_contract.cdc index de6a6ae..bd4342e 100644 --- a/transactions/migration-contract-staging/stage_contract.cdc +++ b/transactions/migration-contract-staging/stage_contract.cdc @@ -20,13 +20,13 @@ import "MigrationContractStaging" transaction(contractName: String, contractCode: String) { let host: &MigrationContractStaging.Host - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, SaveValue) &Account) { // Configure Host resource if needed - if signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { - signer.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) + if signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) == nil { + signer.storage.save(<-MigrationContractStaging.createHost(), to: MigrationContractStaging.HostStoragePath) } // Assign Host reference - self.host = signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath)! + self.host = signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath)! } execute { diff --git a/transactions/migration-contract-staging/unstage_contract.cdc b/transactions/migration-contract-staging/unstage_contract.cdc index 8ee36b0..faece60 100644 --- a/transactions/migration-contract-staging/unstage_contract.cdc +++ b/transactions/migration-contract-staging/unstage_contract.cdc @@ -15,9 +15,9 @@ import "MigrationContractStaging" transaction(contractName: String) { let host: &MigrationContractStaging.Host - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { // Assign Host reference - self.host = signer.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) + self.host = signer.storage.borrow<&MigrationContractStaging.Host>(from: MigrationContractStaging.HostStoragePath) ?? panic("Host was not found in storage") } diff --git a/transactions/test/setup_updater_with_empty_deployment.cdc b/transactions/test/setup_updater_with_empty_deployment.cdc index 8b03ff8..16f395f 100644 --- a/transactions/test/setup_updater_with_empty_deployment.cdc +++ b/transactions/test/setup_updater_with_empty_deployment.cdc @@ -4,12 +4,14 @@ import "StagedContractUpdates" /// Should fail on Updater.init() due to empty hosts and deployments arrays /// transaction { - prepare(signer: AuthAccount) { + prepare(signer: auth(SaveValue) &Account) { + let hosts: [Capability<&StagedContractUpdates.Host>] = [] + let deployments: [[StagedContractUpdates.ContractUpdate]] = [] let updater <- StagedContractUpdates.createNewUpdater( blockUpdateBoundary: StagedContractUpdates.blockUpdateBoundary, - hosts: [], - deployments: [] + hosts: hosts, + deployments: deployments ) - signer.save(<-updater, to: StagedContractUpdates.UpdaterStoragePath) + signer.storage.save(<-updater, to: StagedContractUpdates.UpdaterStoragePath) } } diff --git a/transactions/test/tick_tock.cdc b/transactions/test/tick_tock.cdc index 90961ef..932b78a 100644 --- a/transactions/test/tick_tock.cdc +++ b/transactions/test/tick_tock.cdc @@ -2,7 +2,7 @@ /// Used to mock block advancement in test suite /// transaction { - prepare(signer: AuthAccount) { + prepare(signer: &Account) { log("Block height incremented to: ".concat(getCurrentBlock().height.toString())) } } diff --git a/transactions/updater/delegate.cdc b/transactions/updater/delegate.cdc index 5a05659..26b6ea7 100644 --- a/transactions/updater/delegate.cdc +++ b/transactions/updater/delegate.cdc @@ -5,13 +5,13 @@ import "StagedContractUpdates" transaction { let delegatee: &{StagedContractUpdates.DelegateePublic} - let updaterCap: Capability<&StagedContractUpdates.Updater> + let updaterCap: Capability let updaterID: UInt64 - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, CopyValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) { // Revert if the signer doesn't already have an Updater configured - if signer.type(at: StagedContractUpdates.UpdaterStoragePath) == nil { + if signer.storage.type(at: StagedContractUpdates.UpdaterStoragePath) == nil { panic("Signer does not have an Updater configured") } // Continue... @@ -20,21 +20,22 @@ transaction { self.delegatee = StagedContractUpdates.getContractDelegateeCapability().borrow() ?? panic("Could not borrow Delegatee reference") - let updaterPrivatePath = PrivatePath( - identifier: "StagedContractUpdatesUpdater_".concat( + let updaterCapStoragePath = StoragePath( + identifier: "StagedContractUpdatesUpdaterCapability_".concat( self.delegatee.owner?.address?.toString() ?? panic("Problem referencing contract's DelegateePublic owner address") ) )! - // Link Updater Capability in private if needed & retrieve - if !signer.getCapability<&StagedContractUpdates.Updater>(updaterPrivatePath).check() { - signer.unlink(updaterPrivatePath) - signer.link<&StagedContractUpdates.Updater>( - updaterPrivatePath, - target: StagedContractUpdates.UpdaterStoragePath + // Issue Updater Capability if needed, store & retrieve + if signer.storage.type(at: updaterCapStoragePath) == nil { + signer.storage.save( + signer.capabilities.storage.issue(StagedContractUpdates.UpdaterStoragePath), + to: updaterCapStoragePath ) } - self.updaterCap = signer.getCapability<&StagedContractUpdates.Updater>(updaterPrivatePath) + self.updaterCap = signer.storage.copy>(from: updaterCapStoragePath) + ?? panic("Problem retrieving Updater Capability") + assert(self.updaterCap.check(), message: "Invalid Updater Capability retrieved") self.updaterID = self.updaterCap.borrow()?.getID() ?? panic("Invalid Updater Capability retrieved from signer!") } diff --git a/transactions/updater/remove_from_delegatee_as_updater.cdc b/transactions/updater/remove_from_delegatee_as_updater.cdc index 15ca38c..9ea06d0 100644 --- a/transactions/updater/remove_from_delegatee_as_updater.cdc +++ b/transactions/updater/remove_from_delegatee_as_updater.cdc @@ -6,10 +6,10 @@ import "StagedContractUpdates" transaction { let delegatee: &{StagedContractUpdates.DelegateePublic} - let updaterCap: Capability<&StagedContractUpdates.Updater> + let updaterCap: Capability let updaterID: UInt64 - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, CopyValue) &Account) { self.delegatee = StagedContractUpdates.getContractDelegateeCapability().borrow() ?? panic("Could not borrow Delegatee reference") @@ -18,8 +18,15 @@ transaction { self.delegatee.owner?.address?.toString() ?? panic("Problem referencing contract's DelegateePublic owner address") ) )! + let updaterCapStoragePath = StoragePath( + identifier: "StagedContractUpdatesUpdaterCapability_".concat( + self.delegatee.owner?.address?.toString() ?? panic("Problem referencing contract's DelegateePublic owner address") + ) + )! + + self.updaterCap = signer.storage.copy>(from: updaterCapStoragePath) + ?? panic("Problem retrieving Updater Capability") - self.updaterCap = signer.getCapability<&StagedContractUpdates.Updater>(updaterPrivatePath) self.updaterID = self.updaterCap.borrow()?.getID() ?? panic("Invalid Updater Capability retrieved from signer!") } diff --git a/transactions/updater/setup_updater_multi_account.cdc b/transactions/updater/setup_updater_multi_account.cdc index 2f6ed62..b7452c4 100644 --- a/transactions/updater/setup_updater_multi_account.cdc +++ b/transactions/updater/setup_updater_multi_account.cdc @@ -1,4 +1,4 @@ -import "MetadataViews" +import "ViewResolver" import "StagedContractUpdates" @@ -9,25 +9,25 @@ import "StagedContractUpdates" /// NOTES: deploymentConfig is ordered, and the order is used to determine the order of the contracts in the deployment. /// Each entry in the array must be exactly one key-value pair, where the key is the address of the associated contract /// name and code. -/// This transaction also assumes that all contract hosting AuthAccount Capabilities have been published for the signer -/// to claim. +/// This transaction also assumes that all contract hosting Account Capabilities have been published for the signer to +/// claim. /// transaction(blockHeightBoundary: UInt64?, contractAddresses: [Address], deploymentConfig: [[{Address: {String: String}}]]) { - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, ClaimInboxCapability, PublishCapability) &Account) { // Abort if Updater is already configured in signer's account - if signer.type(at: StagedContractUpdates.UpdaterStoragePath) != nil { + if signer.storage.type(at: StagedContractUpdates.UpdaterStoragePath) != nil { panic("Updater already configured at expected path!") } // Claim all Host Capabilities from contract addresses - let hostCaps: [Capability<&StagedContractUpdates.Host>] = [] + let hostCaps: [Capability] = [] let seenAddresses: [Address] = [] for address in contractAddresses { if seenAddresses.contains(address) { continue } - let hostCap: Capability<&StagedContractUpdates.Host> = signer.inbox.claim<&StagedContractUpdates.Host>( + let hostCap = signer.inbox.claim( StagedContractUpdates.inboxHostCapabilityNamePrefix.concat(signer.address.toString()), provider: address ) ?? panic("No Host Capability found in Inbox for signer at address: ".concat(address.toString())) @@ -43,14 +43,13 @@ transaction(blockHeightBoundary: UInt64?, contractAddresses: [Address], deployme hosts: hostCaps, deployments: deployments ) - signer.save( + signer.storage.save( <-contractUpdater, to: StagedContractUpdates.UpdaterStoragePath ) - signer.unlink(StagedContractUpdates.UpdaterPublicPath) - signer.link<&{StagedContractUpdates.UpdaterPublic, MetadataViews.Resolver}>( - StagedContractUpdates.UpdaterPublicPath, - target: StagedContractUpdates.UpdaterStoragePath + let updaterCap = signer.capabilities.storage.issue<&{StagedContractUpdates.UpdaterPublic, ViewResolver.Resolver}>( + StagedContractUpdates.UpdaterStoragePath ) + signer.capabilities.publish(updaterCap, at: StagedContractUpdates.UpdaterPublicPath) } } diff --git a/transactions/updater/setup_updater_single_account_and_contract.cdc b/transactions/updater/setup_updater_single_account_and_contract.cdc index eda6d07..aa62a23 100644 --- a/transactions/updater/setup_updater_single_account_and_contract.cdc +++ b/transactions/updater/setup_updater_single_account_and_contract.cdc @@ -1,6 +1,4 @@ -#allowAccountLinking - -import "MetadataViews" +import "ViewResolver" import "StagedContractUpdates" @@ -9,43 +7,57 @@ import "StagedContractUpdates" /// transaction(blockHeightBoundary: UInt64?, contractName: String, code: String) { - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, CopyValue, SaveValue, IssueAccountCapabilityController, IssueStorageCapabilityController, ClaimInboxCapability, PublishCapability) &Account) { // Ensure Updater has not already been configured at expected path // Note: If one was already configured, we'd want to load & destroy, but such action should be taken explicitly - if signer.type(at: StagedContractUpdates.UpdaterStoragePath) != nil { + if signer.storage.type(at: StagedContractUpdates.UpdaterStoragePath) != nil { panic("Updater already configured at expected path!") } // Continue configuration... - let accountCapPrivatePath: PrivatePath = /private/StagedContractUpdatesAccountCap - let hostPrivatePath: PrivatePath = /private/StagedContractUpdatesHost + // Derive paths for Account & Host Capabilities, identifying the recipient on publishing + let accountCapStoragePath = StoragePath( + identifier: "StagedContractUpdatesAccountCap_".concat(signer.address.toString()) + )! + let hostCapStoragePath = StoragePath( + identifier: "StagedContractUpdatesHostCap_".concat(signer.address.toString()) + )! + var accountCap: Capability? = nil // Setup Capability on underlying signing host account - if !signer.getCapability<&AuthAccount>(accountCapPrivatePath).check() { - signer.unlink(accountCapPrivatePath) - signer.linkAccount(accountCapPrivatePath) + if signer.storage.type(at: accountCapStoragePath) == nil { + accountCap = signer.capabilities.account.issue() + signer.storage.save(accountCap, to: accountCapStoragePath) + } else { + accountCap = signer.storage.copy>(from: accountCapStoragePath) + ?? panic("Invalid object retrieved from: ".concat(accountCapStoragePath.toString())) } - let accountCap = signer.getCapability<&AuthAccount>(accountCapPrivatePath) // Setup Host resource, wrapping the previously configured account capabaility - if signer.type(at: StagedContractUpdates.HostStoragePath) == nil { - signer.save( - <- StagedContractUpdates.createNewHost(accountCap: accountCap), + if signer.storage.type(at: StagedContractUpdates.HostStoragePath) == nil { + signer.storage.save( + <- StagedContractUpdates.createNewHost(accountCap: accountCap!), to: StagedContractUpdates.HostStoragePath ) } - if !signer.getCapability<&StagedContractUpdates.Host>(hostPrivatePath).check() { - signer.unlink(hostPrivatePath) - signer.link<&StagedContractUpdates.Host>(hostPrivatePath, target: StagedContractUpdates.HostStoragePath) + var hostCap: Capability? = nil + if signer.storage.type(at: hostCapStoragePath) == nil { + signer.storage.save( + signer.capabilities.storage.issue(StagedContractUpdates.HostStoragePath), + to: hostCapStoragePath + ) } - let hostCap = signer.getCapability<&StagedContractUpdates.Host>(hostPrivatePath) + hostCap = signer.storage.copy>(from: hostCapStoragePath) + ?? panic("Invalid object retrieved from: ".concat(hostCapStoragePath.toString())) + + assert(hostCap != nil && hostCap!.check(), message: "Invalid Host Capability retrieved") // Create Updater resource, assigning the contract .blockUpdateBoundary to the new Updater - signer.save( + signer.storage.save( <- StagedContractUpdates.createNewUpdater( blockUpdateBoundary: blockHeightBoundary ?? StagedContractUpdates.blockUpdateBoundary, - hosts: [hostCap], + hosts: [hostCap!], deployments: [[ StagedContractUpdates.ContractUpdate( address: signer.address, @@ -56,10 +68,9 @@ transaction(blockHeightBoundary: UInt64?, contractName: String, code: String) { ), to: StagedContractUpdates.UpdaterStoragePath ) - signer.unlink(StagedContractUpdates.UpdaterPublicPath) - signer.link<&{StagedContractUpdates.UpdaterPublic, MetadataViews.Resolver}>( - StagedContractUpdates.UpdaterPublicPath, - target: StagedContractUpdates.UpdaterStoragePath + let updaterCap = signer.capabilities.storage.issue<&{StagedContractUpdates.UpdaterPublic, ViewResolver.Resolver}>( + StagedContractUpdates.UpdaterStoragePath ) + signer.capabilities.publish(updaterCap, at: StagedContractUpdates.UpdaterPublicPath) } } diff --git a/transactions/updater/update.cdc b/transactions/updater/update.cdc index 57b0722..641a020 100644 --- a/transactions/updater/update.cdc +++ b/transactions/updater/update.cdc @@ -4,8 +4,8 @@ import "StagedContractUpdates" /// Executes the currently staged update in the signer's Updater resource /// transaction { - prepare(signer: AuthAccount) { - signer.borrow<&StagedContractUpdates.Updater>(from: StagedContractUpdates.UpdaterStoragePath) + prepare(signer: auth(BorrowValue) &Account) { + signer.storage.borrow(from: StagedContractUpdates.UpdaterStoragePath) ?.update() ?? panic("Could not borrow Updater from signer's storage!") }