From 03372f237db6273bc1f9e11a9cb41982d9fbb59b Mon Sep 17 00:00:00 2001 From: Joshua Hannan Date: Mon, 6 May 2024 14:54:33 -0500 Subject: [PATCH] FEATURE: V2 FungibleToken Standard (#131) * draft of v2 standard for working group * bring FT v2 up to latest design * adds total supply view and updates dependencies * update FungibleToken.cdc for Stable Cadence * integrate stable cadence changes * comment out events temp * add view to structs * use correct import placeholder * remove view modifier from resolveView * add default impl for getSupportedVaultTypes * remove default impl for getsupported * add Withdrawable to transfer * remove AnyResource * update dependencies for stable cadence * WIP updates to transactions for stable cadence * comment out default functions and remove Balance * remove restricted type from link * Update sdk * Update contracts * Update to Cadence v1.0.0-preview.1 * Revert changes to ExampleToken.cdc * add Cadence test cases for Metadata * add PrivateReceiverForwarder Cadence tests * consolidate Cadence test directories * bump flow CLI version for ci automation * update go assets * update utility contracts * update ExampleToken-v2 Vault to return TotalSupply view * update ExampleToken-v2 init to publish {FungibleToken.Vault} capability * update private forwarder transactions for Cadence 1.0 * update tests/scripts for Cadence 1.0 * update go assets * update go transaction templates * update transactions for Cadence 1.0 * update scripts for Cadence 1.0 * bump go version * add public burn method in ExampleToken-v2 * update create_forwarder & generic_transfer txns for Cadence 1.0 * update go assets * add ReceiverPublicPath to ExampleToken-v2 & update go tests + txns * update go assets * update go assets * rm ExampleToken-v2 dependency on MultipleVaults * update NonFungibleToken import syntax * update flow config with up to date dependencies * update MetadataViews Cadence tests, scripts & txns * update test_helpers.cdc to Cadence 1.0 syntax * update PrivateReceiverForwarder Cadence tests * enable FungibleToken.Receiver.getSupportedVaultTypes() in v2 standard impl * update switchboard Cadence tests & supporting scripts & txns * update ExampleToken-v2 Cadence tests * update go assets * bump flow cli version to v1.5.0-stable-cadence.3 * fix test script bugs & update go assets * update example_token_tests * remove ExampleToken.Minter.mintTokens() pre condition * add FT.Vault.getDefaultReceiverPath() method * update ExampleToken.Vault Capability setup & go assets * rm unused import from ExampleToken-v2 * update NonFungibleToken-v2 implementation from source repo * fix go GenerateTransferInvalidVaultScript() template txn generation * rm test bash script in favor of Makefile * fix example_token_tests burn event check * Apply suggestions from code review Co-authored-by: Joshua Hannan * update ExampleToken-v2.Vault receiverLinkedType + tests & go assets * update instances of ExampleToken to ExampleToken-v2 in flow.json & tests * remove transfer * remove default implementations and move destroy supply update * remove transfer event and remove event functions * remove custom destructor * add event args, global burn method, balance interface, and clean up tests * remove path functions and add view function * remove view modifier, add getIDs * remove view from data view function, updating forwarding events * add suport for multiple type definitions * remove get vault types function and add conformance * update dependencies and remove getVaultTypes line * remove burn method * add burner and add event emission functions * fix supply update and burner name * use conditional downcasting * fix access type * revert to event emission directly in the pre condition * update sdk and cadence deps * fix example token, remove getBalance, add isAvailableToWithdraw * generate assets * update transactions to get go tests passing * add post-condition for vault type * remove some go tests * add view functions to Balance and change transactions to use Balance instead of concrete type * use Balance and FungibleToken.Vault as public interfaces * use correct linked types * generate assets * update generic setup and transfer transactions * update generic transfer transactions * update contract borrows and ExampleToken import * update README for v2 standards * use correct import placeholder format * update previewnet address * update Burner for optional resources and add tests * revove coverage file * fix imports for standard transactions * add switchboard entitlements and tests * remove old code samples in the README and add links * add pre-condition to createEmptyVault * update dependencies * reorganize txs and scripts * add type to TokenForwarding * update comment and event test * move withdraw event and add balance after params * make event formatting prettier * add forwarding addresses * fix capabilities get in switchboard * use contract field and mint event * update CLI and emulator deps and tests --------- Co-authored-by: Daniel Sainati Co-authored-by: Bjarte Stien Karlsen Co-authored-by: Supun Setunga Co-authored-by: Giovanni Sanchez <108043524+sisyphusSmiling@users.noreply.github.com> --- .github/workflows/ci.yml | 6 +- .github/workflows/release.yml | 31 - .gitignore | 4 +- Makefile | 4 +- README.md | 520 ++-- contracts/ExampleToken.cdc | 342 +-- contracts/FungibleToken.cdc | 266 +- contracts/FungibleTokenMetadataViews.cdc | 74 +- contracts/FungibleTokenSwitchboard.cdc | 191 +- contracts/utility/Burner.cdc | 50 + contracts/utility/MetadataViews.cdc | 738 +++-- contracts/utility/NonFungibleToken.cdc | 264 +- .../utility/PrivateReceiverForwarder.cdc | 33 +- contracts/utility/TokenForwarding.cdc | 41 +- contracts/utility/ViewResolver.cdc | 59 + coverage.json | 261 -- flow.json | 34 +- lib/go/contracts/contracts.go | 63 +- lib/go/contracts/contracts_test.go | 2 +- lib/go/contracts/go.mod | 10 +- lib/go/contracts/go.sum | 28 +- lib/go/contracts/internal/assets/assets.go | 94 +- lib/go/templates/forward_templates.go | 48 +- lib/go/templates/go.mod | 29 +- lib/go/templates/go.sum | 590 +--- lib/go/templates/internal/assets/assets.go | 608 ++-- lib/go/templates/script_templates.go | 17 +- lib/go/templates/templates.go | 120 +- lib/go/templates/transaction_templates.go | 152 +- lib/go/test/forwarding_test.go | 229 -- lib/go/test/go.mod | 202 +- lib/go/test/go.sum | 2579 +++++++++++++++-- lib/go/test/test.go | 10 +- lib/go/test/token_test.go | 506 +--- lib/go/test/token_test_helpers.go | 121 +- ...ample_token.cdc => example_token_test.cdc} | 125 +- tests/metadata_views_test.cdc | 70 + tests/private_receiver_forwarder_test.cdc | 86 + ...ample_token_vault_display_strict_equal.cdc | 46 + tests/scripts/get_supported_vault_types.cdc | 16 - tests/scripts/get_token_metadata.cdc | 10 +- tests/scripts/get_unsupported_view.cdc | 11 +- tests/scripts/get_vault_data.cdc | 20 +- tests/scripts/get_vault_display.cdc | 12 +- tests/scripts/get_views.cdc | 16 - ...t_switchboard.cdc => switchboard_test.cdc} | 76 +- tests/test_helpers.cdc | 147 + tests/transactions/burn_array.cdc | 37 + tests/transactions/burn_dict.cdc | 37 + tests/transactions/burn_optional.cdc | 37 + transactions/burn_tokens.cdc | 52 +- transactions/generic_transfer.cdc | 33 - .../generic_transfer_with_address.cdc | 44 + transactions/generic_transfer_with_paths.cdc | 37 + .../metadata/scripts/get_token_metadata.cdc | 18 + .../metadata/scripts/get_vault_data.cdc | 19 + .../metadata/scripts/get_vault_display.cdc | 19 + .../scripts/get_vault_supply_view.cdc | 22 + transactions/metadata/scripts/get_views.cdc | 19 + .../metadata/setup_account_from_address.cdc | 37 + .../setup_account_from_vault_reference.cdc | 29 +- transactions/mint_tokens.cdc | 30 +- .../create_account_private_forwarder.cdc | 45 +- .../create_private_forwarder.cdc | 37 +- .../deploy_forwarder_contract.cdc | 2 +- .../setup_and_create_forwarder.cdc | 58 +- .../transfer_private_many_accounts.cdc | 18 +- transactions/safe_generic_transfer.cdc | 10 +- transactions/scripts/get_balance.cdc | 18 +- transactions/scripts/get_balance_generic.cdc | 11 + transactions/scripts/get_supply.cdc | 4 +- .../scripts/get_supported_vault_types.cdc | 12 +- .../scripts/metadata/get_token_metadata.cdc | 16 - .../scripts/metadata/get_vault_data.cdc | 17 - .../scripts/metadata/get_vault_display.cdc | 17 - .../metadata/get_vault_supply_view.cdc | 20 - .../switchboard/check_receiver_by_type.cdc | 10 - .../scripts/switchboard/get_vault_types.cdc | 18 - .../get_vault_types_and_address.cdc | 18 - .../tokenForwarder/is_recipient_valid.cdc | 10 - transactions/setup_account.cdc | 38 +- .../switchboard/add_vault_capability.cdc | 74 +- .../add_vault_wrapper_capability.cdc | 54 +- .../batch_add_vault_capabilities.cdc | 32 +- .../batch_add_vault_wrapper_capabilities.cdc | 35 +- .../switchboard/remove_vault_capability.cdc | 36 +- .../switchboard/safe_deposit_to_lnf.cdc | 96 - .../switchboard/safe_transfer_tokens.cdc | 61 +- .../switchboard/safe_transfer_tokens_v2.cdc | 45 - .../scripts/get_vault_types_and_address.cdc | 16 + transactions/switchboard/setup_account.cdc | 52 +- .../switchboard/setup_royalty_account.cdc | 99 +- .../setup_royalty_account_by_paths.cdc | 99 +- transactions/switchboard/transfer_tokens.cdc | 43 +- .../{ => tokenForwarder}/create_forwarder.cdc | 41 +- .../scripts/is_recipient_valid.cdc | 8 + transactions/transfer_many_accounts.cdc | 21 +- transactions/transfer_tokens.cdc | 20 +- 98 files changed, 6075 insertions(+), 4567 deletions(-) delete mode 100644 .github/workflows/release.yml create mode 100644 contracts/utility/Burner.cdc create mode 100644 contracts/utility/ViewResolver.cdc delete mode 100644 coverage.json delete mode 100644 lib/go/test/forwarding_test.go rename tests/{test_example_token.cdc => example_token_test.cdc} (69%) create mode 100644 tests/metadata_views_test.cdc create mode 100644 tests/private_receiver_forwarder_test.cdc create mode 100644 tests/scripts/example_token_vault_display_strict_equal.cdc delete mode 100644 tests/scripts/get_supported_vault_types.cdc delete mode 100644 tests/scripts/get_views.cdc rename tests/{test_switchboard.cdc => switchboard_test.cdc} (69%) create mode 100644 tests/test_helpers.cdc create mode 100644 tests/transactions/burn_array.cdc create mode 100644 tests/transactions/burn_dict.cdc create mode 100644 tests/transactions/burn_optional.cdc delete mode 100644 transactions/generic_transfer.cdc create mode 100644 transactions/generic_transfer_with_address.cdc create mode 100644 transactions/generic_transfer_with_paths.cdc create mode 100644 transactions/metadata/scripts/get_token_metadata.cdc create mode 100644 transactions/metadata/scripts/get_vault_data.cdc create mode 100644 transactions/metadata/scripts/get_vault_display.cdc create mode 100644 transactions/metadata/scripts/get_vault_supply_view.cdc create mode 100644 transactions/metadata/scripts/get_views.cdc create mode 100644 transactions/metadata/setup_account_from_address.cdc create mode 100644 transactions/scripts/get_balance_generic.cdc delete mode 100644 transactions/scripts/metadata/get_token_metadata.cdc delete mode 100644 transactions/scripts/metadata/get_vault_data.cdc delete mode 100644 transactions/scripts/metadata/get_vault_display.cdc delete mode 100644 transactions/scripts/metadata/get_vault_supply_view.cdc delete mode 100644 transactions/scripts/switchboard/check_receiver_by_type.cdc delete mode 100644 transactions/scripts/switchboard/get_vault_types.cdc delete mode 100644 transactions/scripts/switchboard/get_vault_types_and_address.cdc delete mode 100644 transactions/scripts/tokenForwarder/is_recipient_valid.cdc delete mode 100644 transactions/switchboard/safe_deposit_to_lnf.cdc delete mode 100644 transactions/switchboard/safe_transfer_tokens_v2.cdc create mode 100644 transactions/switchboard/scripts/get_vault_types_and_address.cdc rename transactions/{ => tokenForwarder}/create_forwarder.cdc (52%) create mode 100644 transactions/tokenForwarder/scripts/is_recipient_valid.cdc diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e431f009..20ace90c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,7 +11,7 @@ jobs: - uses: actions/checkout@v2 - uses: actions/setup-go@v2 with: - go-version: '1.18.x' + go-version: '1.20.x' - uses: actions/cache@v1 with: path: ~/go/pkg/mod @@ -19,9 +19,9 @@ 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.5.0 + 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 diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml deleted file mode 100644 index bb6336eb..00000000 --- a/.github/workflows/release.yml +++ /dev/null @@ -1,31 +0,0 @@ -name: "🚀 release" - -on: - push: - branches: - - master - -concurrency: ${{ github.workflow }}-${{ github.ref }} - -jobs: - release: - name: 🚀 release - runs-on: ubuntu-latest - steps: - - name: 📚 checkout - uses: actions/checkout@v2.4.2 - - name: 🟢 node - uses: actions/setup-node@v3.2.0 - with: - node-version: 15 - registry-url: https://registry.npmjs.org - - name: Install Dependencies - run: npm i - - name: Create Release Pull Request or Publish to npm - id: changesets - uses: changesets/action@v1 - with: - publish: npm run release - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - NPM_TOKEN: ${{ secrets.NPM_TOKEN }} diff --git a/.gitignore b/.gitignore index a5b04f96..c98e302c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ lib/js/test/node_modules/* node_modules/* -.env \ No newline at end of file +.env +coverage.lcov +coverage.json diff --git a/Makefile b/Makefile index 2d03f4bd..146da318 100644 --- a/Makefile +++ b/Makefile @@ -2,9 +2,9 @@ test: $(MAKE) generate -C lib/go $(MAKE) test -C lib/go - flow test --cover --covercode="contracts" tests/*.cdc + flow-c1 test --cover --covercode="contracts" tests/*.cdc .PHONY: ci ci: $(MAKE) ci -C lib/go - flow test --cover --covercode="contracts" tests/*.cdc + flow-c1 test --cover --covercode="contracts" tests/*.cdc diff --git a/README.md b/README.md index a64831e3..6739426e 100644 --- a/README.md +++ b/README.md @@ -1,19 +1,28 @@ # Fungible Token Standard -This is a description of the Flow standard for fungible token contracts. It is meant to contain the minimum requirements to implement a safe, secure, easy to understand, and easy to use fungible token contract. It also includes an example implementation to show how a concrete smart contract would actually implement the interface. +This is a description of the Flow standard for fungible token contracts. +It is meant to contain the minimum requirements to implement a safe, secure, easy to understand, +and easy to use fungible token contract. +It also includes an example implementation to show how a +concrete smart contract would actually implement the interface. + +The version of the contracts in the `master` branch is the +Cadence 1.0 version of the contracts and is not the same +as the ones that are currently deployed to testnet and mainnet. +See the `cadence-0.42` branch for the currently deployed versions. ## What is Flow? -Flow is a new blockchain for open worlds. Read more about it [here](https://www.onflow.org/). +Flow is a new blockchain for open worlds. Read more about it [here](https://www.flow.com/). ## What is Cadence? Cadence is a new Resource-oriented programming language for developing smart contracts for the Flow Blockchain. -Read more about it [here](https://docs.onflow.org/docs) and see its implementation [here](https://github.com/onflow/cadence) +Read more about it [here](https://developers.flow.com/) and see its implementation [here](https://github.com/onflow/cadence) We recommend that anyone who is reading this should have already -completed the [Cadence Tutorials](https://docs.onflow.org/docs/getting-started-1) +completed the [Cadence Tutorials](https://cadence-lang.org/docs/tutorial/first-steps) so they can build a basic understanding of the programming language. Resource-oriented programming, and by extension Cadence, @@ -28,97 +37,113 @@ The `FungibleToken`, `FungibleTokenMetadataViews`, and `FungibleTokenSwitchboard on various networks. You can import them in your contracts from these addresses. There is no need to deploy them yourself. -(note: default deployment of `FungibleTokenMetadataViews` -and `FungibleTokenSwitchboard` is still pending for emulator/canary, so you will still have to deploy those yourself on those networks) - -| Network | Contract Address | -| --------------- | -------------------- | -| Emulator/Canary | `0xee82856bf20e2aa6` | -| Testnet | `0x9a0766d93b6608b7` | -| Sandboxnet | `0xe20612a0776ca4bf` | -| Mainnet | `0xf233dcee88fe0abe` | +| Network | Contract Address | +| ----------------- | -------------------- | +| Emulator | `0xee82856bf20e2aa6` | +| PreviewNet | `0xa0225e7000ac82a9` | +| Testnet/Crescendo | `0x9a0766d93b6608b7` | +| Sandboxnet | `0xe20612a0776ca4bf` | +| Mainnet | `0xf233dcee88fe0abe` | +The `Burner` contract is also deployed to these addresses, but should only be used in Cadence 1.0 `FungibleToken` implementations of the standard. ## Basics of the Standard: -The code for the standard is in `contracts/FungibleToken.cdc`. An example implementation of the standard that simulates what a simple token would be like is in `contracts/ExampleToken.cdc`. +The code for the standard is in [`contracts/FungibleToken.cdc`](contracts/FungibleToken.cdc). An example implementation of the standard that simulates what a simple token would be like is in [`contracts/ExampleToken.cdc`](contracts/FungibleToken.cdc). -The exact smart contract that is used for the official Flow Network Token is in `contracts/FlowToken.cdc` +The exact smart contract that is used for the official Flow Network Token (`FlowToken`) is in [the `flow-core-contracts` repository](https://github.com/onflow/flow-core-contracts/blob/master/contracts/FlowToken.cdc). Example transactions that users could use to interact with fungible tokens are located in the `transactions/` directory. These templates are mostly generic and can be used with any fungible token implementation by providing the correct addresses, names, and values. -The standard consists of a contract interface called `FungibleToken` that requires implementing contracts to define a `Vault` resource that represents the tokens that an account owns. Each account that owns tokens will have a `Vault` stored in its account storage. Users call functions on each other's `Vault`s to send and receive tokens. +The standard consists of a contract interface called `FungibleToken` that defines important +functionality for token implementations. Contracts are expected to define a resource +that implement the `FungibleToken.Vault` resource interface. +A `Vault` represents the tokens that an account owns. Each account that owns tokens +will have a `Vault` stored in its account storage. +Users call functions on each other's `Vault`s to send and receive tokens. -Right now we are using unsigned 64-bit fixed point numbers `UFix64` as the type to represent token balance information. This type has 8 decimal places and cannot represent negative numbers. +The standard uses unsigned 64-bit fixed point numbers `UFix64` as the type to represent token balance information. This type has 8 decimal places and cannot represent negative numbers. ## Core Features (All contained in the main FungibleToken interface) -1- Getting metadata for the token smart contract via the fields of the contract: - -- `pub var totalSupply: UFix64` - - The only required field of the contract. It would be incremented when new tokens are minted and decremented when they are destroyed. -- Event that gets emitted when the contract is initialized - - `pub event TokensInitialized(initialSupply: UFix64)` - -2- Retrieving the token fields of a `Vault` in an account that owns tokens. - -- Balance interface - - `pub var balance: UFix64` - - The only required field of the `Vault` type - -3- Withdrawing a specific amount of tokens *amount* using the *withdraw* function of the owner's `Vault` - -- Provider interface - - `pub fun withdraw(amount: UFix64): @FungibleToken.Vault` - - Conditions - - the returned Vault's balance must equal the amount withdrawn - - The amount withdrawn must be less than or equal to the balance - - The resulting balance must equal the initial balance - amount - - Users can give other accounts a reference to their `Vault` cast as a `Provider` to allow them to withdraw and send tokens for them. A contract can define any custom logic to govern the amount of tokens that can be withdrawn at a time with a `Provider`. This can mimic the `approve`, `transferFrom` functionality of ERC20. -- withdraw event - - Indicates how much was withdrawn and from what account the `Vault` is stored in. +### `Balance` Interface + +Specifies that the implementing type must have a `UFix64` `balance` field. + - `access(all) var balance: UFix64` + +### `Provider` Interface +Defines a [`withdraw ` function](contracts/FungibleToken.cdc#L95) for withdrawing a specific amount of tokens as *amount*. + - `access(all) fun withdraw(amount: UFix64): @{FungibleToken.Vault}` + - Conditions + - the returned Vault's balance must equal the amount withdrawn + - The amount withdrawn must be less than or equal to the balance + - The resulting balance must equal the initial balance - amount + - Users can give other accounts a persistent Capability + or ephemeral reference to their `Vault` cast as a `Provider` + to allow them to withdraw and send tokens for them. + A contract can define any custom logic to govern the amount of tokens + that can be withdrawn at a time with a `Provider`. + This can mimic the `approve`, `transferFrom` functionality of ERC20. +- [`FungibleToken.Withdrawn` event](contracts/FungibleToken.cdc#L50) + - Event that is emitted automatically to indicate how much was withdrawn + and from what account the `Vault` is stored in. If the `Vault` is not in account storage when the event is emitted, `from` will be `nil`. - - `pub event TokensWithdrawn(amount: UFix64, from: Address?)` - -4 - Depositing a specific amount of tokens *from* using the *deposit* function of the recipient's `Vault` - -- `Receiver` interface - - `pub fun deposit(from: @FungibleToken.Vault)` - - Conditions - - `from` balance must be non-zero - - The resulting balance must be equal to the initial balance + the balance of `from` -- deposit event - - Indicates how much was deposited and to what account the `Vault` is stored in. - If the `Vault` is not in account storage when the event is emitted, - `to` will be `nil`. - - `pub event TokensDeposited(amount: UFix64, to: Address?)` -- Users could create custom `Receiver`s to trigger special code when transfers to them happen, like forwarding the tokens - to another account, splitting them up, and much more. - -- It is important that if you are making your own implementation of the fungible token interface that + - Contracts do not have to emit their own events, + the standard events will automatically be emitted from the interface contract with values identifying the relevant `Vault`. + +Defines [an `isAvailableToWithdraw()` function](contracts/FungibleToken.cdc#L95) +to ask a `Provider` if the specified number of tokens can be withdrawn from the implementing type. + +### `Receiver` Interface +Defines functionality to depositing fungible tokens into a resource object. +- [`deposit()` function](contracts/FungibleToken.cdc#L119): + - `access(all) fun deposit(from: @{FungibleToken.Vault})` + - Conditions + - `from` balance must be non-zero + - The resulting balance must be equal to the initial balance + the balance of `from` + - It is important that if you are making your own implementation of the fungible token interface that you cast the input to `deposit` as the type of your token. `let vault <- from as! @ExampleToken.Vault` - The interface specifies the argument as `@FungibleToken.Vault`, any resource that satisfies this can be sent to the deposit function. The interface checks that the concrete types match, but you'll still need to cast the `Vault` before storing it. - -5 - Creating an empty Vault resource - -- `pub fun createEmptyVault(): @FungibleToken.Vault` + The interface specifies the argument as `@{FungibleToken.Vault}`, any resource that satisfies this can be sent to the deposit function. The interface checks that the concrete types match, but you'll still need to cast the `Vault` before incrementing the receiving `Vault`'s balance. +- deposit event + - [`FungibleToken.Deposited` event](contracts/FungibleToken.cdc#L53) from the standard + that indicates how much was deposited and to what account the `Vault` is stored in. + - If the `Vault` is not in account storage when the event is emitted, + `to` will be `nil`. + - This event is emitted from the interface contract automatically on any deposit, + so projects do not need to define and emit their own events. + +Defines Functionality for Getting Supported Vault Types +- Some resource types can accept multiple different vault types in their deposit functions, + so the `getSupportedVaultTypes()` and `isSupportedVaultType()` functions allow callers + to query a resource that implements `Receiver` to see if the `Receiver` accepts + their desired `Vault` type in its deposit function. + +Users could create custom `Receiver`s to trigger special code when transfers to them happen, +like forwarding the tokens to another account, splitting them up, and much more. + +### `Vault` Interface +[Interface](contracts/FungibleToken.cdc#L134) that inherits from `Provider`, `Receiver`, `Balance`, `ViewResolver.Resolver`, +and `Burner.Burnable` and provides additional pre and post conditions. + +The `ViewResolver.Resolver` interface defines functionality for retrieving metadata +about a particular resource object. [Fungible Token metadata](README.md#ft-metadata) is described below. + +See the comments in [the `Burner` contract](contracts/Burner.cdc) for context about it. +Basically, it defines functionality for tokens to have custom logic when those tokens +are destroyed. + +### Creating an empty Vault resource +Defines functionality in the contract to create a new empty vault of +of the contract's defined type. +- `access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault}` - Defined in the contract - To create an empty `Vault`, the caller calls the function in the contract and stores the Vault in their storage. +- To create an empty `Vault`, the caller calls the function and provides the Vault Type + that they want. They get a vault back and can store it in their storage. - Conditions: - the balance of the returned Vault must be 0 -6 - Destroying a Vault - -If a `Vault` is explicitly destroyed using Cadence's `destroy` keyword, the balance of the destroyed vault must be subtracted from the total supply. - -7 - Standard for Token Metadata - -- not sure what this should be yet -- Could be a dictionary, could be an IPFS hash, could be json, etc. -- need suggestions! - ## Comparison to Similar Standards in Ethereum @@ -133,20 +158,37 @@ This spec covers much of the same ground that a spec like ERC-20 covers, but wit ## FT Metadata -FT Metadata is represented in a flexible and modular way using both the [standard proposed in FLIP-0636](https://github.com/onflow/flips/blob/main/application/20210916-nft-metadata.md) and the [standard proposed in FLIP-1087](https://github.com/onflow/flips/blob/main/application/20220811-fungible-tokens-metadata.md). +FT Metadata is represented in a flexible and modular way using both +the [standard proposed in FLIP-0636](https://github.com/onflow/flips/blob/main/application/20210916-nft-metadata.md) +and the [standard proposed in FLIP-1087](https://github.com/onflow/flips/blob/main/application/20220811-fungible-tokens-metadata.md). -When writing an NFT contract, you should implement the [`MetadataViews.Resolver`](contracts/utility/MetadataViews.cdc#L20-L23) interface, which allows your `Vault` resource to implement one or more metadata types called views. +[A guide for NFT metadata](https://developers.flow.com/build/advanced-concepts/metadata-views) +is provided on the docs site. Many of the concepts described there also apply +to fungible tokens, so it is useful to read for any Cadence developer. + +When writing an FT contract interface, your contract will implement +the `FungibleToken` contract interface which already inherits +from [the `ViewResolver` contract interface](https://github.com/onflow/flow-nft/blob/master/contracts/ViewResolver.cdc), +so you will be required to implement the metadata functions. +Additionally, your `Vault` will also implement the `ViewResolver.Resolver` by default, +which allows your `Vault` resource to implement one or more metadata types called views. Views do not specify or require how to store your metadata, they only specify the format to query and return them, so projects can still be flexible with how they store their data. ### Fungible token Metadata Views -The [Example Token contract](contracts/ExampleToken.cdc) defines three new views that can used to communicate any fungible token information: +The [FungibleTokenMetadataViews contract](contracts/FungibleTokenMetadataViews.cdc) defines four new views that can used to communicate any fungible token information: -1. `FTView` A view that wraps the two other views that actually contain the data. -1. `FTDisplay` The view that contains all the information that will be needed by other dApps to display the fungible token: name, symbol, description, external URL, logos and links to social media. -1. `FTVaultData` The view that can be used by other dApps to interact programmatically with the fungible token, providing the information about the public and private paths used by default by the token, the public and private linked types for exposing capabilities and the function for creating new empty vaults. You can use this view to [setup an account using the vault stored in other account without the need of importing the actual token contract.](transactions/setup_account_from_vault_reference.cdc) +1. `FTView`: A view that wraps the two other views that actually contain the data. +2. `FTDisplay`: The view that contains all the information that will be needed +by other dApps to display the fungible token: name, symbol, description, external URL, logos and links to social media. +3. `FTVaultData`: The view that can be used by other dApps to interact programmatically +with the fungible token, providing the information about the public and storage paths +used by default by the token, the public linked types for exposing capabilities +and the function for creating new empty vaults. +You can use this view to [setup an account using the vault stored in other account without the need of importing the actual token contract.](transactions/setup_account_from_vault_reference.cdc) +4. `TotalSupply`: Specifies the total supply of the given token. ### How to implement metadata @@ -156,67 +198,21 @@ The [Example Token contract](contracts/ExampleToken.cdc) shows how to implement In this repository you can find examples on how to read metadata, accessing the `ExampleToken` display (name, symbol, logos, etc.) and its vault data (paths, linked types and the method to create a new vault). -First step will be to borrow a reference to the token's vault stored in some account: - -```cadence -let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") -``` - Latter using that reference you can call methods defined in the [Fungible Token Metadata Views contract](contracts/FungibleTokenMetadataViews.cdc) that will return you the structure containing the desired information: -```cadence -let ftView = FungibleTokenMetadataViews.getFTView(viewResolver: vaultRef) -``` - -Alternatively you could call directly the `resolveView(_ view: Type): AnyStruct?` method on the `ExampleToken.Vault`, but the `getFTView(viewResolver: &{MetadataViews.Resolver}): FTView`, `getFTDisplay(_ viewResolver: &{MetadataViews.Resolver}): FTDisplay?` and `getFTVaultData(_ viewResolver: &{MetadataViews.Resolver}): FTVaultData?` defined on the `FungibleMetadataViews` contract will ease the process of dealing with optional types when retrieving this views. -Finally you can return the whole of structure or just log some values from the views depending on what you are aiming for: - -```cadence -return ftView -```` - -```cadence -/* -When you retrieve a FTView both the FTDisplay and the FTVaultData views contained on it are optional values, meaning that the token could not be implementing then. -*/ -log(ftView.ftDisplay!.symbol) -``` ## Bonus Features -**Minting and Burning are not included in the standard but are included in the FlowToken example contract to illustrate what minting and burning might look like for a token in Flow.** - -8 - Minting or Burning a specific amount of tokens using a specific minter resource that an owner can control - -- `MintandBurn` Resource - - function to mintTokens - - tokens minted event - - Each minter has a set amount of tokens that they are allowed to mint. This cannot be changed and a new minter needs to be created to add more allowance. - - function to burnTokens - - tokens Burnt event - - Each time tokens are minted or burnt, that value is added or subtracted to or from the total supply. +The following features could each be defined as a separate standard. It would be good to make standards for these, but not necessary to include in the main standard interface and are not currently defined in this example. +- Scoped Provider +This refers to restricting a `Provider` capability to only be able to withdraw a specific amount of tokens from someone else's `Vault` +This is currently being worked on. -**The following features could each be defined as a separate interface. It would be good to make standards for these, but not necessary to include in the main standard interface and are not currently defined in this example.** - -9 - Withdrawing a specific amount of tokens from someone else's `Vault` by using their `provider` reference. - -- approved withdraw event -- Providing a resource that only approves an account to send a specific amount per transaction or per day/month/etc. -- Returning the amount of tokens that an account can send for another account. -- Reading the balance of the account that you have permission to send tokens for -- Owner is able to increase and decrease the approval at will, or revoke it completely - - This is much harder than anticipated - -11 - Pausing Token transfers (maybe a way to prevent the contract from being imported) - -12 - Cloning the token to create a new token with the same distribution - -13 - Restricted ownership (For accredited investors and such) +- Pausing Token transfers (maybe a way to prevent the contract from being imported) +- Cloning the token to create a new token with the same distribution +- Restricted ownership (For accredited investors and such) - allowlisting - denylisting @@ -224,15 +220,19 @@ log(ftView.ftDisplay!.symbol) To use the Flow Token contract as is, you need to follow these steps: -1. If you are using the Playground, you need to deploy the `FungibleToken` definition to account 1 yourself and import it in `ExampleToken`. It is a pre-deployed interface in the emulator, testnet, and mainnet and you can import definition from those accounts: +1. If you are using any network or the playground, there is no need to deploy +the `FungibleToken` definition to accounts yourself. +It is a pre-deployed interface in the emulator, testnet, mainnet, +and playground and you can import definition from those accounts: - `0xee82856bf20e2aa6` on emulator - - `0x9a0766d93b6608b7` on testnet + - `0xa0225e7000ac82a9 ` on previewnet + - `0x9a0766d93b6608b7` on testnet/crescendo - `0xf233dcee88fe0abe` on mainnet -2. Deploy the `ExampleToken` definition +2. Deploy the `ExampleToken` definition, making sure to import the `FungibleToken` interface. 3. You can use the `get_balance.cdc` or `get_supply.cdc` scripts to read the balance of a user's `Vault` or the total supply of all tokens, respectively. -4. Use the `setupAccount.cdc` on any account to set up the account to be able to - use `FlowTokens`. +4. Use the `setup_account.cdc` on any account to set up the account to be able to + use `ExampleToken`. 5. Use the `transfer_tokens.cdc` transaction file to send tokens from one user with a `Vault` in their account storage to another user with a `Vault` in their account storage. 6. Use the `mint_tokens.cdc` transaction with the admin account to mint new tokens. @@ -248,221 +248,91 @@ To use the Flow Token contract as is, you need to follow these steps: Users willing to use the Fungible Token Switchboard will need to setup their accounts by creating a new `FungibleTokenSwitchboard.Switchboard` resource and saving it to their accounts at the `FungibleTokenSwitchboard.StoragePath` path. - This can be accomplished by executing the transaction found in this repository `transactions/switchboard/setup_account.cdc`. This transaction will create and save a Switchboard resource to the signer's account, - and it also will create the needed public capabilities to access it. After setting up their switchboard, in order to make it support receiving a certain token, users will need to add the desired token's receiver capability to their switchboard resource. + This can be accomplished by executing the transaction found in this repository `transactions/switchboard/setup_account.cdc`. + This transaction will create and save a Switchboard resource to the signer's account, + and it also will create the needed public capabilities to access it. + After setting up their switchboard, in order to make it support receiving a certain token, + users will need to add the desired token's receiver capability to their switchboard resource. ## Adding a new vault to the switchboard - When a user wants to receive a new fungible token through their switchboard, they will need to add a new public capability linked to said FT to their switchboard resource. This can be accomplished in two different ways: + When a user wants to receive a new fungible token through their switchboard, + they will need to add a new public capability linked to said FT + to their switchboard resource. This can be accomplished in two different ways: 1. Adding a single capability using `addNewVault(capability: Capability<&{FungibleToken.Receiver}>)` * Before calling this method on a transaction you should first retrieve the capability to the token's vault you are - willing to add to the switchboard, as is done in the template transaction `transactions/switchboard/add_vault_capability.cdc`. - - ```cadence - transaction { - let exampleTokenVaultCapabilty: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard - - prepare(signer: AuthAccount) { - // Get the example token vault capability from the signer's account - self.exampleTokenVaultCapability = - signer.getCapability<&{FungibleToken.Receiver}> - (ExampleToken.ReceiverPublicPath) - // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") - } - - execute { - // Add the capability to the switchboard using addNewVault method - self.switchboardRef.addNewVault(capability: self.exampleTokenVaultCapability) - } - } - ``` - This function will panic if is not possible to `.borrow()` a reference to a `&{FungibleToken.Receiver}` from the passed capability. It will also panic if there is already a capability stored for the same `Type` of resource exposed by the capability. - - 2. Adding one or more capabilities using the paths where they are stored using `addNewVaultsByPath(paths: [PublicPath], address: Address)` + willing to add to the switchboard, as is done in the template transaction [`transactions/switchboard/add_vault_capability.cdc`](./transactions/switchboard/add_vault_capability.cdc). + + This function will panic if is not possible to `.borrow()` a reference + to a `&{FungibleToken.Receiver}` from the passed capability. + + 2. Adding one or more capabilities using the paths where they are stored using `addNewVaultsByPath(paths: [PublicPath], address: Address)`. This is shown in + the [`batch_add_vault_wrapper_capabilities.cdc` transaction](./transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc) * When using this method, an array of `PublicPath` objects should be passed along with the `Address` of the account from where the vaults' capabilities should be retrieved. - ```cadence - transaction (address: Address) { - - let exampleTokenVaultPath: PublicPath - let vaultPaths: [PublicPath] - let switchboardRef: &FungibleTokenSwitchboard.Switchboard - - prepare(signer: AuthAccount) { - // Get the example token vault path from the contract - self.exampleTokenVaultPath = ExampleToken.ReceiverPublicPath - // And store it in the array of public paths that will be passed to the - // switchboard method - self.vaultPaths = [] - self.vaultPaths.append(self.exampleTokenVaultPath) - // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") - } - - execute { - // Add the capability to the switchboard using addNewVault method - self.switchboardRef.addNewVaultsByPath(paths: self.vaultPaths, - address: address) - } - } - ``` - This function won't panic, instead it will just not add to the `@Switchboard` any capability which can not be retrieved from any of the provided `PublicPath`s. It will also ignore any type of `&{FungibleToken.Receiver}` that is already present on the `@Switchboard` + This function won't panic, instead it will just not add to the `@Switchboard` + any capability which can not be retrieved from any of the provided `PublicPath`s. + It will also ignore any type of `&{FungibleToken.Receiver}` that is already present on the `@Switchboard` 3. Adding a capability to a receiver specifying which type of token will be deposited there using `addNewVaultWrapper(capability: Capability<&{FungibleToken.Receiver}>, type: Type)`. This method can be used to link a token forwarder or any other wrapper to the switchboard. Once the `Forwarder` has been properly created containing the capability to an actual `@FungibleToken.Vault`, this method can be used to link the `@Forwarder` to the switchboard to deposit the specified type of Fungible Token. - In the template transaction `switchboard/add_vault_wrapper_capability.cdc`, + In [the template transaction `switchboard/add_vault_wrapper_capability.cdc`](./transactions/switchboard/add_vault_wrapper_capability.cdc), we assume that the signer has a forwarder containing a capability to an `@ExampleToken.Vault` resource: - ```cadence - transaction { - - let tokenForwarderCapability: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard - - prepare(signer: AuthAccount) { - - // Get the token forwarder capability from the signer's account - self.tokenForwarderCapability = - signer.getCapability<&{FungibleToken.Receiver}> - (ExampleToken.ReceiverPublicPath) - - // Check if the receiver capability exists - assert(self.tokenForwarderCapability.check(), - message: "Signer does not have a working fungible token receiver capability") - - // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") - - } - - execute { - - // Add the capability to the switchboard using addNewVault method - self.switchboardRef.addNewVaultWrapper(capability: self.tokenForwarderCapability, type: Type<@ExampleToken.Vault>()) - - } - - } - ``` - ## Removing a vault from the switchboard - If a user no longer wants to be able to receive deposits from a certain FT, or if they want to update the provided capability for one of them, they will need to remove the vault from the switchboard. + If a user no longer wants to be able to receive deposits from a certain FT, + or if they want to update the provided capability for one of them, + they will need to remove the vault from the switchboard. This can be accomplished by using `removeVault(capability: Capability<&{FungibleToken.Receiver}>)`. -This can be observed in the template transaction `transactions/switchboard/remove_vault_capability.cdc`: - ```cadence - transaction { - let exampleTokenVaultCapabilty: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard - - prepare(signer: AuthAccount) { - // Get the example token vault capability from the signer's account - self.exampleTokenVaultCapability = signer.getCapability - <&{FungibleToken.Receiver}>(ExampleToken.ReceiverPublicPath) - // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") - - } - - execute { - // Remove the capability from the switchboard using the - // removeVault method - self.switchboardRef.removeVault(capability: self.exampleTokenVaultCapability) - } - } - ``` +This can be observed in [the template transaction `transactions/switchboard/remove_vault_capability.cdc`](./transactions/switchboard/remove_vault_capability.cdc): + This function will panic if is not possible to `.borrow()` a reference to a `&{FungibleToken.Receiver}` from the passed capability. ## Transferring tokens through the switchboard - The Fungible Token Switchboard provides two different ways of depositing tokens to it, using the `deposit(from: @FungibleToken.Vault)` method enforced by the `{FungibleToken.Receiver}` or using the `safeDeposit(from: @FungibleToken.Vault): @FungibleToken`: + The Fungible Token Switchboard provides two different ways of depositing tokens to it, + using the `deposit(from: @{FungibleToken.Vault})` method enforced by + the `{FungibleToken.Receiver}` or using the `safeDeposit(from: @FungibleToken.Vault): @FungibleToken`: - 1. Using the first method will be just the same as depositing to `&{FungibleToken.Receiver}`. The path for the Switchboard receiver is defined in `FungibleTokenSwitchboard.ReceiverPublicPath`, + 1. Using the first method will be just the same as depositing to `&{FungibleToken.Receiver}`. + The path for the Switchboard receiver is defined in `FungibleTokenSwitchboard.ReceiverPublicPath`, the generic receiver path `/public/GenericFTReceiver` that can also be obtained from the NFT MetadataViews contract. - An example of how to do this can be found in the transaction template on this repo `transactions/switchboard/transfer_tokens.cdc` - ```cadence - transaction(to: Address, amount: UFix64) { - // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault + An example of how to do this can be found in the transaction template on this repo [`transactions/switchboard/transfer_tokens.cdc`](./transactions/switchboard/transfer_tokens.cdc). - prepare(signer: AuthAccount) { + 2. The `safeDeposit(from: @FungibleToken.Vault): @FungibleToken` works in a similar way, + with the difference that it will not panic if the desired FT Vault + can not be obtained from the Switchboard. The method will return the passed vault, + empty if the funds were deposited successfully or still containing the funds + if the transfer of the funds was not possible. Keep in mind that + when using this method on a transaction you will always have to deal + with the returned resource. An example of this can be found on [`transactions/switchboard/safe_transfer_tokens.cdc`](./transactions/switchboard/safe_transfer_tokens.cdc): - // Get a reference to the signer's stored vault - let vaultRef = signer.borrow<&ExampleToken.Vault> - (from: ExampleToken.VaultStoragePath) - ?? panic("Could not borrow reference to the owner's Vault!") - - // Withdraw tokens from the signer's stored vault - self.sentVault <- vaultRef.withdraw(amount: amount) - } - - execute { - - // Get the recipient's public account object - let recipient = getAccount(to) - - // Get a reference to the recipient's Switchboard Receiver - let switchboardRef = recipient.getCapability - (FungibleTokenSwitchboard.ReceiverPublicPath) - .borrow<&{FungibleToken.Receiver}>() - ?? panic("Could not borrow receiver reference to switchboard!") - - // Deposit the withdrawn tokens in the recipient's switchboard receiver - switchboardRef.deposit(from: <-self.sentVault) - } - } - ``` - - 2. The `safeDeposit(from: @FungibleToken.Vault): @FungibleToken` works in a similar way, with the difference that it will not panic if the desired FT Vault can not be obtained from the Switchboard. The method will return the passed vault, empty if the funds were deposited successfully or still containing the funds if the transfer of the funds was not possible. Keep in mind that when using this method on a transaction you will always have to deal with the returned resource. An example of this can be found on `transactions/switchboard/safe_transfer_tokens.cdc`: - ```cadence - transaction(to: Address, amount: UFix64) { - // The reference to the vault from the payer's account - let vaultRef: &ExampleToken.Vault - // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault - - - prepare(signer: AuthAccount) { - - // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) - ?? panic("Could not borrow reference to the owner's Vault!") - - // Withdraw tokens from the signer's stored vault - self.sentVault <- self.vaultRef.withdraw(amount: amount) - } - - execute { +# Running Automated Tests - // Get the recipient's public account object - let recipient = getAccount(to) +There are two sets of tests in the repo, Cadence tests and Go tests. +The Cadence tests are much more straightforward and are all written in Cadence, +so we recommend following those. - // Get a reference to the recipient's Switchboard Receiver - let switchboardRef = recipient.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() - ?? panic("Could not borrow receiver reference to switchboard!") +## Cadence Testing Framework - // Deposit the withdrawn tokens in the recipient's switchboard receiver, - // then deposit the returned vault in the signer's vault - self.vaultRef.deposit(from: <- switchboardRef.safeDeposit(from: <-self.sentVault)) - } - } - ``` +The Cadence tests are located in the `tests/` repository. They are written in Cadence +and can be run directly from the command line using the Flow CLI. +Make sure you are using [the latest Cadence 1.0 CLI verion](https://forum.flow.com/t/update-on-cadence-1-0/5197/10). +``` +flow test --cover --covercode="contracts" tests/*.cdc +``` -# Running Automated Tests +## Go tests -You can find automated tests in the `lib/go/test/token_test.go` file. It uses the transaction templates that are contained in the `lib/go/templates/transaction_templates.go` file. Currently, these rely on a dependency from a private dapper labs repository to run, so external users will not be able to run them. We are working on making all of this public so anyone can run tests, but haven't completed this work yet. +You can find automated tests in the `lib/go/test/token_test.go` file. +It uses the transaction templates that are contained in the +`lib/go/templates/transaction_templates.go` file. You can run them by navigating +to the `lib/go/test/` directory and running `go test -v`. +If you make changes to the contracts or transactions in between running tests, +you will need to run `make generate` from the `lib/go/` directory +to generate the assets used in the tests. ## License diff --git a/contracts/ExampleToken.cdc b/contracts/ExampleToken.cdc index b2ff6506..9f619abc 100644 --- a/contracts/ExampleToken.cdc +++ b/contracts/ExampleToken.cdc @@ -2,38 +2,75 @@ import "FungibleToken" import "MetadataViews" import "FungibleTokenMetadataViews" -pub contract ExampleToken: FungibleToken { - - /// Total supply of ExampleTokens in existence - pub var totalSupply: UFix64 - - /// Storage and Public Paths - pub let VaultStoragePath: StoragePath - pub let VaultPublicPath: PublicPath - pub let ReceiverPublicPath: PublicPath - pub let AdminStoragePath: StoragePath - - /// The event that is emitted when the contract is created - pub event TokensInitialized(initialSupply: UFix64) - - /// The event that is emitted when tokens are withdrawn from a Vault - pub event TokensWithdrawn(amount: UFix64, from: Address?) - - /// The event that is emitted when tokens are deposited to a Vault - pub event TokensDeposited(amount: UFix64, to: Address?) +access(all) contract ExampleToken: FungibleToken { /// The event that is emitted when new tokens are minted - pub event TokensMinted(amount: UFix64) + access(all) event TokensMinted(amount: UFix64, type: String) - /// The event that is emitted when tokens are destroyed - pub event TokensBurned(amount: UFix64) + /// Total supply of ExampleTokens in existence + access(all) var totalSupply: UFix64 - /// The event that is emitted when a new minter resource is created - pub event MinterCreated(allowedAmount: UFix64) + /// Storage and Public Paths + access(all) let VaultStoragePath: StoragePath + access(all) let VaultPublicPath: PublicPath + access(all) let ReceiverPublicPath: PublicPath + access(all) let AdminStoragePath: StoragePath + + access(all) view fun getContractViews(resourceType: Type?): [Type] { + return [ + Type(), + Type(), + Type(), + Type() + ] + } - /// The event that is emitted when a new burner resource is created - pub event BurnerCreated() + access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? { + switch viewType { + case Type(): + return FungibleTokenMetadataViews.FTView( + ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTDisplay?, + ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ) + case Type(): + let media = MetadataViews.Media( + file: MetadataViews.HTTPFile( + url: "https://assets.website-files.com/5f6294c0c7a8cdd643b1c820/5f6294c0c7a8cda55cb1c936_Flow_Wordmark.svg" + ), + mediaType: "image/svg+xml" + ) + let medias = MetadataViews.Medias([media]) + return FungibleTokenMetadataViews.FTDisplay( + name: "Example Fungible Token", + symbol: "EFT", + description: "This fungible token is used as an example to help you develop your next FT #onFlow.", + externalURL: MetadataViews.ExternalURL("https://example-ft.onflow.org"), + logos: medias, + socials: { + "twitter": MetadataViews.ExternalURL("https://twitter.com/flow_blockchain") + } + ) + case Type(): + return FungibleTokenMetadataViews.FTVaultData( + storagePath: self.VaultStoragePath, + receiverPath: self.ReceiverPublicPath, + metadataPath: self.VaultPublicPath, + receiverLinkedType: Type<&ExampleToken.Vault>(), + metadataLinkedType: Type<&ExampleToken.Vault>(), + createEmptyVaultFunction: (fun(): @{FungibleToken.Vault} { + return <-ExampleToken.createEmptyVault(vaultType: Type<@ExampleToken.Vault>()) + }) + ) + case Type(): + return FungibleTokenMetadataViews.TotalSupply( + totalSupply: ExampleToken.totalSupply + ) + } + return nil + } + /// Vault + /// /// Each user stores an instance of only the Vault in their storage /// The functions in the Vault and governed by the pre and post conditions /// in FungibleToken when they are called. @@ -44,228 +81,145 @@ pub contract ExampleToken: FungibleToken { /// out of thin air. A special Minter resource needs to be defined to mint /// new tokens. /// - pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance, MetadataViews.Resolver { + access(all) resource Vault: FungibleToken.Vault { /// The total balance of this vault - pub var balance: UFix64 + access(all) var balance: UFix64 - /// Initialize the balance at resource creation time + // initialize the balance at resource creation time init(balance: UFix64) { self.balance = balance } + /// Called when a fungible token is burned via the `Burner.burn()` method + access(contract) fun burnCallback() { + if self.balance > 0.0 { + ExampleToken.totalSupply = ExampleToken.totalSupply - self.balance + } + self.balance = 0.0 + } + + access(all) view fun getViews(): [Type] { + return ExampleToken.getContractViews(resourceType: nil) + } + + access(all) fun resolveView(_ view: Type): AnyStruct? { + return ExampleToken.resolveContractView(resourceType: nil, viewType: view) + } + + /// getSupportedVaultTypes optionally returns a list of vault types that this receiver accepts + access(all) view fun getSupportedVaultTypes(): {Type: Bool} { + let supportedTypes: {Type: Bool} = {} + supportedTypes[self.getType()] = true + return supportedTypes + } + + access(all) view fun isSupportedVaultType(type: Type): Bool { + return self.getSupportedVaultTypes()[type] ?? false + } + + /// Asks if the amount can be withdrawn from this vault + access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool { + return amount <= self.balance + } + + /// withdraw + /// /// Function that takes an amount as an argument /// and withdraws that amount from the Vault. + /// /// It creates a new temporary Vault that is used to hold - /// the money that is being transferred. It returns the newly + /// the tokens that are being transferred. It returns the newly /// created Vault to the context that called so it can be deposited /// elsewhere. /// - /// @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): @FungibleToken.Vault { + access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @ExampleToken.Vault { self.balance = self.balance - amount - emit TokensWithdrawn(amount: amount, from: self.owner?.address) return <-create Vault(balance: amount) } + /// deposit + /// /// Function that takes a Vault object as an argument and adds /// its balance to the balance of the owners Vault. + /// /// It is allowed to destroy the sent Vault because the Vault /// was a temporary holder of the tokens. The Vault's balance has /// been consumed and therefore can be destroyed. /// - /// @param from: The Vault resource containing the funds that will be deposited - /// - pub fun deposit(from: @FungibleToken.Vault) { + access(all) fun deposit(from: @{FungibleToken.Vault}) { let vault <- from as! @ExampleToken.Vault self.balance = self.balance + vault.balance - emit TokensDeposited(amount: vault.balance, to: self.owner?.address) vault.balance = 0.0 destroy vault } - destroy() { - if self.balance > 0.0 { - ExampleToken.totalSupply = ExampleToken.totalSupply - self.balance - } - } - - /// The way of getting all the Metadata Views implemented by ExampleToken + /// createEmptyVault /// - /// @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. + /// Function that creates a new Vault with a balance of zero + /// and returns it to the calling context. A user must call this function + /// and store the returned Vault in their storage in order to allow their + /// account to be able to receive deposits of this token type. /// - pub fun getViews(): [Type] { - return [ - Type(), - Type(), - Type(), - Type() - ] - } - - /// The way of getting a Metadata View out of the ExampleToken - /// - /// @param view: The Type of the desired view. - /// @return A structure representing the requested view. - /// - pub fun resolveView(_ view: Type): AnyStruct? { - switch view { - case Type(): - return FungibleTokenMetadataViews.FTView( - ftDisplay: self.resolveView(Type()) as! FungibleTokenMetadataViews.FTDisplay?, - ftVaultData: self.resolveView(Type()) as! FungibleTokenMetadataViews.FTVaultData? - ) - case Type(): - let media = MetadataViews.Media( - file: MetadataViews.HTTPFile( - url: "https://assets.website-files.com/5f6294c0c7a8cdd643b1c820/5f6294c0c7a8cda55cb1c936_Flow_Wordmark.svg" - ), - mediaType: "image/svg+xml" - ) - let medias = MetadataViews.Medias([media]) - return FungibleTokenMetadataViews.FTDisplay( - name: "Example Fungible Token", - symbol: "EFT", - description: "This fungible token is used as an example to help you develop your next FT #onFlow.", - externalURL: MetadataViews.ExternalURL("https://example-ft.onflow.org"), - logos: medias, - socials: { - "twitter": MetadataViews.ExternalURL("https://twitter.com/flow_blockchain") - } - ) - case Type(): - return FungibleTokenMetadataViews.FTVaultData( - storagePath: ExampleToken.VaultStoragePath, - receiverPath: ExampleToken.ReceiverPublicPath, - metadataPath: ExampleToken.VaultPublicPath, - providerPath: /private/exampleTokenVault, - receiverLinkedType: Type<&ExampleToken.Vault{FungibleToken.Receiver}>(), - metadataLinkedType: Type<&ExampleToken.Vault{FungibleToken.Balance, MetadataViews.Resolver}>(), - providerLinkedType: Type<&ExampleToken.Vault{FungibleToken.Provider}>(), - createEmptyVaultFunction: (fun (): @ExampleToken.Vault { - return <-ExampleToken.createEmptyVault() - }) - ) - case Type(): - return FungibleTokenMetadataViews.TotalSupply(totalSupply: ExampleToken.totalSupply) - } - return nil + access(all) fun createEmptyVault(): @ExampleToken.Vault { + return <-create Vault(balance: 0.0) } } - /// Function that creates a new Vault with a balance of zero - /// and returns it to the calling context. A user must call this function - /// and store the returned Vault in their storage in order to allow their - /// account to be able to receive deposits of this token type. + /// Minter /// - /// @return The new Vault resource - /// - pub fun createEmptyVault(): @Vault { - return <-create Vault(balance: 0.0) - } - - pub resource Administrator { - - /// Function that creates and returns a new minter resource - /// - /// @param allowedAmount: The maximum quantity of tokens that the minter could create - /// @return The Minter resource that would allow to mint tokens - /// - pub fun createNewMinter(allowedAmount: UFix64): @Minter { - emit MinterCreated(allowedAmount: allowedAmount) - return <-create Minter(allowedAmount: allowedAmount) - } - - /// Function that creates and returns a new burner resource - /// - /// @return The Burner resource - /// - pub fun createNewBurner(): @Burner { - emit BurnerCreated() - return <-create Burner() - } - } - /// Resource object that token admin accounts can hold to mint new tokens. /// - pub resource Minter { - - /// The amount of tokens that the minter is allowed to mint - pub var allowedAmount: UFix64 - + access(all) resource Minter { + /// mintTokens + /// /// Function that mints new tokens, adds them to the total supply, /// and returns them to the calling context. /// - /// @param amount: The quantity of tokens to mint - /// @return The Vault resource containing the minted tokens - /// - pub fun mintTokens(amount: UFix64): @ExampleToken.Vault { - pre { - amount > 0.0: "Amount minted must be greater than zero" - amount <= self.allowedAmount: "Amount minted must be less than the allowed amount" - } + access(all) fun mintTokens(amount: UFix64): @ExampleToken.Vault { ExampleToken.totalSupply = ExampleToken.totalSupply + amount - self.allowedAmount = self.allowedAmount - amount - emit TokensMinted(amount: amount) - return <-create Vault(balance: amount) - } - - init(allowedAmount: UFix64) { - self.allowedAmount = allowedAmount + let vault <-create Vault(balance: amount) + emit TokensMinted(amount: amount, type: vault.getType().identifier) + return <-vault } } - /// Resource object that token admin accounts can hold to burn tokens. + /// createEmptyVault /// - pub resource Burner { - - /// Function that destroys a Vault instance, effectively burning the tokens. - /// - /// Note: the burned tokens are automatically subtracted from the - /// total supply in the Vault destructor. - /// - /// @param from: The Vault resource containing the tokens to burn - /// - pub fun burnTokens(from: @FungibleToken.Vault) { - let vault <- from as! @ExampleToken.Vault - let amount = vault.balance - destroy vault - emit TokensBurned(amount: amount) - } + /// Function that creates a new Vault with a balance of zero + /// and returns it to the calling context. A user must call this function + /// and store the returned Vault in their storage in order to allow their + /// account to be able to receive deposits of this token type. + /// + access(all) fun createEmptyVault(vaultType: Type): @ExampleToken.Vault { + return <- create Vault(balance: 0.0) } init() { self.totalSupply = 1000.0 + self.VaultStoragePath = /storage/exampleTokenVault - self.VaultPublicPath = /public/exampleTokenMetadata + self.VaultPublicPath = /public/exampleTokenVault self.ReceiverPublicPath = /public/exampleTokenReceiver - self.AdminStoragePath = /storage/exampleTokenAdmin + self.AdminStoragePath = /storage/exampleTokenAdmin - // Create the Vault with the total supply of tokens and save it in storage. + // Create the Vault with the total supply of tokens and save it in storage + // let vault <- create Vault(balance: self.totalSupply) - self.account.save(<-vault, to: self.VaultStoragePath) + emit TokensMinted(amount: vault.balance, type: vault.getType().identifier) // Create a public capability to the stored Vault that exposes - // the `deposit` method through the `Receiver` interface. - self.account.link<&{FungibleToken.Receiver}>( - self.ReceiverPublicPath, - target: self.VaultStoragePath - ) - - // Create a public capability to the stored Vault that only exposes - // the `balance` field and the `resolveView` method through the `Balance` interface - self.account.link<&ExampleToken.Vault{FungibleToken.Balance}>( - self.VaultPublicPath, - target: self.VaultStoragePath - ) - - let admin <- create Administrator() - self.account.save(<-admin, to: self.AdminStoragePath) - - // Emit an event that shows that the contract was initialized - emit TokensInitialized(initialSupply: self.totalSupply) + // the `deposit` method and getAcceptedTypes method through the `Receiver` interface + // and the `balance` method through the `Balance` interface + // + let exampleTokenCap = self.account.capabilities.storage.issue<&ExampleToken.Vault>(self.VaultStoragePath) + self.account.capabilities.publish(exampleTokenCap, at: self.VaultPublicPath) + let receiverCap = self.account.capabilities.storage.issue<&ExampleToken.Vault>(self.VaultStoragePath) + self.account.capabilities.publish(receiverCap, at: self.ReceiverPublicPath) + + self.account.storage.save(<-vault, to: /storage/exampleTokenVault) + + let admin <- create Minter() + self.account.storage.save(<-admin, to: self.AdminStoragePath) } } diff --git a/contracts/FungibleToken.cdc b/contracts/FungibleToken.cdc index 48b092d2..512401c1 100644 --- a/contracts/FungibleToken.cdc +++ b/contracts/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,40 @@ 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" +import "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 should implement the fungible token +/// 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, balanceAfter: UFix64) + + /// 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, balanceAfter: UFix64) + + /// 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,27 +70,26 @@ 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: @@ -94,6 +98,8 @@ pub contract interface FungibleToken { } } + /// Receiver + /// /// The interface that enforces the requirements for depositing /// tokens into the implementing type. /// @@ -102,30 +108,56 @@ 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 returns a dictionary of Vault types + /// and whether the type is currently supported by this Receiver + 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" + } + self.balance = 0.0 + } + + /// getSupportedVaultTypes returns a dictionary of vault types and whether this receiver accepts the indexed type + /// 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,85 +165,41 @@ 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" + emit Withdrawn( + type: result.getType().identifier, + amount: amount, + from: self.owner?.address, + fromUUID: self.uuid, + withdrawnUUID: result.uuid, + balanceAfter: self.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 { @@ -219,19 +207,35 @@ pub contract interface FungibleToken { "Cannot deposit an incompatible token type" } post { + emit Deposited( + type: before(from.getType().identifier), + amount: before(from.balance), + to: self.owner?.address, + toUUID: self.uuid, + depositedUUID: before(from.uuid), + balanceAfter: self.balance + ) 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" + result.getType() == self.getType(): "The newly created Vault must have the same type as the creating vault" + } + } } - /// 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/FungibleTokenMetadataViews.cdc b/contracts/FungibleTokenMetadataViews.cdc index d8dda1b7..c0cdd51f 100644 --- a/contracts/FungibleTokenMetadataViews.cdc +++ b/contracts/FungibleTokenMetadataViews.cdc @@ -1,5 +1,6 @@ -import FungibleToken from "FungibleToken" -import MetadataViews from "MetadataViews" +import "FungibleToken" +import "MetadataViews" +import "ViewResolver" /// This contract implements the metadata standard proposed /// in FLIP-1087. @@ -10,16 +11,16 @@ import MetadataViews from "MetadataViews" /// metadata types, called views. Each view type represents /// a different kind of metadata. /// -pub contract FungibleTokenMetadataViews { +access(all) contract FungibleTokenMetadataViews { /// FTView wraps FTDisplay and FTVaultData, and is used to give a complete /// picture of a Fungible Token. Most Fungible Token contracts should /// implement this view. /// - pub struct FTView { - pub let ftDisplay: FTDisplay? - pub let ftVaultData: FTVaultData? - init( + access(all) struct FTView { + access(all) let ftDisplay: FTDisplay? + access(all) let ftVaultData: FTVaultData? + view init( ftDisplay: FTDisplay?, ftVaultData: FTVaultData? ) { @@ -33,7 +34,7 @@ pub contract FungibleTokenMetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return A FTView struct /// - pub fun getFTView(viewResolver: &{MetadataViews.Resolver}): FTView { + access(all) fun getFTView(viewResolver: &{ViewResolver.Resolver}): FTView { let maybeFTView = viewResolver.resolveView(Type()) if let ftView = maybeFTView { return ftView as! FTView @@ -48,34 +49,34 @@ pub contract FungibleTokenMetadataViews { /// This can be used by applications to give an overview and /// graphics of the FT. /// - pub struct FTDisplay { + access(all) struct FTDisplay { /// The display name for this token. /// /// Example: "Flow" /// - pub let name: String + access(all) let name: String /// The abbreviated symbol for this token. /// /// Example: "FLOW" - pub let symbol: String + access(all) let symbol: String /// A description the provides an overview of this token. /// /// Example: "The FLOW token is the native currency of the Flow network." - pub let description: String + access(all) let description: String /// External link to a URL to view more information about the fungible token. - pub let externalURL: MetadataViews.ExternalURL + access(all) let externalURL: MetadataViews.ExternalURL /// One or more versions of the fungible token logo. - pub let logos: MetadataViews.Medias + access(all) let logos: MetadataViews.Medias /// Social links to reach the fungible token's social homepages. /// Possible keys may be "instagram", "twitter", "discord", etc. - pub let socials: {String: MetadataViews.ExternalURL} + access(all) let socials: {String: MetadataViews.ExternalURL} - init( + view init( name: String, symbol: String, description: String, @@ -97,7 +98,7 @@ pub contract FungibleTokenMetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return An optional FTDisplay struct /// - pub fun getFTDisplay(_ viewResolver: &{MetadataViews.Resolver}): FTDisplay? { + access(all) fun getFTDisplay(_ viewResolver: &{ViewResolver.Resolver}): FTDisplay? { if let maybeDisplayView = viewResolver.resolveView(Type()) { if let displayView = maybeDisplayView as? FTDisplay { return displayView @@ -110,58 +111,45 @@ pub contract FungibleTokenMetadataViews { /// This can be used by applications to setup a FT vault with proper /// storage and public capabilities. /// - pub struct FTVaultData { + access(all) struct FTVaultData { /// Path in storage where this FT vault is recommended to be stored. - pub let storagePath: StoragePath + access(all) let storagePath: StoragePath /// Public path which must be linked to expose the public receiver capability. - pub let receiverPath: PublicPath + access(all) let receiverPath: PublicPath /// Public path which must be linked to expose the balance and resolver public capabilities. - pub let metadataPath: PublicPath - - /// Private path which should be linked to expose the provider capability to withdraw funds - /// from the vault. - pub let providerPath: PrivatePath + access(all) let metadataPath: PublicPath /// Type that should be linked at the `receiverPath`. This is a restricted type requiring /// the `FungibleToken.Receiver` interface. - pub let receiverLinkedType: Type + access(all) let receiverLinkedType: Type /// Type that should be linked at the `receiverPath`. This is a restricted type requiring - /// the `FungibleToken.Balance` and `MetadataViews.Resolver` interfaces. - pub let metadataLinkedType: Type - - /// Type that should be linked at the aforementioned private path. This - /// is normally a restricted type with at a minimum the `FungibleToken.Provider` interface. - pub let providerLinkedType: Type + /// the `ViewResolver.Resolver` interfaces. + access(all) let metadataLinkedType: Type /// Function that allows creation of an empty FT vault that is intended /// to store the funds. - pub let createEmptyVault: ((): @FungibleToken.Vault) + access(all) let createEmptyVault: fun(): @{FungibleToken.Vault} - init( + view init( storagePath: StoragePath, receiverPath: PublicPath, metadataPath: PublicPath, - providerPath: PrivatePath, receiverLinkedType: Type, metadataLinkedType: Type, - providerLinkedType: Type, - createEmptyVaultFunction: ((): @FungibleToken.Vault) + createEmptyVaultFunction: fun(): @{FungibleToken.Vault} ) { pre { receiverLinkedType.isSubtype(of: Type<&{FungibleToken.Receiver}>()): "Receiver public type must include FungibleToken.Receiver." - metadataLinkedType.isSubtype(of: Type<&{FungibleToken.Balance, MetadataViews.Resolver}>()): "Metadata public type must include FungibleToken.Balance and MetadataViews.Resolver interfaces." - providerLinkedType.isSubtype(of: Type<&{FungibleToken.Provider}>()): "Provider type must include FungibleToken.Provider interface." + metadataLinkedType.isSubtype(of: Type<&{FungibleToken.Vault}>()): "Metadata linked type must be a fungible token vault" } self.storagePath = storagePath self.receiverPath = receiverPath self.metadataPath = metadataPath - self.providerPath = providerPath self.receiverLinkedType = receiverLinkedType self.metadataLinkedType = metadataLinkedType - self.providerLinkedType = providerLinkedType self.createEmptyVault = createEmptyVaultFunction } } @@ -171,7 +159,7 @@ pub contract FungibleTokenMetadataViews { /// @param viewResolver: A reference to the resolver resource /// @return A optional FTVaultData struct /// - pub fun getFTVaultData(_ viewResolver: &{MetadataViews.Resolver}): FTVaultData? { + access(all) fun getFTVaultData(_ viewResolver: &{ViewResolver.Resolver}): FTVaultData? { if let view = viewResolver.resolveView(Type()) { if let v = view as? FTVaultData { return v @@ -184,7 +172,7 @@ pub contract FungibleTokenMetadataViews { access(all) struct TotalSupply { access(all) let supply: UFix64 - init(totalSupply: UFix64) { + view init(totalSupply: UFix64) { self.supply = totalSupply } } diff --git a/contracts/FungibleTokenSwitchboard.cdc b/contracts/FungibleTokenSwitchboard.cdc index 66a82cdd..158e733e 100644 --- a/contracts/FungibleTokenSwitchboard.cdc +++ b/contracts/FungibleTokenSwitchboard.cdc @@ -1,4 +1,4 @@ -import FungibleToken from "FungibleToken" +import "FungibleToken" /// The contract that allows an account to receive payments in multiple fungible /// tokens using a single `{FungibleToken.Receiver}` capability. @@ -6,49 +6,50 @@ import FungibleToken from "FungibleToken" /// `FungibleTokenSwitchboard.ReceiverPublicPath = /public/GenericFTReceiver` /// but it can be stored anywhere. /// -pub contract FungibleTokenSwitchboard { +access(all) contract FungibleTokenSwitchboard { // Storage and Public Paths - pub let StoragePath: StoragePath - pub let PublicPath: PublicPath - pub let ReceiverPublicPath: PublicPath + access(all) let StoragePath: StoragePath + access(all) let PublicPath: PublicPath + access(all) let ReceiverPublicPath: PublicPath + + access(all) entitlement Owner /// The event that is emitted when a new vault capability is added to a /// switchboard resource. /// - pub event VaultCapabilityAdded(type: Type, switchboardOwner: Address?, + access(all) event VaultCapabilityAdded(type: Type, switchboardOwner: Address?, capabilityOwner: Address?) /// The event that is emitted when a vault capability is removed from a /// switchboard resource. /// - pub event VaultCapabilityRemoved(type: Type, switchboardOwner: Address?, + access(all) event VaultCapabilityRemoved(type: Type, switchboardOwner: Address?, capabilityOwner: Address?) /// The event that is emitted when a deposit can not be completed. /// - pub event NotCompletedDeposit(type: Type, amount: UFix64, + access(all) event NotCompletedDeposit(type: Type, amount: UFix64, switchboardOwner: Address?) /// The interface that enforces the method to allow anyone to check on the /// available capabilities of a switchboard resource and also exposes the /// deposit methods to deposit funds on it. /// - pub resource interface SwitchboardPublic { - pub fun getVaultTypes(): [Type] - pub fun getVaultTypesWithAddress(): {Type: Address} - pub fun getSupportedVaultTypes(): {Type: Bool} - pub fun deposit(from: @FungibleToken.Vault) - pub fun safeDeposit(from: @FungibleToken.Vault): @FungibleToken.Vault? - pub fun checkReceiverByType(type: Type): Bool - pub fun safeBorrowByType(type: Type): &{FungibleToken.Receiver}? + access(all) resource interface SwitchboardPublic { + access(all) view fun getVaultTypesWithAddress(): {Type: Address} + access(all) view fun getSupportedVaultTypes(): {Type: Bool} + access(all) view fun isSupportedVaultType(type: Type): Bool + access(all) fun deposit(from: @{FungibleToken.Vault}) + access(all) fun safeDeposit(from: @{FungibleToken.Vault}): @{FungibleToken.Vault}? + access(all) view fun safeBorrowByType(type: Type): &{FungibleToken.Receiver}? } /// The resource that stores the multiple fungible token receiver /// capabilities, allowing the owner to add and remove them and anyone to /// deposit any fungible token among the available types. /// - pub resource Switchboard: FungibleToken.Receiver, SwitchboardPublic { + access(all) resource Switchboard: FungibleToken.Receiver, SwitchboardPublic { /// Dictionary holding the fungible token receiver capabilities, /// indexed by the fungible token vault type. @@ -62,7 +63,7 @@ pub contract FungibleTokenSwitchboard { /// token vault deposit function through `{FungibleToken.Receiver}` that /// will be added to the switchboard. /// - pub fun addNewVault(capability: Capability<&{FungibleToken.Receiver}>) { + access(Owner) fun addNewVault(capability: Capability<&{FungibleToken.Receiver}>) { // Borrow a reference to the vault pointed to by the capability we // want to store inside the switchboard let vaultRef = capability.borrow() @@ -89,35 +90,35 @@ pub contract FungibleTokenSwitchboard { /// @param paths: The paths where the public capabilities are stored. /// @param address: The address of the owner of the capabilities. /// - pub fun addNewVaultsByPath(paths: [PublicPath], address: Address) { + access(Owner) fun addNewVaultsByPath(paths: [PublicPath], address: Address) { // Get the account where the public capabilities are stored let owner = getAccount(address) // For each path, get the saved capability and store it // into the switchboard's receiver capabilities dictionary for path in paths { - let capability = owner.getCapability<&{FungibleToken.Receiver}>(path) - // Borrow a reference to the vault pointed to by the capability + let capability = owner.capabilities.get<&{FungibleToken.Receiver}>(path) + // Borrow a reference to the vault pointed to by the capability // we want to store inside the switchboard // If the vault was borrowed successfully... if let vaultRef = capability.borrow() { - // ...and if there is no previous capability added for that - // token + // ...and if there is no previous capability added for that token if (self.receiverCapabilities[vaultRef!.getType()] == nil) { - // Use the vault reference type as key for storing the + // Use the vault reference type as key for storing the // capability self.receiverCapabilities[vaultRef!.getType()] = capability - // and emit the event that indicates that a new + // and emit the event that indicates that a new // capability has been added - emit VaultCapabilityAdded(type: vaultRef.getType(), - switchboardOwner: self.owner?.address, - capabilityOwner: address) + emit VaultCapabilityAdded(type: vaultRef.getType(), + switchboardOwner: self.owner?.address, + capabilityOwner: address, + ) } } } } /// Adds a new fungible token receiver capability to the switchboard - /// resource specifying which `Type` of `@FungibleToken.Vault` can be + /// resource specifying which `Type` of `@{FungibleToken.Vault}` can be /// deposited to it. Use it to include in your switchboard "wrapper" /// receivers such as a `@TokenForwarding.Forwarder`. It can also be /// used to overwrite the type attached to a certain capability without @@ -131,7 +132,7 @@ pub contract FungibleTokenSwitchboard { /// capability, rather than the `Type` from the reference borrowed from /// said capability /// - pub fun addNewVaultWrapper(capability: Capability<&{FungibleToken.Receiver}>, + access(Owner) fun addNewVaultWrapper(capability: Capability<&{FungibleToken.Receiver}>, type: Type) { // Check if the capability is working assert(capability.check(), message: "The passed capability is not valid") @@ -139,13 +140,15 @@ pub contract FungibleTokenSwitchboard { self.receiverCapabilities[type] = capability // emit the event that indicates that a new capability has been // added - emit VaultCapabilityAdded(type: type, - switchboardOwner: self.owner?.address, - capabilityOwner: capability.address) + emit VaultCapabilityAdded( + type: type, + switchboardOwner: self.owner?.address, + capabilityOwner: capability.address, + ) } /// Adds zero or more new fungible token receiver capabilities to the - /// switchboard resource specifying which `Type`s of `@FungibleToken.Vault`s + /// switchboard resource specifying which `Type`s of `@{FungibleToken.Vault}`s /// can be deposited to it. Use it to include in your switchboard "wrapper" /// receivers such as a `@TokenForwarding.Forwarder`. It can also be /// used to overwrite the types attached to certain capabilities without @@ -155,29 +158,26 @@ pub contract FungibleTokenSwitchboard { /// @param types: The types of the fungible token to be deposited on each path. /// @param address: The address of the owner of the capabilities. /// - pub fun addNewVaultWrappersByPath(paths: [PublicPath], types: [Type], + access(Owner) fun addNewVaultWrappersByPath(paths: [PublicPath], types: [Type], address: Address) { // Get the account where the public capabilities are stored let owner = getAccount(address) // For each path, get the saved capability and store it // into the switchboard's receiver capabilities dictionary for i, path in paths { - let capability = - owner.getCapability<&{FungibleToken.Receiver}>(path) - // Borrow a reference to the vault pointed to by the capability + let capability = owner.capabilities.get<&{FungibleToken.Receiver}>(path) + // Borrow a reference to the vault pointed to by the capability // we want to store inside the switchboard // If the vault was borrowed successfully... - if let vaultRef = - capability.borrow() { - // Use the vault reference type as key for storing the - // capability + if let vaultRef = capability.borrow() { + // Use the vault reference type as key for storing the capability self.receiverCapabilities[types[i]] = capability - // and emit the event that indicates that a new - // capability has been added - emit VaultCapabilityAdded(type: types[i], - switchboardOwner: self.owner?.address, - capabilityOwner: address) - + // and emit the event that indicates that a new capability has been added + emit VaultCapabilityAdded( + type: types[i], + switchboardOwner: self.owner?.address, + capabilityOwner: address, + ) } } } @@ -188,7 +188,7 @@ pub contract FungibleTokenSwitchboard { /// @param capability: The capability to a fungible token vault to be /// removed from the switchboard. /// - pub fun removeVault(capability: Capability<&{FungibleToken.Receiver}>) { + access(Owner) fun removeVault(capability: Capability<&{FungibleToken.Receiver}>) { // Borrow a reference to the vault pointed to by the capability we // want to remove from the switchboard let vaultRef = capability.borrow() @@ -197,9 +197,11 @@ pub contract FungibleTokenSwitchboard { self.receiverCapabilities.remove(key: vaultRef.getType()) // Emit the event that indicates that a new capability has been // removed - emit VaultCapabilityRemoved(type: vaultRef.getType(), - switchboardOwner: self.owner?.address, - capabilityOwner: capability.address) + emit VaultCapabilityRemoved( + type: vaultRef.getType(), + switchboardOwner: self.owner?.address, + capabilityOwner: capability.address, + ) } /// Takes a fungible token vault and routes it to the proper fungible @@ -207,15 +209,15 @@ pub contract FungibleTokenSwitchboard { /// /// @param from: The deposited fungible token vault resource. /// - pub fun deposit(from: @FungibleToken.Vault) { + access(all) fun deposit(from: @{FungibleToken.Vault}) { // Get the capability from the ones stored at the switchboard - let depositedVaultCapability - = self.receiverCapabilities[from.getType()] + let depositedVaultCapability = self.receiverCapabilities[from.getType()] ?? panic ("The deposited vault is not available on this switchboard") + // Borrow the reference to the desired vault - let vaultRef = - depositedVaultCapability.borrow() - ?? panic ("Can not borrow a reference to the the vault") + let vaultRef = depositedVaultCapability.borrow() + ?? panic ("Can not borrow a reference to the the vault") + vaultRef.deposit(from: <-from) } @@ -230,23 +232,24 @@ pub contract FungibleTokenSwitchboard { /// funds if the deposit was successful, or still containing the funds /// if the reference to the needed vault was not found. /// - pub fun safeDeposit(from: @FungibleToken.Vault): @FungibleToken.Vault? { + access(all) fun safeDeposit(from: @{FungibleToken.Vault}): @{FungibleToken.Vault}? { // Try to get the proper vault capability from the switchboard // If the desired vault is present on the switchboard... - if let depositedVaultCapability - = self.receiverCapabilities[from.getType()] { + if let depositedVaultCapability = self.receiverCapabilities[from.getType()] { // We try to borrow a reference to the vault from the capability // If we can borrow a reference to the vault... - if let vaultRef = - depositedVaultCapability.borrow() { + if let vaultRef = depositedVaultCapability.borrow() { // We deposit the funds on said vault vaultRef.deposit(from: <-from.withdraw(amount: from.balance)) } } // if deposit failed for some reason if from.balance > 0.0 { - emit NotCompletedDeposit(type: from.getType(), amount: from.balance, - switchboardOwner: self.owner?.address) + emit NotCompletedDeposit( + type: from.getType(), + amount: from.balance, + switchboardOwner: self.owner?.address, + ) return <-from } destroy from @@ -258,7 +261,7 @@ pub contract FungibleTokenSwitchboard { /// @param vaultType: The type of the ft vault whose capability needs to be checked /// /// @return a boolean marking the capability for a type as valid or not - pub fun checkReceiverByType(type: Type): Bool { + access(all) view fun checkReceiverByType(type: Type): Bool { if self.receiverCapabilities[type] == nil { return false } @@ -274,7 +277,7 @@ pub contract FungibleTokenSwitchboard { /// @param vaultType: The type of the ft vault whose capability needs to be checked /// /// @return an optional receiver capability for consumers of the switchboard to check/validate on their own - pub fun safeBorrowByType(type: Type): &{FungibleToken.Receiver}? { + access(all) view fun safeBorrowByType(type: Type): &{FungibleToken.Receiver}? { if !self.checkReceiverByType(type: type) { return nil } @@ -282,23 +285,6 @@ pub contract FungibleTokenSwitchboard { return self.receiverCapabilities[type]!.borrow() } - /// A getter function to know which tokens a certain switchboard - /// resource is prepared to receive. - /// - /// @return The keys from the dictionary of stored - /// `{FungibleToken.Receiver}` capabilities that can be effectively - /// borrowed. - /// - pub fun getVaultTypes(): [Type] { - let effectiveTypes: [Type] = [] - for vaultType in self.receiverCapabilities.keys { - if self.receiverCapabilities[vaultType]!.check() { - effectiveTypes.append(vaultType) - } - } - return effectiveTypes - } - /// A getter function to know which tokens a certain switchboard /// resource is prepared to receive along with the address where /// those tokens will be deposited. @@ -306,14 +292,13 @@ pub contract FungibleTokenSwitchboard { /// @return A dictionary mapping the `{FungibleToken.Receiver}` /// type to the receiver owner's address /// - pub fun getVaultTypesWithAddress(): {Type: Address} { + access(all) view fun getVaultTypesWithAddress(): {Type: Address} { let effectiveTypesWithAddress: {Type: Address} = {} // Check if each capability is live for vaultType in self.receiverCapabilities.keys { if self.receiverCapabilities[vaultType]!.check() { // and attach it to the owner's address - effectiveTypesWithAddress[vaultType] = - self.receiverCapabilities[vaultType]!.address + effectiveTypesWithAddress[vaultType] = self.receiverCapabilities[vaultType]!.address } } return effectiveTypesWithAddress @@ -323,15 +308,36 @@ pub contract FungibleTokenSwitchboard { /// which can be deposited using the 'deposit' function. /// /// @return Dictionary of FT types that can be deposited. - pub fun getSupportedVaultTypes(): {Type: Bool} { + access(all) view fun getSupportedVaultTypes(): {Type: Bool} { let supportedVaults: {Type: Bool} = {} - let vaultTypes = self.getVaultTypes() - for vaultT in vaultTypes { - supportedVaults.insert(key: vaultT, true) + for receiverType in self.receiverCapabilities.keys { + if self.receiverCapabilities[receiverType]!.check() { + if receiverType.isSubtype(of: Type<@{FungibleToken.Vault}>()) { + supportedVaults[receiverType] = true + } + if receiverType.isSubtype(of: Type<@{FungibleToken.Receiver}>()) { + let receiverRef = self.receiverCapabilities[receiverType]!.borrow()! + let subReceiverSupportedTypes = receiverRef.getSupportedVaultTypes() + for subReceiverType in subReceiverSupportedTypes.keys { + if subReceiverType.isSubtype(of: Type<@{FungibleToken.Vault}>()) { + supportedVaults[subReceiverType] = true + } + } + } + } } return supportedVaults } + /// 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 { + let supportedVaults = self.getSupportedVaultTypes() + if let supported = supportedVaults[type] { + return supported + } else { return false } + } + init() { // Initialize the capabilities dictionary self.receiverCapabilities = {} @@ -342,7 +348,7 @@ pub contract FungibleTokenSwitchboard { /// Function that allows to create a new blank switchboard. A user must call /// this function and store the returned resource in their storage. /// - pub fun createSwitchboard(): @Switchboard { + access(all) fun createSwitchboard(): @Switchboard { return <-create Switchboard() } @@ -351,5 +357,4 @@ pub contract FungibleTokenSwitchboard { self.PublicPath = /public/fungibleTokenSwitchboardPublic self.ReceiverPublicPath = /public/GenericFTReceiver } - } diff --git a/contracts/utility/Burner.cdc b/contracts/utility/Burner.cdc new file mode 100644 index 00000000..66ba5f2c --- /dev/null +++ b/contracts/utility/Burner.cdc @@ -0,0 +1,50 @@ +/// 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(_ toBurn: @AnyResource?) { + if toBurn == nil { + destroy toBurn + return + } + let r <- toBurn! + + 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/utility/MetadataViews.cdc b/contracts/utility/MetadataViews.cdc index 2934fdff..f47932eb 100644 --- a/contracts/utility/MetadataViews.cdc +++ b/contracts/utility/MetadataViews.cdc @@ -1,123 +1,49 @@ -import FungibleToken from "FungibleToken" -import NonFungibleToken from "NonFungibleToken" +import "FungibleToken" +import "NonFungibleToken" +import "ViewResolver" /// This contract implements the metadata standard proposed /// in FLIP-0636. -/// +/// /// Ref: https://github.com/onflow/flips/blob/main/application/20210916-nft-metadata.md -/// +/// /// Structs and resources can implement one or more /// metadata types, called views. Each view type represents /// 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. + /// 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. + /// 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 @@ -139,23 +65,23 @@ pub contract MetadataViews { return nil } - /// Generic interface that represents a file stored on or off chain. Files + /// 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. + /// 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,99 +126,107 @@ 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 { + access(all) struct Media { - /// 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? + /// File for the media + /// + access(all) let file: {File} - /// The edition number of the object. - /// For an "24 of 100 (#24/100)" item, the number is 24. - pub let number: UInt64 + /// 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 + /// + access(all) let mediaType: String - /// 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 max: UInt64? + view init(file: {File}, mediaType: String) { + self.file=file + self.mediaType=mediaType + } + } - 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 + /// + access(all) struct Medias { + + /// An arbitrary-sized list for any number of Media items + access(all) let items: [Media] + + view init(_ items: [Media]) { + self.items = items } } - /// Wrapper view for multiple Edition views - /// - pub struct Editions { + /// Helper to get Medias in a typesafe way + /// + /// @param viewResolver: A reference to the resolver resource + /// @return A optional Medias struct + /// + access(all) fun getMedias(_ viewResolver: &{ViewResolver.Resolver}) : Medias? { + if let view = viewResolver.resolveView(Type()) { + if let v = view as? Medias { + return v + } + } + return nil + } - /// An arbitrary-sized list for any number of editions - /// that the NFT might be a part of - pub let infoList: [Edition] + /// View to represent a license according to https://spdx.org/licenses/ + /// This view can be used if the content of an NFT is licensed. + /// + access(all) struct License { + access(all) let spdxIdentifier: String - init(_ infoList: [Edition]) { - self.infoList = infoList + view init(_ identifier: String) { + self.spdxIdentifier = identifier } } - /// Helper to get Editions in a typesafe way + /// Helper to get License in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return An optional Editions struct + /// @return A optional License struct /// - pub fun getEditions(_ viewResolver: &{Resolver}) : Editions? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Editions { + 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 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 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 /// - pub struct Serial { - pub let number: UInt64 + access(all) struct ExternalURL { + access(all) let url: String - init(_ number: UInt64) { - self.number = number + view init(_ url: String) { + self.url=url } } - /// Helper to get Serial in a typesafe way + /// Helper to get ExternalURL in a typesafe way /// /// @param viewResolver: A reference to the resolver resource - /// @return An optional Serial struct + /// @return A optional ExternalURL struct /// - pub fun getSerial(_ viewResolver: &{Resolver}) : Serial? { - if let view = viewResolver.resolveView(Type()) { - if let v = view as? Serial { + 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() @@ -300,7 +234,7 @@ pub contract MetadataViews { /// 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 @@ -311,14 +245,14 @@ pub contract MetadataViews { /// 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]" } @@ -332,12 +266,12 @@ pub contract MetadataViews { /// 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,161 +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. + /// 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 /// 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 } } @@ -541,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 @@ -554,33 +652,33 @@ pub contract MetadataViews { /// 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 @@ -597,7 +695,7 @@ pub contract MetadataViews { /// @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 @@ -605,136 +703,4 @@ 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 - /// - pub struct Rarity { - /// The score of the rarity as a number - pub let score: UFix64? - - /// 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 - } - } - - /// 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 - } - } - 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 - /// - 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 - - // 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?) { - 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. - 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) - } - } - \ No newline at end of file diff --git a/contracts/utility/NonFungibleToken.cdc b/contracts/utility/NonFungibleToken.cdc index 04f90d84..4f79d2cc 100644 --- a/contracts/utility/NonFungibleToken.cdc +++ b/contracts/utility/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,102 +36,197 @@ Collection to complete the transfer. */ -// The main NFT contract interface. Other NFT contracts will -// import and implement this interface -// -pub contract interface NonFungibleToken { - - // The total number of tokens of this type in existence - pub var totalSupply: UInt64 - - // Event that emitted when the NFT contract is initialized - // - pub event ContractInitialized() - - // Event that is emitted when a token is withdrawn, - // indicating the owner of the collection that it was withdrawn from. - // - // If the collection is not in an account's storage, `from` will be `nil`. - // - pub event Withdraw(id: UInt64, from: Address?) - - // Event that emitted when a token is deposited to a collection. - // - // It indicates the owner of the collection that it was deposited to. - // - pub event Deposit(id: UInt64, to: Address?) - - // Interface that the NFTs have to conform to - // - pub resource interface INFT { - // The unique ID that each NFT has - pub let id: UInt64 +import "ViewResolver" + +/// The main NFT contract. Other NFT contracts will +/// import and implement the interfaces defined in this contract +/// +access(all) contract interface NonFungibleToken: ViewResolver { + + /// An entitlement for allowing the withdrawal of tokens from a Vault + access(all) entitlement Withdraw + + /// An entitlement for allowing updates and update events for an NFT + access(all) entitlement Update + + /// entitlement for owner that grants Withdraw and Update + access(all) entitlement Owner + + /// 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. + /// + access(all) event Updated(type: String, id: UInt64, uuid: UInt64, owner: Address?) + access(contract) view fun emitNFTUpdated(_ nftRef: auth(Update | Owner) &{NonFungibleToken.NFT}) + { + emit Updated(type: nftRef.getType().identifier, id: nftRef.id, uuid: nftRef.uuid, owner: nftRef.owner?.address) } - // Requirement that all conforming NFT smart contracts have - // to define a resource called NFT that conforms to INFT - pub resource NFT: INFT { - pub let id: UInt64 - } - // Interface to mediate withdraws from the Collection - // - pub resource interface Provider { - // withdraw removes an NFT from the collection and moves it to the caller - pub fun withdraw(withdrawID: UInt64): @NFT { + /// Event that is emitted when a token is withdrawn, + /// 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`. + /// + 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 + /// + /// If the collection is not in an account's storage, `from`, will be `nil`. + /// + access(all) event Deposited(type: String, id: UInt64, uuid: UInt64, to: Address?, collectionUUID: UInt64) + + /// Included for backwards-compatibility + access(all) resource interface INFT: NFT {} + + /// Interface that the NFTs must conform to + /// + access(all) resource interface NFT: ViewResolver.Resolver { + + /// 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.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID" + result.getLength() == 0: "The created collection must be empty!" } } - } - // Interface to mediate deposits to the Collection - // - pub resource interface Receiver { + /// 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 {} + } - // deposit takes an NFT as an argument and adds it to the Collection - // - pub fun deposit(token: @NFT) + /// 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 type: The Type of the desired NFT + /// @param id: The id of the NFT to borrow + /// + /// @return A structure representing the requested view. + access(all) fun getSubNFT(type: Type, id: UInt64) : &{NonFungibleToken.NFT}? { + return nil + } } - // 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 + /// Interface to mediate withdrawals from a resource, usually a Collection + /// + access(all) resource interface Provider { + + // 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 | Owner) 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) + } + } } - // Requirement for the concrete resource type - // to be declared in the implementing contract - // - pub resource Collection: Provider, Receiver, CollectionPublic { + /// Interface to mediate deposits to the Collection + /// + access(all) resource interface Receiver { - // Dictionary to hold the NFTs in the Collection - pub var ownedNFTs: @{UInt64: NFT} + /// 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}) - // withdraw removes an NFT from the collection and moves it to the caller - pub fun withdraw(withdrawID: UInt64): @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} - // deposit takes a NFT and adds it to the collections dictionary - // and adds the ID to the id array - pub fun deposit(token: @NFT) + /// 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 + } + + /// 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) view fun borrowNFT(_ id: UInt64): &{NFT}? + } - // getIDs returns an array of the IDs that are in the collection - pub fun getIDs(): [UInt64] + /// Requirement for the concrete resource type + /// to be declared in the implementing contract + /// + access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection { - // Returns a borrowed reference to an NFT in the collection - // so that the caller can read data and call methods from it - pub fun borrowNFT(id: 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 { - self.ownedNFTs[id] != nil: "NFT does not exist in the collection!" + // 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) + } + } + + /// Gets the amount of NFTs stored in the collection + /// @return An integer indicating the size of the collection + access(all) view fun getLength(): Int + + /// 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 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!" } } } - // createEmptyCollection creates an empty Collection - // and returns it to the caller so that they can own NFTs - 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!" } diff --git a/contracts/utility/PrivateReceiverForwarder.cdc b/contracts/utility/PrivateReceiverForwarder.cdc index 63898a7e..0bdf60c9 100644 --- a/contracts/utility/PrivateReceiverForwarder.cdc +++ b/contracts/utility/PrivateReceiverForwarder.cdc @@ -7,19 +7,19 @@ whose deposit function is only callable by an admin through a public capability. */ -import FungibleToken from "FungibleToken" +import "FungibleToken" -pub contract PrivateReceiverForwarder { +access(all) contract PrivateReceiverForwarder { // Event that is emitted when tokens are deposited to the target receiver - pub event PrivateDeposit(amount: UFix64, to: Address?) + access(all) event PrivateDeposit(amount: UFix64, depositedUUID: UInt64, from: Address?, to: Address?, toUUID: UInt64) - pub let SenderStoragePath: StoragePath + access(all) let SenderStoragePath: StoragePath - pub let PrivateReceiverStoragePath: StoragePath - pub let PrivateReceiverPublicPath: PublicPath + access(all) let PrivateReceiverStoragePath: StoragePath + access(all) let PrivateReceiverPublicPath: PublicPath - pub resource Forwarder { + access(all) resource Forwarder { // This is where the deposited tokens will be sent. // The type indicates that it is a reference to a receiver @@ -31,14 +31,16 @@ pub contract PrivateReceiverForwarder { // Function that takes a Vault object as an argument and forwards // it to the recipient's Vault using the stored reference // - access(contract) fun deposit(from: @FungibleToken.Vault) { + access(contract) fun deposit(from: @{FungibleToken.Vault}) { let receiverRef = self.recipient.borrow()! let balance = from.balance + let uuid = from.uuid + receiverRef.deposit(from: <-from) - emit PrivateDeposit(amount: balance, to: self.owner?.address) + emit PrivateDeposit(amount: balance, depositedUUID: uuid, from: self.owner?.address, to: receiverRef.owner?.address, toUUID: receiverRef.uuid) } init(recipient: Capability<&{FungibleToken.Receiver}>) { @@ -51,18 +53,19 @@ pub contract PrivateReceiverForwarder { // createNewForwarder creates a new Forwarder reference with the provided recipient // - pub fun createNewForwarder(recipient: Capability<&{FungibleToken.Receiver}>): @Forwarder { + access(all) fun createNewForwarder(recipient: Capability<&{FungibleToken.Receiver}>): @Forwarder { return <-create Forwarder(recipient: recipient) } - pub resource Sender { - pub fun sendPrivateTokens(_ address: Address, tokens: @FungibleToken.Vault) { + access(all) resource Sender { + access(all) fun sendPrivateTokens(_ address: Address, tokens: @{FungibleToken.Vault}) { let account = getAccount(address) - let privateReceiver = account.getCapability<&PrivateReceiverForwarder.Forwarder>(PrivateReceiverForwarder.PrivateReceiverPublicPath) - .borrow() ?? panic("Could not borrow reference to private forwarder") + let privateReceiver = account.capabilities.borrow<&PrivateReceiverForwarder.Forwarder>( + PrivateReceiverForwarder.PrivateReceiverPublicPath + ) ?? panic("Could not borrow reference to private forwarder") privateReceiver.deposit(from: <-tokens) @@ -76,7 +79,7 @@ pub contract PrivateReceiverForwarder { self.PrivateReceiverStoragePath = storagePath self.PrivateReceiverPublicPath = publicPath - self.account.save(<-create Sender(), to: self.SenderStoragePath) + self.account.storage.save(<-create Sender(), to: self.SenderStoragePath) } } \ No newline at end of file diff --git a/contracts/utility/TokenForwarding.cdc b/contracts/utility/TokenForwarding.cdc index 60d69d09..8527f839 100644 --- a/contracts/utility/TokenForwarding.cdc +++ b/contracts/utility/TokenForwarding.cdc @@ -14,18 +14,18 @@ their tokens to. */ -import FungibleToken from "FungibleToken" +import "FungibleToken" -pub contract TokenForwarding { +access(all) contract TokenForwarding { // Event that is emitted when tokens are deposited to the target receiver - pub event ForwardedDeposit(amount: UFix64, from: Address?) + access(all) event ForwardedDeposit(amount: UFix64, depositedUUID: UInt64, from: Address?, to: Address?, toUUID: UInt64, depositedType: Type) - pub resource interface ForwarderPublic { + access(all) resource interface ForwarderPublic { /// Helper function to check whether set `recipient` capability /// is not latent or the capability tied to a type is valid. - pub fun check(): Bool + access(all) fun check(): Bool /// Gets the receiver assigned to a recipient capability. /// This is necessary because without it, it is not possible to look under the hood and see if a capability @@ -33,10 +33,10 @@ pub contract TokenForwarding { /// malicious kinds of updates that could prevent listings from being made that are valid on storefronts. /// /// @return an optional receiver capability for consumers of the TokenForwarding to check/validate on their own - pub fun safeBorrow(): &{FungibleToken.Receiver}? + access(all) fun safeBorrow(): &{FungibleToken.Receiver}? } - pub resource Forwarder: FungibleToken.Receiver, ForwarderPublic { + access(all) resource Forwarder: FungibleToken.Receiver, ForwarderPublic { // This is where the deposited tokens will be sent. // The type indicates that it is a reference to a receiver @@ -48,19 +48,21 @@ pub contract TokenForwarding { // Function that takes a Vault object as an argument and forwards // it to the recipient's Vault using the stored reference // - pub fun deposit(from: @FungibleToken.Vault) { + access(all) fun deposit(from: @{FungibleToken.Vault}) { let receiverRef = self.recipient.borrow<&{FungibleToken.Receiver}>()! let balance = from.balance - receiverRef.deposit(from: <-from) + let uuid = from.uuid + + emit ForwardedDeposit(amount: balance, depositedUUID: uuid, from: self.owner?.address, to: receiverRef.owner?.address, toUUID: receiverRef.uuid, depositedType: from.getType()) - emit ForwardedDeposit(amount: balance, from: self.owner?.address) + receiverRef.deposit(from: <-from) } /// Helper function to check whether set `recipient` capability /// is not latent or the capability tied to a type is valid. - pub fun check(): Bool { + access(all) fun check(): Bool { return self.recipient.check<&{FungibleToken.Receiver}>() } @@ -70,13 +72,13 @@ pub contract TokenForwarding { /// malicious kinds of updates that could prevent listings from being made that are valid on storefronts. /// /// @return an optional receiver capability for consumers of the TokenForwarding to check/validate on their own - pub fun safeBorrow(): &{FungibleToken.Receiver}? { + access(all) fun safeBorrow(): &{FungibleToken.Receiver}? { return self.recipient.borrow<&{FungibleToken.Receiver}>() } // changeRecipient changes the recipient of the forwarder to the provided recipient // - pub fun changeRecipient(_ newRecipient: Capability) { + access(all) fun changeRecipient(_ newRecipient: Capability) { pre { newRecipient.borrow<&{FungibleToken.Receiver}>() != nil: "Could not borrow Receiver reference from the Capability" } @@ -87,7 +89,7 @@ pub contract TokenForwarding { /// which can be deposited using the 'deposit' function. /// /// @return Array of FT types that can be deposited. - pub fun getSupportedVaultTypes(): {Type: Bool} { + access(all) view fun getSupportedVaultTypes(): {Type: Bool} { if !self.recipient.check<&{FungibleToken.Receiver}>() { return {} } @@ -97,6 +99,15 @@ pub contract TokenForwarding { return supportedVaults } + /// 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 { + let supportedVaults = self.getSupportedVaultTypes() + if let supported = supportedVaults[type] { + return supported + } else { return false } + } + init(recipient: Capability) { pre { recipient.borrow<&{FungibleToken.Receiver}>() != nil: "Could not borrow Receiver reference from the Capability" @@ -107,7 +118,7 @@ pub contract TokenForwarding { // createNewForwarder creates a new Forwarder reference with the provided recipient // - pub fun createNewForwarder(recipient: Capability): @Forwarder { + access(all) fun createNewForwarder(recipient: Capability): @Forwarder { return <-create Forwarder(recipient: recipient) } } diff --git a/contracts/utility/ViewResolver.cdc b/contracts/utility/ViewResolver.cdc new file mode 100644 index 00000000..862a4e82 --- /dev/null +++ b/contracts/utility/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/coverage.json b/coverage.json deleted file mode 100644 index c26366f8..00000000 --- a/coverage.json +++ /dev/null @@ -1,261 +0,0 @@ -{ - "coverage": { - "A.0000000000000007.ExampleToken": { - "line_hits": { - "101": 1, - "115": 6, - "117": 1, - "122": 2, - "128": 2, - "129": 2, - "140": 2, - "149": 1, - "153": 0, - "155": 1, - "167": 3, - "178": 1, - "179": 1, - "187": 1, - "188": 1, - "207": 1, - "208": 1, - "210": 1, - "211": 1, - "212": 1, - "213": 1, - "217": 1, - "233": 1, - "234": 1, - "235": 1, - "236": 1, - "241": 2, - "242": 2, - "243": 2, - "244": 2, - "245": 2, - "248": 2, - "249": 2, - "253": 2, - "260": 2, - "265": 2, - "266": 2, - "269": 2, - "54": 12, - "68": 6, - "69": 6, - "70": 6, - "82": 5, - "83": 5, - "84": 5, - "85": 5, - "86": 5, - "90": 7, - "91": 1 - }, - "missed_lines": [ - 153 - ], - "statements": 49, - "percentage": "98.0%" - }, - "A.0000000000000007.FungibleTokenMetadataViews": { - "line_hits": { - "101": 1, - "102": 1, - "103": 1, - "106": 0, - "154": 2, - "155": 2, - "156": 2, - "158": 2, - "159": 2, - "160": 2, - "161": 2, - "162": 2, - "163": 2, - "164": 2, - "165": 2, - "175": 1, - "176": 1, - "177": 1, - "180": 0, - "188": 0, - "26": 1, - "27": 1, - "37": 1, - "38": 1, - "39": 1, - "41": 0, - "86": 2, - "87": 2, - "88": 2, - "89": 2, - "90": 2, - "91": 2 - }, - "missed_lines": [ - 41, - 106, - 180, - 188 - ], - "statements": 32, - "percentage": "87.5%" - }, - "A.0000000000000007.FungibleTokenSwitchboard": { - "line_hits": { - "102": 0, - "105": 0, - "108": 0, - "111": 0, - "137": 0, - "139": 0, - "142": 0, - "161": 1, - "164": 1, - "165": 1, - "170": 1, - "174": 1, - "177": 1, - "194": 1, - "197": 1, - "200": 1, - "212": 4, - "216": 3, - "219": 3, - "236": 0, - "240": 0, - "243": 0, - "247": 0, - "248": 0, - "250": 0, - "252": 0, - "253": 0, - "262": 1, - "263": 0, - "266": 1, - "278": 1, - "279": 0, - "282": 1, - "293": 4, - "294": 4, - "295": 2, - "296": 2, - "299": 4, - "310": 0, - "312": 0, - "313": 0, - "315": 0, - "319": 0, - "327": 4, - "328": 4, - "329": 4, - "330": 2, - "332": 4, - "337": 1, - "346": 1, - "350": 1, - "351": 1, - "352": 1, - "68": 1, - "71": 1, - "74": 1, - "77": 1, - "82": 0, - "94": 0, - "97": 0, - "98": 0 - }, - "missed_lines": [ - 82, - 94, - 97, - 98, - 102, - 105, - 108, - 111, - 137, - 139, - 142, - 236, - 240, - 243, - 247, - 248, - 250, - 252, - 253, - 263, - 279, - 310, - 312, - 313, - 315, - 319 - ], - "statements": 61, - "percentage": "57.4%" - }, - "A.0000000000000007.TokenForwarding": { - "line_hits": { - "102": 1, - "104": 1, - "111": 1, - "52": 1, - "54": 1, - "56": 1, - "58": 1, - "64": 0, - "74": 0, - "81": 0, - "83": 0, - "91": 0, - "92": 0, - "94": 0, - "95": 0, - "96": 0, - "97": 0 - }, - "missed_lines": [ - 64, - 74, - 81, - 83, - 91, - 92, - 94, - 95, - 96, - 97 - ], - "statements": 17, - "percentage": "41.2%" - } - }, - "excluded_locations": [ - "A.0000000000000002.FungibleToken", - "A.0000000000000002.FungibleTokenMetadataViews", - "A.0000000000000001.FlowClusterQC", - "A.0000000000000001.FlowIDTableStaking", - "A.0000000000000001.NFTStorefront", - "I.Crypto", - "A.0000000000000001.NodeVersionBeacon", - "A.0000000000000001.FlowServiceAccount", - "A.0000000000000001.FlowDKG", - "A.0000000000000001.LockedTokens", - "A.0000000000000001.FlowStakingCollection", - "A.0000000000000001.ExampleNFT", - "I.Test", - "A.0000000000000001.StakingProxy", - "A.0000000000000004.FlowFees", - "A.0000000000000001.FlowStorageFees", - "A.0000000000000001.FlowEpoch", - "A.0000000000000001.NFTStorefrontV2", - "s.7465737400000000000000000000000000000000000000000000000000000000", - "A.0000000000000003.FlowToken", - "A.0000000000000001.ViewResolver", - "A.0000000000000001.MetadataViews", - "A.0000000000000001.NonFungibleToken" - ] -} \ No newline at end of file diff --git a/flow.json b/flow.json index 7cfc5864..79b80a1d 100644 --- a/flow.json +++ b/flow.json @@ -4,6 +4,8 @@ "source": "./contracts/FungibleToken.cdc", "aliases": { "emulator": "0xee82856bf20e2aa6", + "testing": "0x0000000000000007", + "previewnet": "0xa0225e7000ac82a9", "testnet": "0x9a0766d93b6608b7", "mainnet": "0xf233dcee88fe0abe" } @@ -13,6 +15,7 @@ "aliases": { "emulator": "0xf8d6e0586b0a20c7", "testing": "0x0000000000000007", + "previewnet": "0xa0225e7000ac82a9", "mainnet": "0xf233dcee88fe0abe", "testnet": "0x9a0766d93b6608b7" } @@ -22,6 +25,7 @@ "aliases": { "emulator": "0xf8d6e0586b0a20c7", "testing": "0x0000000000000007", + "previewnet": "0xa0225e7000ac82a9", "mainnet": "0xf233dcee88fe0abe", "testnet": "0x9a0766d93b6608b7" } @@ -36,20 +40,43 @@ "PrivateReceiverForwarder": { "source": "./contracts/utility/PrivateReceiverForwarder.cdc", "aliases": { - "emulator": "0xf8d6e0586b0a20c7" + "emulator": "0xf8d6e0586b0a20c7", + "testing": "0x0000000000000007" } }, "TokenForwarding": { "source": "./contracts/utility/TokenForwarding.cdc", "aliases": { "emulator": "0xf8d6e0586b0a20c7", + "testnet": "0x51ea0e37c27a1f1a", "testing": "0x0000000000000007" } }, + "ViewResolver": { + "source": "./contracts/utility/ViewResolver.cdc", + "aliases": { + "emulator": "0xf8d6e0586b0a20c7", + "testing": "0x0000000000000007", + "previewnet": "0xb6763b4399a888c8", + "mainnet": "0x1d7e57aa55817448", + "testnet": "0x631e88ae7f1d7c20" + } + }, + "Burner": { + "source": "./contracts/utility/Burner.cdc", + "aliases": { + "emulator": "0xf8d6e0586b0a20c7", + "testing": "0x0000000000000007", + "previewnet": "0xa0225e7000ac82a9", + "testnet": "0x9a0766d93b6608b7" + } + }, "NonFungibleToken": { "source": "./contracts/utility/NonFungibleToken.cdc", "aliases": { "emulator": "0xf8d6e0586b0a20c7", + "testing": "0x0000000000000007", + "previewnet": "0xb6763b4399a888c8", "mainnet": "0x1d7e57aa55817448", "testnet": "0x631e88ae7f1d7c20" } @@ -58,6 +85,8 @@ "source": "./contracts/utility/MetadataViews.cdc", "aliases": { "emulator": "0xf8d6e0586b0a20c7", + "testing": "0x0000000000000007", + "previewnet": "0xb6763b4399a888c8", "mainnet": "0x1d7e57aa55817448", "testnet": "0x631e88ae7f1d7c20" } @@ -88,6 +117,7 @@ "networks": { "emulator": "127.0.0.1:3569", "testing": "127.0.0.1:3569", + "previewnet": "access.previewnet.nodes.onflow.org:9000", "testnet": "access.devnet.nodes.onflow.org:9000", "mainnet": "access.mainnet.nodes.onflow.org:9000" }, @@ -109,4 +139,4 @@ ] } } -} \ No newline at end of file +} diff --git a/lib/go/contracts/contracts.go b/lib/go/contracts/contracts.go index d7fcccd9..d4918b0d 100644 --- a/lib/go/contracts/contracts.go +++ b/lib/go/contracts/contracts.go @@ -16,6 +16,14 @@ var ( placeholderExampleToken = regexp.MustCompile(`"ExampleToken"`) placeholderMetadataViews = regexp.MustCompile(`"MetadataViews"`) placeholderFTMetadataViews = regexp.MustCompile(`"FungibleTokenMetadataViews"`) + placeholderViewResolver = regexp.MustCompile(`"ViewResolver"`) + placeholderBurner = regexp.MustCompile(`"Burner"`) + exampleTokenImport = "ExampleToken from " + metadataViewsImport = "MetadataViews from " + ftMetadataViewsImport = "FungibleTokenMetadataViews from " + burnerImport = "Burner from " + fungibleTokenImport = "FungibleToken from " + viewResolverImport = "ViewResolver from " ) const ( @@ -23,23 +31,29 @@ const ( filenameExampleToken = "ExampleToken.cdc" filenameTokenForwarding = "utility/TokenForwarding.cdc" filenamePrivateForwarder = "utility/PrivateReceiverForwarder.cdc" - filenameFTMetadataViews = "FungibleTokenMetadataViews.cdc" filenameFTSwitchboard = "FungibleTokenSwitchboard.cdc" + filenameFTMetadataViews = "FungibleTokenMetadataViews.cdc" + filenameViewResolver = "utility/ViewResolver.cdc" + filenameBurner = "utility/Burner.cdc" ) -// FungibleToken returns the FungibleToken contract interface. -func FungibleToken() []byte { +// FungibleToken returns the FungibleToken contract. +func FungibleToken(resolverAddr, burnerAddr string) []byte { code := assets.MustAssetString(filenameFungibleToken) + code = placeholderViewResolver.ReplaceAllString(code, viewResolverImport+"0x"+resolverAddr) + code = placeholderBurner.ReplaceAllString(code, burnerImport+"0x"+burnerAddr) + return []byte(code) } // FungibleToken returns the FungibleToken contract interface. -func FungibleTokenMetadataViews(fungibleTokenAddr, metadataViewsAddr string) []byte { +func FungibleTokenMetadataViews(fungibleTokenAddr, metadataViewsAddr, viewResolverAddr string) []byte { code := assets.MustAssetString(filenameFTMetadataViews) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) - code = placeholderMetadataViews.ReplaceAllString(code, "0x"+metadataViewsAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) + code = placeholderMetadataViews.ReplaceAllString(code, metadataViewsImport+"0x"+metadataViewsAddr) + code = placeholderViewResolver.ReplaceAllString(code, viewResolverImport+"0x"+viewResolverAddr) return []byte(code) } @@ -48,20 +62,27 @@ func FungibleTokenMetadataViews(fungibleTokenAddr, metadataViewsAddr string) []b func FungibleTokenSwitchboard(fungibleTokenAddr string) []byte { code := assets.MustAssetString(filenameFTSwitchboard) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) return []byte(code) } -// ExampleToken returns the ExampleToken contract. +// ExampleToken returns the second version of the ExampleToken contract. // // The returned contract will import the FungibleToken interface from the specified address. func ExampleToken(fungibleTokenAddr, metadataViewsAddr, ftMetadataViewsAddr string) []byte { code := assets.MustAssetString(filenameExampleToken) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) - code = placeholderMetadataViews.ReplaceAllString(code, "0x"+metadataViewsAddr) - code = placeholderFTMetadataViews.ReplaceAllString(code, "0x"+ftMetadataViewsAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) + code = placeholderMetadataViews.ReplaceAllString(code, metadataViewsImport+"0x"+metadataViewsAddr) + code = placeholderFTMetadataViews.ReplaceAllString(code, ftMetadataViewsImport+"0x"+ftMetadataViewsAddr) + + return []byte(code) +} + +// Burner returns the Burner contract. +func Burner() []byte { + code := assets.MustAssetString(filenameBurner) return []byte(code) } @@ -78,9 +99,9 @@ func CustomToken(fungibleTokenAddr, code := assets.MustAssetString(filenameExampleToken) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) - code = placeholderMetadataViews.ReplaceAllString(code, "0x"+metadataViewsAddr) - code = placeholderFTMetadataViews.ReplaceAllString(code, "0x"+ftMetadataViewsAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) + code = placeholderMetadataViews.ReplaceAllString(code, metadataViewsImport+"0x"+metadataViewsAddr) + code = placeholderFTMetadataViews.ReplaceAllString(code, ftMetadataViewsImport+"0x"+ftMetadataViewsAddr) code = strings.ReplaceAll( code, @@ -109,7 +130,7 @@ func CustomToken(fungibleTokenAddr, func TokenForwarding(fungibleTokenAddr string) []byte { code := assets.MustAssetString(filenameTokenForwarding) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) return []byte(code) } @@ -120,7 +141,7 @@ func TokenForwarding(fungibleTokenAddr string) []byte { func CustomTokenForwarding(fungibleTokenAddr, tokenName, storageName string) []byte { code := assets.MustAssetString(filenameTokenForwarding) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) code = strings.ReplaceAll( code, @@ -140,15 +161,7 @@ func CustomTokenForwarding(fungibleTokenAddr, tokenName, storageName string) []b func PrivateReceiverForwarder(fungibleTokenAddr string) []byte { code := assets.MustAssetString(filenamePrivateForwarder) - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) - - return []byte(code) -} - -func MetadataViews(fungibleTokenAddr string) []byte { - code := assets.MustAssetString(filenamePrivateForwarder) - - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+fungibleTokenAddr) + code = placeholderFungibleToken.ReplaceAllString(code, fungibleTokenImport+"0x"+fungibleTokenAddr) return []byte(code) } diff --git a/lib/go/contracts/contracts_test.go b/lib/go/contracts/contracts_test.go index a64d6650..f87dec83 100644 --- a/lib/go/contracts/contracts_test.go +++ b/lib/go/contracts/contracts_test.go @@ -11,7 +11,7 @@ import ( const addrA = "0A" func TestFungibleTokenContract(t *testing.T) { - contract := contracts.FungibleToken() + contract := contracts.FungibleToken(addrA, addrA) assert.NotNil(t, contract) } diff --git a/lib/go/contracts/go.mod b/lib/go/contracts/go.mod index 0eb735a7..c80fcf0f 100644 --- a/lib/go/contracts/go.mod +++ b/lib/go/contracts/go.mod @@ -1,14 +1,16 @@ module github.com/onflow/flow-ft/lib/go/contracts -go 1.18 +go 1.19 require ( github.com/kevinburke/go-bindata v3.22.0+incompatible - github.com/stretchr/testify v1.6.1 + github.com/stretchr/testify v1.8.4 ) require ( - github.com/davecgh/go-spew v1.1.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/kr/pretty v0.3.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - gopkg.in/yaml.v3 v3.0.0 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/lib/go/contracts/go.sum b/lib/go/contracts/go.sum index 88306fae..6ab9870a 100644 --- a/lib/go/contracts/go.sum +++ b/lib/go/contracts/go.sum @@ -1,14 +1,24 @@ -github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/kevinburke/go-bindata v3.22.0+incompatible h1:/JmqEhIWQ7GRScV0WjX/0tqBrC5D21ALg0H0U/KZ/ts= github.com/kevinburke/go-bindata v3.22.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= -github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= -gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/lib/go/contracts/internal/assets/assets.go b/lib/go/contracts/internal/assets/assets.go index dd45a379..45ea51ce 100644 --- a/lib/go/contracts/internal/assets/assets.go +++ b/lib/go/contracts/internal/assets/assets.go @@ -1,13 +1,15 @@ // Code generated by go-bindata. DO NOT EDIT. // sources: -// ../../../contracts/ExampleToken.cdc (11.722kB) -// ../../../contracts/FungibleToken.cdc (9.721kB) -// ../../../contracts/FungibleTokenMetadataViews.cdc (7.241kB) -// ../../../contracts/FungibleTokenSwitchboard.cdc (17.536kB) -// ../../../contracts/utility/MetadataViews.cdc (26.322kB) -// ../../../contracts/utility/NonFungibleToken.cdc (4.828kB) -// ../../../contracts/utility/PrivateReceiverForwarder.cdc (2.592kB) -// ../../../contracts/utility/TokenForwarding.cdc (4.755kB) +// ../../../contracts/ExampleToken.cdc (9.718kB) +// ../../../contracts/FungibleToken.cdc (10.377kB) +// ../../../contracts/FungibleTokenMetadataViews.cdc (6.596kB) +// ../../../contracts/FungibleTokenSwitchboard.cdc (17.944kB) +// ../../../contracts/utility/Burner.cdc (1.997kB) +// ../../../contracts/utility/MetadataViews.cdc (25.493kB) +// ../../../contracts/utility/NonFungibleToken.cdc (10.577kB) +// ../../../contracts/utility/PrivateReceiverForwarder.cdc (2.845kB) +// ../../../contracts/utility/TokenForwarding.cdc (5.484kB) +// ../../../contracts/utility/ViewResolver.cdc (2.718kB) package assets @@ -77,7 +79,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _exampletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x5a\xeb\x6f\x1b\xb7\xb2\xff\xee\xbf\x62\xae\x2e\xd0\x2b\xa1\xb6\xec\xbe\x72\x5b\x21\x69\xe2\x9c\xc6\x38\x07\x68\x8b\xa0\x75\xdb\x0f\x45\x91\x50\xbb\x23\x89\xc7\xbb\xe4\x96\xe4\x4a\x56\x83\xfc\xef\x07\xc3\xc7\x2e\xb9\x0f\x49\x51\x7a\xf4\xc5\x96\x96\xf3\xe0\xcc\x6f\x66\xc8\x99\xe5\x65\x25\x95\x81\xc9\x5d\x2d\xd6\x7c\x59\xe0\xbd\x7c\x40\x31\xb9\x08\x3f\xff\x80\x86\xe5\xcc\xb0\x5f\x39\xee\x74\xfb\x73\xb2\xba\xb3\xe6\xa2\xaa\x97\x90\x49\x61\x14\xcb\x0c\xbc\x7a\x64\x65\xe5\x17\x2e\x20\xa1\x83\x77\x17\x17\x00\x00\xd7\xd7\xd7\x70\x2f\x0d\x2b\x40\xd7\x55\x55\xec\x41\xae\x12\x32\x0d\x5c\x00\x3e\x72\x6d\x50\x64\x68\x49\x48\xc4\x96\x29\x30\x44\xf6\xb3\xa5\x5a\xc0\x2f\x77\xfc\xf1\xc9\x97\x2d\xcf\x9f\x8d\x54\x6c\x8d\xc0\x44\x0e\xaf\xeb\x65\xc1\x33\x78\xcd\xcc\x46\x37\x1c\x0a\x34\xf0\x2b\xab\x0b\xe3\x57\xd2\xd3\x05\x44\x5f\xfa\x2b\x1d\x1f\xb7\xb0\xfd\x3f\x59\xf7\x13\x66\xc8\xb7\xa8\x4e\x58\x7a\x9b\x97\x5c\x8c\x0a\x6f\x8d\xb3\x41\xc0\x2d\x0a\x03\x66\xc3\x0c\x70\x0d\x58\x72\x63\x30\x87\xdd\x06\x05\x98\x0d\xb6\xf6\xe6\x1a\x32\x85\xcc\x60\xde\x48\x72\xa4\xce\x94\xff\x12\xdc\x70\x56\xf0\xbf\x30\x9f\x72\xf7\x7f\x6a\xbe\xd9\xe9\x62\x9d\x6f\x98\x42\xd8\x71\xb3\xc9\x15\xdb\x09\x58\x29\x59\x02\x73\xb6\x1a\x54\xe0\xb7\xb0\x74\xca\x4a\x59\x0b\x13\xe4\x5e\x5a\xd2\x05\xdc\xe6\xb9\x42\xad\x9f\x9f\xa5\x47\x8e\x95\xd4\x9c\x9e\x18\x79\x50\x8b\xef\xc2\xc2\x9e\x16\x46\x9e\xa3\x83\xc0\x5d\xac\x47\xc9\xc5\x98\x03\x7e\xb0\x8f\x3a\x62\xcf\xdc\xac\x36\x4a\xee\x47\xe4\xbc\xac\x95\xf8\x08\x39\xcc\x6e\xc9\xee\x43\x81\x42\x2d\x6b\x95\xe1\x38\xb8\xec\xae\xd4\x3f\xdc\xb3\x29\x2b\x0a\xb9\xc3\xfc\xf6\xa3\x64\x2f\x69\x03\xa7\xc8\xb6\x3b\x6d\x64\x47\x62\x5e\xb1\x6c\x03\xb5\x46\x05\xda\x48\x85\x1a\x98\x00\x2e\xb4\x61\x22\x43\xca\x31\x52\x14\x7b\x1b\x3c\x16\x27\x94\x64\xcc\x06\xb9\x5b\xcd\xd6\x98\xa8\xbb\xaa\x45\x66\xb8\x74\xb9\xa8\xa5\xa1\xd4\xb2\x96\x5b\x24\x5b\xc3\xd2\x71\xab\x94\x4b\x39\x95\xd4\x86\xe2\x32\xe7\x96\xb0\x61\xc7\x45\x27\x0d\x86\x20\xde\x5b\xb7\x66\xac\x28\x30\x9f\x27\xd2\xb3\x0d\x66\x0f\x1a\x36\xac\xaa\xc8\x3e\x06\x54\x2d\x0c\x2f\xd1\x92\xe2\x16\x15\xb0\x46\x43\x6b\xa8\x94\x47\xc3\xeb\x27\x6f\x4c\x5a\x21\xdc\xfe\x97\x18\xcc\x1a\x76\x46\xa9\x04\x1f\x0d\x59\x28\xc9\x2c\xd6\x57\xa4\x66\xc3\xce\xa1\x70\xc5\x85\x25\xbe\x04\x2d\xe9\xb9\xb2\xbe\x12\x12\x76\x6c\x0f\x2b\x49\xba\x95\xac\xe0\x19\x97\xb5\x76\xee\x30\xd2\xcb\x74\x56\x6c\x4d\x23\x6b\x2f\x96\x0b\x60\x5c\xcd\xe1\x16\x74\x85\x19\x67\x85\x47\x58\x0b\x07\x81\x98\x6b\xe2\xb4\x6c\x75\x30\xd2\x22\xb6\x61\xd7\x46\x65\x6a\x0a\xc2\x4e\xc3\xc8\xaa\xd0\xa9\x4c\xf3\xd7\x4a\x6e\x79\x8e\xea\xb2\xf3\x7b\xc8\xed\xdd\xdf\x5f\xb2\x82\x50\x75\x09\x49\x2d\x9c\x93\xbd\x0b\x72\x8f\xaf\x74\xb1\x4f\x6d\xe9\x82\xa5\x23\xf4\xbb\xd6\xb0\x6d\x52\x56\x5c\xe6\xfc\xaa\xb4\xc4\x05\x66\x6d\x4a\xb7\xfe\x0a\x1c\x09\x25\x61\x8f\xd6\xda\x84\x0d\x02\x4d\x43\x4c\xf9\x7f\xda\x61\x3d\x83\x77\xcd\x73\xfa\x68\x2c\x56\xf3\xc0\xf2\x59\x60\xde\x2c\x79\x9f\xaa\x72\x17\x30\xe8\xb0\xc2\x1e\x5c\xd0\xb9\x24\x04\xcc\x7d\x51\xeb\xba\x44\x61\x12\x42\x8a\x97\x50\x44\xb4\xa3\xf6\x44\xb6\xa0\x34\x01\x37\x4f\x77\x6e\x3c\x8e\xb4\xcf\x19\x06\xe9\x7c\xc2\xd4\xde\x87\x67\x48\x2f\xb5\x76\xe8\xd8\xc8\x22\x4f\x38\x10\xe3\x52\x0a\xdc\x37\x4b\x97\xc8\xc5\x1a\x8c\x62\x42\xaf\x50\x29\xcc\xe7\x24\x46\xa1\xa9\x95\xd0\x76\xbd\xc0\x5d\xb1\x4f\xb8\x84\x00\xf2\x42\x65\x12\x46\x96\xb1\x0b\x48\x0a\x10\x6e\x6c\xec\x2d\xa3\x62\x95\xf0\xc2\x42\xe3\x8e\x82\x28\xd9\x6a\xb2\xe4\x45\xc5\x14\x2b\x21\xa4\x76\x02\x93\x37\x16\xa1\xc8\x15\x08\x17\x18\x9d\xba\x4c\x6a\xa5\x00\xb3\xec\xdc\xe6\x2c\x1f\xb7\x83\x16\x37\x52\x18\xc6\x85\xb5\xc8\x26\x61\x57\x8b\x5c\x0f\x2a\x48\x90\x5d\xd5\xa2\x59\xdb\xad\x40\x0b\x78\x91\x86\x8e\x13\x79\x10\x75\xc9\xd7\x2b\xbf\xd9\x84\x80\xea\xc7\xe8\x01\xc3\xfd\x0d\x07\x0c\xcb\x4c\xee\x04\xaa\xe7\x73\xe6\x0a\xfd\x2c\xe1\xe5\xcd\xf1\xf4\x2a\xce\x51\x6d\x9c\x38\x6e\xb3\x0f\x0a\x01\x6f\x57\xb9\xfc\x37\x66\xdd\x38\xb0\xd8\x67\x79\x6a\x4e\xe0\x46\x37\x91\xec\x01\x95\xa4\x0a\x04\xbb\x05\x3d\x12\x16\x5c\x83\x2f\xc2\x44\xed\x4f\x0a\x96\x4c\x93\x48\xa7\xce\x12\x33\x56\x6b\x6c\xa3\x2b\xe1\xb2\x23\x35\xa3\x88\xa2\xd8\x41\x15\xa4\xfb\xb4\xda\x82\xe6\xff\x5a\x7d\x37\x2c\xdd\xcb\x12\x51\x10\x94\x74\x5d\x62\x6e\xb7\x6b\xab\xc4\x4a\xda\x6a\xe7\x63\xc1\x9f\x65\x8e\xa2\xde\x39\xf1\x38\x56\x2d\x42\x9d\x13\x76\xbc\x28\x46\x03\xae\x07\x5c\xbf\x6a\xea\x04\x0d\x81\xb5\x9b\x23\xe9\x24\x6f\xc3\x0a\x9e\x5e\xf9\x03\xb0\xfe\x1f\x78\x11\x5f\x61\xe6\xa9\x7d\x8f\x61\xfc\x53\xc7\x6f\xde\x4d\xb7\x1d\xa8\xf7\x4f\xb1\x09\x99\x3b\xcc\x1e\xc5\x7b\x42\x03\xcf\xe0\x66\x7e\x93\x3c\x0f\xe8\x49\x33\x47\x04\x7b\xbf\x60\xda\xb5\x0b\x5f\xa5\xbb\xfa\x96\x58\x77\xd6\xd0\x27\x31\x54\x74\xa3\x83\x67\xe3\x8f\xae\x12\xd6\x09\xcb\xf7\x63\xa1\x49\xa0\xa1\x33\x89\x5c\xc1\x1a\x8d\x21\xa4\xb0\xa2\xb0\x68\x09\x65\x1b\x6c\xdd\x06\x4e\x42\x29\x38\xdd\xa9\x2e\xd6\x62\x1c\x9f\x3e\x6f\xdc\x52\x68\x2b\x27\xe6\x7e\x5f\xa1\x76\xc7\x93\x80\xcb\x98\xf5\xd6\x1e\x12\xe0\xde\x15\xfe\xa2\xc6\x06\xaa\xb6\x60\x2d\xd3\x2a\xd3\x9a\x7b\x8b\x85\xac\x28\xf8\x8d\x84\x07\x21\x77\xb0\xdb\xf0\x6c\x03\x36\x40\xd0\xb8\x03\x56\xc5\xb4\x0e\x99\x43\xb9\x63\x08\xed\x6d\x3a\x83\x12\xcd\x46\x8e\x04\x5a\x08\x82\x35\x1a\x6b\x89\xe9\x6c\x01\xbf\xd3\x2e\xfe\xe8\xf8\xcd\x6f\xf6\xf7\x9e\x33\x69\xf1\xd3\xf1\xf6\xc0\xfc\xee\x9e\xfe\x7e\x3b\x9d\x5d\x9e\x41\xfa\x1d\xd7\x55\xc1\xf6\x67\x52\xdb\x18\xfc\x8e\x19\x76\x16\xfd\x7d\x8b\xbe\x6f\xa7\x69\x04\xfd\xf1\x21\x88\x4b\xb1\xd6\x1e\x79\xf1\x44\x98\xb9\x34\x48\xd0\x71\x69\x90\xf4\x0e\x1c\x72\xd4\x5c\x79\x60\xcd\x87\xd1\x09\xda\xa8\x3a\x33\xb5\x22\x58\x54\x0a\xa9\x1e\x04\x6c\x2a\xfc\xb3\x46\x6d\x86\x18\xf4\x10\x12\x63\xea\x4d\x50\x67\x5f\xe1\x6c\x01\xb7\x62\xff\xb3\x15\xf2\xbc\x5b\xd6\x77\xdc\x64\x1b\xbb\x78\x20\x0d\x64\x4c\xe3\xe9\xf0\x59\xf4\xe8\xa1\x85\xe5\x51\x06\xd3\x41\x6a\xfa\xac\x8c\x07\x99\xcf\x9c\xf1\x3e\x3f\x04\xa0\x33\x5b\x04\x4e\x59\xfc\xbc\x8f\xc5\x56\x99\x06\xb3\x67\xa9\x13\x23\xfe\x04\x85\x9a\xe5\xcf\x07\x35\x9a\x9d\xeb\xb2\xd6\x2a\xc3\x5e\xa3\x02\x5a\x62\xce\x19\x3c\xeb\x5c\xa0\x7e\xa0\x5f\x0f\x38\x8b\x17\xb8\xe8\x90\xfc\xf3\xfe\xfe\xf5\x1d\x2f\x70\x9c\x8a\x3e\xb5\x2a\x16\x30\xd9\x18\x53\xe9\xc5\xf5\x35\xd3\x1a\x8d\x9e\xef\x70\x49\xe5\xf4\x8a\xd8\xea\x79\x26\xcb\xeb\xaf\x56\x4f\x3e\xff\xe6\xcb\xec\x26\xfb\x7f\xf6\x75\x96\xe7\x4f\xbe\xfc\x62\xf9\x59\xf6\xf5\xe7\x37\x9d\x07\xec\xab\xaf\xb2\xe5\x67\xd9\x37\x5f\x3c\x79\x73\x57\xc8\xdd\x9b\xdf\xa4\xca\x4b\xa6\x1e\xe6\x7a\xbb\x9e\x8c\xea\x31\x90\x84\xc2\xc7\x5a\x83\x0c\xbb\x80\x09\x2f\xd9\x1a\xaf\xf5\x76\xfd\xe9\x63\x59\x0c\x73\xeb\x7b\x26\x31\xab\x1e\xb6\xab\x9e\xfe\x6e\x1f\xff\x31\x4c\x7e\x4a\x2c\x79\xcf\x8e\xdb\x5a\xb0\x92\xf6\xe0\x53\x5b\xc3\xcc\x1d\x60\x26\xe3\x06\xd0\xfb\x72\x29\xc9\x45\xaf\xee\xee\x0f\x2c\xcb\x51\x67\x8a\x57\x74\xe0\x5e\xc0\xc4\x16\xd2\x55\x10\x61\x8f\xa8\xcd\xed\xcf\x1d\xba\xd1\xeb\x41\x77\x41\x2c\x2a\xd8\xcb\x3a\xd4\x53\xfa\x5f\x81\xa0\x2b\xdb\xdd\x3d\xfc\xaf\x14\xe4\xc9\xf9\x01\xd9\xf8\x68\x50\x09\x56\xfc\xf2\xd3\xf7\x5d\x0c\xbe\x6a\x1f\x4d\x1b\x90\x79\xd9\x57\x2b\x33\x97\x62\x45\xcc\xa5\x5a\x4f\x0e\x80\xa0\x90\x6b\xa9\x17\xde\x85\x07\x4c\x25\x33\xce\x0a\xbd\x18\x48\xa9\xf1\x67\x62\x76\xdc\x18\x54\x93\x93\x94\xf5\x8b\x6d\x10\x90\xae\x6f\x96\x85\xcc\x1e\xb2\x0d\xe3\x62\x32\x0c\x17\x48\x8e\x5e\xf1\xe7\xec\xbc\x11\xa7\xaf\x8f\xc8\xf7\x81\xcb\x38\x4a\x75\xdc\x82\xef\x9f\xdb\xa3\xa6\xfc\xb8\x1b\x54\x68\xfb\xf7\x99\xf4\x27\x02\x87\x22\xdf\x69\x3f\xa6\xcb\x29\x3c\x2a\xdf\xbd\x72\x3c\xae\x2b\xc5\xb7\xcc\x60\x00\xa0\x65\x66\x79\x1d\xdf\xcc\xf7\x5c\x3c\x60\xee\x12\x91\xf5\xd7\x27\x7d\x8d\xde\x0d\xb7\xc8\xde\x0f\x9e\xb2\xba\xdb\x3c\x43\xc0\x91\x5e\xdb\x61\xb9\xc1\x34\x67\xc8\x0d\x3d\xc1\xc3\x02\x5c\xd3\xe0\x55\x59\x99\xbd\x65\x12\xfa\x01\x0b\x98\xd2\xb1\x89\x0e\xd4\x03\x37\xc3\x23\xb1\xdb\xb4\x24\x12\xca\xae\xa8\xe9\x81\xc0\x1c\x7e\x74\x66\x64\xa6\x47\xe1\x73\x23\x33\xe2\x32\x4d\xe6\x78\x63\x97\xbe\xd9\xc8\x35\x2f\x12\x27\x78\x71\x91\x2e\x78\xdf\xce\x03\xd2\xd6\x4c\xda\x39\x74\x5e\xd8\x71\xb3\x01\x16\x77\x5a\xfe\x42\x25\xdb\x7e\xb7\xc8\x9b\x4e\x20\x6f\x1b\x7d\xac\x28\xe8\x04\xed\x1b\x7e\x73\xb8\x75\x5d\xee\xb2\xd6\xae\xf1\xe7\x3a\xbb\xa1\x3f\x9f\x70\xb3\x83\x09\x7f\xf6\x36\x76\x62\x33\x32\x8c\xa0\x1f\xa4\xca\xdd\xdd\xce\xb6\x76\xdc\xf3\x96\x5b\x96\xd9\x16\xa0\x6b\xfc\x31\x57\x00\x43\x1c\x87\xa6\x86\x6e\xfa\xcc\xae\x38\x9a\x7d\x85\xfd\x29\x41\xdc\x10\x6c\x6d\x13\x1a\x2d\xbd\x4e\x3a\xc1\xba\x0f\xc5\x05\xbc\xe8\x22\xfb\x48\x63\xed\x66\x7e\x33\x8b\x5d\x96\x74\xe9\xed\xa4\x94\x6b\xa3\x98\x91\xbd\x76\xfa\x88\x63\x23\x6f\x0d\x8e\xb3\x8e\x36\x58\xd3\x31\x16\x99\xa3\x64\x8f\xbc\xac\x4b\xf8\xb3\x66\xc2\x70\xb3\x8f\x3b\xae\x7e\x3c\x12\xa4\x64\xb2\x2e\x72\xaf\xcc\x68\xbf\xb5\x3b\xd5\x70\xfd\x2a\x4b\xe9\x9d\xec\x46\x1a\x5e\xc8\xc1\x1b\x99\x13\xf5\x23\xee\x1c\xd3\x91\x29\xdc\x02\x5e\x78\xa1\xef\xfa\x6d\xa5\x83\x63\xbc\xe4\xeb\xe1\x96\xe9\xb0\x06\x23\x0c\x0e\x36\x50\xc7\x9d\xd9\x99\x0f\x1e\xed\xcb\x90\xb9\x5f\x9e\x40\xd3\x33\xa7\x23\xb2\x88\xf6\xf4\x03\x96\xeb\x0e\x21\x0f\x59\x27\x30\x1c\xcf\x54\x61\x4e\x17\x3a\xc6\x0e\x5b\x36\x64\x19\x05\x42\x88\x76\x37\xc7\xdb\xc8\xa2\x99\x7d\x9d\x36\xf3\x6a\x10\xd0\xeb\x56\xf4\x07\x09\x1d\x58\xa7\x9d\xe5\x66\xdc\x06\xd1\xb4\x6a\x10\x78\x87\x9c\x4c\x5c\x74\xa4\xf9\xa5\xed\x87\x93\xd4\x32\x24\x59\x13\xbd\x1f\x72\x99\xb0\x8a\x91\x11\x53\x74\xd3\xf2\x87\x8c\x53\x86\xc2\xbb\xb3\xd9\x0f\x9b\x9c\xb8\x17\x02\x4e\x89\x62\x5a\xe9\xba\xbb\x03\x93\x93\xa3\x07\x87\x4a\xe1\xc0\x51\xc2\x3b\xd5\xf6\x5f\x17\x30\x71\x8e\x09\x3a\xd9\x32\xb5\x44\x58\x5b\x70\x2a\xf2\x88\xb0\x65\xaf\x7f\xd5\xf4\x7c\x9e\xfa\x6e\x75\xc7\xcf\x23\x7c\x0b\xd4\xda\x31\x25\x43\x04\xec\x38\x56\x93\x03\x15\xfd\x9c\xae\xf0\xa7\x43\xb3\xa1\xbe\xae\x30\xb4\x81\xa3\x83\xa5\xce\x9b\x1b\xdd\x39\x10\x7c\xd4\xe8\xc8\xce\x62\x87\x33\xf6\xd0\x6c\xac\xbb\x9d\xe4\xfb\xdf\x9d\x57\x28\xd3\x1e\xcf\x29\x4d\x6e\x3c\x10\xe8\x7e\x52\xd0\x4e\xc4\xc2\xeb\x18\x97\x80\xab\x15\x66\x86\x6f\xb1\xd8\x5b\x81\x21\x72\x62\xb9\xdd\x98\x21\x01\x3f\x4a\x83\x0b\x37\x1f\x73\xe7\xa7\xe8\x0d\x19\x56\x1b\x59\x32\xc3\x29\x15\xec\x41\xd7\x4b\xfb\x22\x03\xe6\xcd\x34\x34\xe1\x14\xa7\x98\xf4\x2d\x0f\xab\x76\x9d\x19\xa9\xfe\xb6\xf1\x54\x34\xa6\xad\xd5\x70\xb7\x37\x64\x04\x5a\xe0\x33\xc2\x7f\x7b\x26\x45\x54\x2c\x60\x6a\x7c\x04\x35\x3c\x11\xea\x84\x4b\xe7\x05\xa4\x3e\xf6\x23\x6c\x5a\xf4\xc7\x5b\xb0\x20\x4f\x83\xfe\xb3\x9b\x9b\x78\x32\x65\x57\x74\x6f\xe7\xf0\x0c\xae\xfd\x81\xb9\x7f\xdb\x1d\x20\x6d\x2f\xd3\x44\x59\xd9\x6f\x09\x61\xb8\xb1\xa4\xb4\xfd\xfb\xfc\x08\x79\x58\x98\x92\x77\xdf\xfa\x1b\xd3\xda\xae\x8b\xc3\x09\xdc\xf9\x22\x42\xa6\xbd\xb0\x74\xeb\x63\x54\xb5\xec\x1d\x83\x6d\x91\xae\x2b\x5c\x84\xcb\x44\x8b\xe2\x04\x26\xc3\x49\xab\xeb\x8a\x59\xba\x19\x9f\x31\xe6\x24\x65\xfa\xf4\xca\x32\x8b\x06\x8f\x5d\x0f\xcd\x86\xf6\xc3\xc0\xd9\x0e\x32\x56\xb1\x25\x2f\xa8\xf2\xfa\x2a\x6e\x2f\x48\x79\xfc\x3a\x07\x3e\x56\x52\x63\x5c\x44\xed\xc2\xb7\xfe\x8a\xf3\xd6\xcf\xb7\xc0\x6c\x94\xac\xd7\xce\x3a\x6f\x83\x23\xde\x82\x3d\xc5\xac\x58\x16\x19\x21\xd9\x47\xc1\xc5\xc3\xd3\x4f\xc6\x7b\x1a\xfd\x5c\x7c\xac\xbb\x63\x98\x5a\xa3\x19\xb1\x47\xb3\xf2\xe3\x0d\x63\x5f\xe7\x1a\xb3\x8e\x77\xe7\x5b\x58\x71\x2c\x9a\x21\x3c\xbc\x8d\xe6\x09\xc3\x96\x7b\x19\x08\x1b\xc3\x1d\xb2\xdb\xa9\xcd\x9b\x41\x43\x1e\xec\x6f\x7d\xb0\x15\x6d\x2e\xb3\x45\xad\x85\x76\x72\x8b\x9c\x1e\x46\xb2\xa5\x8d\x90\xdc\x8d\xda\xd4\x61\xaf\x28\xf1\x31\x11\xbf\xd6\xa8\x37\x72\x17\x9d\x9f\x9b\xf7\xe8\x76\x4c\x03\x6f\x5f\xc3\x6d\xb8\x44\xb9\xf3\xc0\x5b\xba\xc3\xe1\xf8\xfe\xe2\xfd\xc5\x7f\x02\x00\x00\xff\xff\x3a\xeb\x72\x04\xca\x2d\x00\x00" +var _exampletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x5a\x5f\x6f\x1b\x37\x12\x7f\xf7\xa7\x98\xea\x80\x3b\x09\xb5\x65\xa7\x4d\x72\xad\x10\xc7\x75\xd2\x18\x77\x40\x03\x04\x89\x9b\x3e\x04\x41\x4c\xed\x8e\xb4\x3c\x73\xc9\x05\xc9\x95\xac\x1a\xf9\xee\x87\xe1\x9f\xd5\x72\xb5\x6b\xcb\x6e\x0e\x38\x3d\x34\xd6\x2e\x67\x38\x9c\xf9\xcd\x6f\x66\xa8\xf2\xb2\x52\xda\xc2\xe8\xa2\x96\x4b\x3e\x17\x78\xa9\xae\x51\x8e\x0e\xe2\xe3\xb7\x68\x59\xce\x2c\xfb\xc8\x71\x6d\xb6\x8f\x93\xd5\x9d\x35\x07\x2c\xcb\xd0\x98\x31\x13\x62\x02\x99\x92\x56\xb3\xcc\xc2\x9b\x1b\x56\x56\x41\x60\x06\x89\x3c\xdc\x1e\x1c\x00\x00\x1c\x1f\x1f\xc3\x65\x81\x80\x2b\x94\x16\x6c\xc1\x2c\x70\x03\x58\x72\x6b\x31\x87\x75\x81\x12\x24\xae\xc1\x92\x8c\x01\xa6\x11\x4a\x2e\x2d\xe6\x4e\xb8\xbd\xa9\x57\xe0\x74\x9b\xb7\x6e\xc9\x98\x95\xaa\x96\x76\x06\xbf\x5f\xf0\x9b\xe7\x4f\x0f\xc1\x6e\x2a\x9c\xc1\x07\xab\xb9\x5c\x4e\x5a\xdb\x2b\xcb\x04\x98\xba\xaa\xc4\x06\xd4\x22\xb1\xda\x00\x97\x80\x37\xdc\x58\x94\x19\xee\x6c\xba\x62\x1a\x2c\x89\x7f\x70\xd2\x71\xab\xad\xee\x0f\x56\x69\xb6\x44\x60\x32\x87\x77\xf5\x5c\xf0\x0c\xde\x31\x5b\x98\x1d\x4d\x02\x2d\x7c\x64\xb5\xb0\x41\x82\x56\xcd\xa0\xf5\x65\x58\xc2\xeb\xf5\x02\xdb\xbf\x7b\xd7\xbf\xc7\x0c\xf9\x0a\xf5\x03\x44\xce\xf3\x92\xcb\x41\xa3\x76\x3d\xc2\x71\x0d\x8b\x5a\xc2\x12\xed\xeb\x80\x03\x87\x91\xb1\x46\xa3\x6a\x9d\xe1\xa5\x8b\x02\xfd\xf7\x6c\x32\x83\x4f\xf4\xc7\x67\xb8\x75\x8a\xe8\xa3\xd1\xd6\x5a\xc2\xa7\xe6\x01\x7d\x68\xd1\x8b\x61\xfc\x4d\x2f\x2e\xe9\xdf\x97\xe3\xc9\xe1\x03\xc5\x7e\xe5\xa6\x12\x6c\xf3\x08\x49\xe7\xfa\x5f\x99\x65\x0f\x96\xbd\xdc\x02\xe6\xe5\x78\xd2\x88\x7e\x76\x7f\x7d\xdd\x75\x29\x79\x93\x9c\x27\x56\xd8\xf6\x68\x9f\x43\x0f\x9d\xff\xb7\x0f\x26\x33\x38\x97\x9b\x0f\x56\xd7\x99\x3d\x6b\x39\xd9\xac\xb9\xcd\x8a\x66\x71\xeb\x0d\x7d\x32\x66\x70\x7f\x97\xcf\x12\xd9\x56\x08\xef\x15\x1e\xef\x48\xd2\x67\x61\x43\x50\x66\x60\x50\x2c\xa6\xf7\x1f\x5d\x72\xd1\x3d\xf8\xbe\x51\x9f\x00\x33\xdf\xdd\x6d\x69\x58\x7c\x76\x38\x60\x6d\x03\x84\xff\x9d\xbd\x6d\xac\xed\x61\x71\xb3\xfc\x6c\xc7\xe4\xc9\x63\x02\xbd\x75\xd7\x6e\xac\x89\x22\x4a\xcc\x39\x83\x53\x48\xe5\xde\xd2\xd3\xfe\x10\x3b\xc7\x71\x81\xb3\x8e\xc8\xbf\x2e\x2f\xdf\x5d\x70\x81\xc3\x52\xb5\x16\x33\x18\x15\xd6\x56\x66\x76\x7c\xcc\x8c\x41\x6b\xa6\x6b\x9c\x1b\x6e\xf1\x88\x54\x9a\x69\xa6\xca\xe3\x67\x8b\xe7\x3f\xfc\xfc\x34\x3b\xc9\xfe\xc9\x7e\xca\xf2\xfc\xf9\xd3\x1f\xe7\x4f\xb2\x9f\x7e\x38\xe9\xbc\x60\xcf\x9e\x65\xf3\x27\xd9\xcf\x3f\x3e\xff\x72\x21\xd4\xfa\xcb\x1f\x4a\xe7\x25\xd3\xd7\x53\xb3\x5a\x8e\x7a\x6d\x98\xf4\xa3\xc0\x79\xc0\x47\x73\xc4\x4b\xb6\xc4\x63\xb3\x5a\x7e\x7f\x53\x8a\x5d\x2d\x93\x61\x17\x9a\x7e\x1f\x9a\xf1\x27\xf7\xfa\xf3\xae\xe8\x3e\x99\x16\xa2\xd7\xef\x53\xc9\x4a\xb2\x39\x94\xbc\x46\x91\xaf\xa3\xa3\xfe\xc3\x9a\x4d\x39\x57\x14\x86\x37\x17\x97\x03\x4b\x72\x34\x99\xe6\x95\xe5\x4a\xce\x60\x74\x59\x70\x43\x2c\xe6\x55\xbb\x52\x4e\x45\xbe\x36\x98\x03\x33\xc0\xa8\xc2\xfa\xfd\xad\x82\x02\x45\x05\x1b\x55\x43\x8e\x2b\x14\xca\xfd\xad\x41\xe2\x8d\x85\x8b\x4b\xf8\x9b\x92\x14\xa9\xe9\xc0\xbe\x78\x63\x51\x4b\x26\x7e\x7f\xff\x5b\x17\x5b\x6f\xb6\xaf\xc6\x0d\x80\xc2\xbe\x47\x0b\x3b\x55\x72\x41\x8a\x95\x5e\x8e\x06\x82\x2c\xd4\x52\x99\x59\x08\xd5\x80\x6b\x54\xc6\x99\x30\xb3\x0e\xa1\xb6\x3f\x23\xbb\xa6\xde\x46\x8f\xf6\x32\x30\x2c\x76\xa0\x26\xfb\xbe\xcc\x85\xca\xae\xb3\x82\x71\x39\xda\x85\x03\xb8\x02\xd2\x7d\xf2\xa8\x9c\x6f\x53\xce\x23\x19\x3e\x6a\xe8\x47\x9e\x69\xb7\x14\x8e\x38\xbb\xed\x4f\xbf\x8b\x75\x6c\x61\xb6\x82\xbb\x5d\xcd\x50\x96\x7a\x0b\xbb\x7b\xde\x27\x17\xb7\xfc\x8d\xcb\x6b\xcc\x5b\xa4\xfd\xf7\x76\xab\xe8\x75\xed\x74\x03\xdd\xcd\xff\x92\x92\x4c\x23\xb3\xf8\xa6\xac\xec\xc6\x2d\xbc\xa8\x65\xe6\x93\x6c\xbc\xa8\xe5\x78\x32\x83\x5f\x6e\x93\xa0\x78\x7d\x5f\xef\xc0\x63\x08\xe5\x8b\xa3\xc4\x8c\xee\x46\xe3\x15\xfd\xb7\x65\xf5\x2f\xbd\x56\x0f\x40\x72\xf7\xf1\x23\x30\x99\xb6\x4d\x8f\xc1\x64\x4b\x43\x3f\x26\x93\x56\x3e\x39\x60\xeb\xcd\x1d\x67\xf9\xda\xed\x62\x25\x17\xed\xae\x8e\x26\x02\xe7\xaa\xf8\xad\x79\xfa\x86\x65\x05\x11\xa2\x76\x79\x81\x8e\x14\xb9\x34\x96\xc9\x0c\x69\x26\x51\x52\x6c\xc0\x16\xe8\xc5\x69\x28\xb1\x05\x72\x1d\xb3\x28\x19\xa5\x16\x01\x14\x26\x2c\x0b\x32\x34\x82\x2c\xd5\x0a\xb5\xc4\x1c\xe6\x5e\x5b\xa5\xfd\x68\x52\x29\x63\x69\x6c\xcb\xb9\x13\x6c\xd4\xf1\x8e\x3f\xfd\x40\x66\x0b\xdc\xb8\x51\x2c\x63\x42\x60\x3e\x4d\x76\xcf\x0a\xcc\xae\x0d\x14\xac\xaa\x50\x02\xb3\xa0\x6b\x69\x79\x89\x4e\x14\x57\xa8\x81\x35\x16\x52\x15\xe8\xe8\x68\x74\xbd\x0f\x2d\x13\xad\x90\xfe\xfc\x73\x0c\x09\x90\xc7\x93\xd1\xa4\x49\x95\x41\x2d\x9a\xaf\x6e\xf0\x74\x73\x24\x99\xd9\xa8\x23\x73\x73\x5c\x70\xe9\x84\x0f\xc1\x28\x7a\xaf\x91\x4c\x90\x0a\xd6\x6c\x03\x0b\x45\xb6\x95\x4c\xf0\x8c\xab\xda\xf8\x70\x58\x15\xf6\xf4\x5e\xdc\xba\x46\xd5\x61\x5b\x2e\x81\x71\x3d\x85\x73\x30\x15\x12\xfd\x83\x1b\x3f\x35\xc4\xa6\x0f\x24\x62\x6e\x48\xd3\x7c\x6b\x83\x55\x6e\x90\x6d\xd4\x6d\x87\xdc\xd4\x15\xed\x41\xa0\x51\xe8\x4c\xe9\x0c\xd4\x3e\x07\xe3\x58\xdd\x8e\x88\xc3\x2e\xcc\x99\x88\x60\xb2\x54\x8f\x57\x0d\x0e\xbb\xdb\xd0\x50\x1b\x56\xa7\x03\xad\x57\x0a\x5c\x72\xcb\x99\xe0\x7f\xa2\x73\x7a\x54\x4c\xa1\x8e\x06\x3a\x97\x51\x80\x29\xf2\x8d\x2c\x09\x8e\x3b\x9a\x27\x1d\x6a\x72\xac\x1c\x55\x9e\x46\xe5\xad\x0c\x4b\x8e\xf7\xda\x81\xc7\xa3\x92\xf5\xb4\x18\xf3\xda\xa1\x7d\xc5\x99\x33\xf5\xea\x15\x7d\xd7\x53\x7a\x3c\x9e\x5c\x11\x27\x17\x2a\xef\x3a\x21\xa2\xc8\x4f\x5e\xb4\x96\xb6\x99\xb3\xec\x7a\xdc\xb5\x96\x2f\x52\x83\x5f\xc2\xc9\xf4\xa4\x87\x6c\x87\xb8\x04\x4e\x87\x5f\x1d\x25\xaa\x13\x95\x5f\xef\x72\xd9\xc9\xf4\xa4\xcf\x5d\x43\x43\xba\x1f\xce\xfb\x26\xf1\x16\x8f\x25\x46\xde\x33\xd9\x4b\x2e\x26\xf7\x19\xd0\x1a\x69\xdd\x7c\xf4\xc5\x99\x74\xf7\xcc\x3a\x64\xce\x83\xe7\x2d\xfa\xab\xd7\x42\x42\xd4\x12\x2d\xf9\x5f\x69\x8b\xf9\xc7\x58\xf3\x0c\x28\xd7\xcb\x32\x21\x36\xc1\x06\x03\x0c\x04\x37\x8e\x03\x5c\x2a\xb9\xdb\x25\x13\x99\x87\x9b\xa6\x6b\x70\x07\xaf\x02\x73\xdc\x15\x89\x9e\x7d\x29\x2e\xb7\xde\xea\x57\x4a\x89\x6e\x1d\xa7\xc9\xc1\x44\x29\x27\xd0\x59\x7e\x0a\xb7\x1d\xac\x24\xab\x3f\x39\xe8\x2c\xd1\x6d\x36\x9e\x7c\x86\x53\xb0\xba\xc6\x3e\x97\xa7\x82\x7b\x03\x8c\x9b\xdd\x53\x8d\x6d\xfb\x7e\x82\x0c\xed\x8f\x72\x34\xae\xd7\x2f\x9f\xac\x43\xeb\xd9\x19\x2c\x98\x30\x83\x04\x71\x6e\xae\x0d\x65\x29\x65\xbf\xbf\x0e\x74\xe5\x64\x8e\xb0\xe6\xb6\xc8\x35\x5b\x4b\x58\x68\x55\xde\xcb\x89\xdb\x03\x9d\xaf\x18\x17\xcc\xd1\xee\x1f\x41\x47\xe7\xa6\xf1\xce\x53\x05\x2b\x5e\x9c\xf6\xa7\x77\xc7\xfe\x68\x65\xfb\x61\xb2\x20\x76\x80\x01\x78\xec\xda\xf7\x0e\x61\x17\x3f\x5d\x31\xbd\xac\x4b\x94\x36\x11\xa4\xb2\x1f\xb5\x07\xd8\x06\xa1\xe0\x8f\x50\x66\xa6\x83\x5b\xff\xdb\x86\xd2\x48\xb9\xe0\xea\x17\x96\x95\xd2\x4c\x6f\x42\xc7\x11\x6f\x73\xdd\xa0\x47\xa3\x9d\x12\x79\xa2\xc1\x16\x18\x6f\x76\xbd\x01\x1a\x61\x8e\x5c\x2e\xc1\x6a\x26\xcd\x02\xb5\xc6\x7c\x4a\x1b\xc5\xa4\x23\x09\x89\xeb\x56\x17\x46\x7a\x62\x57\x10\xb6\x55\x49\x6f\xe0\x34\xfb\x2e\x83\xaa\x3e\x6f\x10\x90\x63\xa5\x0c\x8f\x77\xc9\x51\x17\x0a\x83\x6b\xea\x0c\xfa\x0f\x1e\x40\x91\x96\xde\x88\x03\x4f\x6c\xeb\x41\x54\xf4\x34\xcd\x77\x97\xbf\xe4\xeb\x51\x08\x50\x1f\xaa\x5e\x1c\xb5\xbb\x94\x6d\x91\xf5\x12\x83\x6c\x17\x5c\xf0\x30\x74\x05\x37\xab\xf9\x7f\x30\xeb\x42\xcc\xc1\x8a\xe5\xb9\x49\xd4\x70\x6b\x9a\x36\x21\x44\x27\x69\x47\x10\xd4\x5a\xa2\x36\x7b\x20\x8e\x1b\x60\x42\xa8\xb5\x47\x54\x8e\xc6\x6a\xe5\x7b\x59\x43\xdb\x7b\xd3\xe6\x98\xb1\xda\xe0\x16\xc4\x69\x4e\x91\xc9\x2d\xb0\x12\x2c\x51\x47\x4b\x42\x13\xe6\x3a\x27\x27\xfb\x8f\xad\xed\x05\x4b\xcf\x35\x47\x94\x84\x33\x53\x97\x98\xbb\xa3\xbb\x9e\x72\xa1\x5c\x6f\x1c\x40\xe6\x2c\x8c\x1d\xee\x00\x9c\x9a\xa2\x18\x02\x32\xa6\x1c\x1c\x1a\xe6\xba\x4d\x08\x55\x01\x5f\x82\x5e\x1c\xf9\xe4\x65\xe6\xbb\x3e\xac\xed\x8d\xb4\xef\xbd\xbe\xde\xde\x23\x79\xd3\x69\x37\xc0\x5f\xfd\xb8\x90\xa4\x5c\xda\xc1\x5d\x77\xbc\xdc\x13\x80\x29\xdd\xf8\x58\x53\xb6\x01\x6b\xe3\xe9\x4f\xd4\x6a\x87\xea\x22\x81\xf0\x2d\x3f\x30\x21\x88\x6a\x02\x4f\x50\x03\xef\x3a\xfe\xb2\x36\x9e\x2f\x7c\x4d\x88\xb3\xca\x8e\x46\x37\xa8\x39\x4d\x5e\x77\xc3\x3f\xdd\xe1\x8c\x1e\x28\x9d\xfb\x61\xc2\x81\xd7\xbf\x4f\x35\x66\x99\x23\x5f\x3f\x25\x30\xdf\xc5\xc6\x1e\x22\xc2\xc2\x34\xdd\xbb\xef\x70\xa9\x06\xee\x87\xab\x9d\x79\x7e\x2f\x36\xba\x87\x5c\x4e\xa6\x27\xdd\xd9\xb7\x35\xe8\xfa\x29\x68\x70\xae\x8b\xfc\xe1\x99\xc5\x1d\x87\xe5\x25\x0d\x53\xde\x13\x7e\xee\xa3\xdc\x8c\xb3\xd2\xc3\x66\xa4\x30\x84\xdd\x26\x5e\x26\x35\xfe\x77\xbd\x3d\x11\x47\x02\xa6\xb5\xf1\xa1\x23\x37\x8a\x5f\x19\x71\x64\x5b\x3f\x1f\x1e\x0e\xe2\xae\x2d\xd1\x45\xde\x5e\x11\xdc\x9a\xfe\x98\xba\xf2\x98\x01\xe4\xfb\xbe\x7a\xd3\x26\x9b\xfd\x4a\x0e\x7d\xb0\xe4\x03\xbf\xcd\xfa\x7f\xe3\x6f\xb3\x9e\x5c\x9a\x86\x74\xca\x73\x94\x96\x2f\x38\xea\x49\x3f\x30\xbb\x2c\xd3\xc1\x60\x2f\xcf\xb4\xd1\xf8\x97\xf8\xe5\xdb\x72\xcb\xb7\xe5\x95\x6f\xc0\x29\x7d\xe9\xd5\xcb\x25\x9d\xbb\xc1\x7b\x01\xd9\x44\x0f\xee\xe1\x95\x10\x49\x77\x6f\xd0\xae\x7a\xae\x58\xa5\x28\x7e\x72\x72\x42\x95\x28\x5d\xd2\xbd\x51\x86\x53\x38\x0e\xce\x8b\x57\xff\xce\xc2\xb4\x06\xf5\x5d\x0c\x93\x64\xe5\xbe\xdd\x27\xb8\x7b\x19\x3d\x20\x1b\x17\xa6\xe2\xdd\x9f\xdb\x87\x4c\x76\xeb\x20\xb9\x97\x79\xed\x9d\xb9\xbd\xf1\x73\xd0\xed\x52\x94\x0b\x77\xf8\xbf\x29\x08\x6d\x6c\x85\x04\x5c\x2e\x93\xbb\x44\xaf\xf2\xa0\x2f\xeb\x07\x82\xd6\x8d\xc9\x36\x61\x87\x93\x3f\xe9\x25\xf6\xe1\x80\x9e\xe3\x32\xf0\xbe\x85\x8c\x55\x6c\xce\x05\xb7\x9b\x98\x85\x2e\x93\xf2\xf6\x30\x82\x37\x95\x32\xd8\x26\x7f\x7f\x2f\x14\x72\x21\xde\x08\xf9\xbb\x52\xb4\xe7\x6e\x72\x0f\x33\x6f\x7c\x67\x0b\xad\xea\xa5\x77\xec\x55\x0c\xe2\x15\xb8\x72\xb3\x60\x59\xdb\x7f\xb1\x25\x84\xab\x70\xc6\xab\x5e\x25\xaf\xe2\xcb\x3e\x1d\x49\x0c\xda\x08\x78\xcd\xaa\xd8\xb7\x85\x44\x9f\x36\x2e\xe0\x68\xa6\x21\x9c\x53\x6e\x4c\x3d\xf0\x2b\x43\x6f\x92\x4c\x52\x40\xf6\xea\x76\x2e\x37\xc5\xb8\x63\xcf\x21\x30\xdb\xff\xc3\xca\x24\x39\x46\xbc\x1a\xf9\x7f\x38\x42\xcb\x96\x96\xf9\xbb\x59\x3c\x39\xe8\x57\x1a\x6d\xa4\x44\x1a\x87\x82\x74\x08\x56\xcd\xee\xa0\x9a\x96\x2e\x72\x87\xef\x7b\xb6\x99\xe5\x5b\x97\xf1\xc0\x29\x3a\x1b\x3a\x61\xbf\x61\x2f\x81\x44\x26\xfd\x7a\xf0\xdf\x00\x00\x00\xff\xff\x9d\x72\xd1\xe7\xf6\x25\x00\x00" func exampletokenCdcBytes() ([]byte, error) { return bindataRead( @@ -93,11 +95,11 @@ func exampletokenCdc() (*asset, error) { } info := bindataFileInfo{name: "ExampleToken.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3a, 0x3d, 0xc4, 0x3a, 0x3e, 0xb, 0x4b, 0x81, 0x28, 0x22, 0xed, 0xcf, 0x52, 0x58, 0xcf, 0xa1, 0x1a, 0x98, 0x1e, 0x19, 0x9a, 0x5b, 0xef, 0x1, 0x17, 0x79, 0x53, 0x4, 0x87, 0x81, 0x7e, 0xa6}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe0, 0xbe, 0x3b, 0x6f, 0xd2, 0xd0, 0xf5, 0x35, 0x49, 0x8b, 0xda, 0x6b, 0xd4, 0x13, 0x3, 0x5e, 0x67, 0xf0, 0xb9, 0x32, 0x81, 0xc, 0xec, 0xff, 0x14, 0xe8, 0xa6, 0x75, 0x9b, 0x8d, 0xe7, 0x6d}} return a, nil } -var _fungibletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xe4\x5a\xdd\x6f\x1b\xc7\x11\x7f\xbf\xbf\x62\x60\x3f\x58\x4a\x29\xca\x48\x8b\x00\x15\x9a\xc4\x76\x1a\x01\x06\xda\x22\x88\xd5\xe4\x21\x08\xca\xe5\xdd\x1c\xb9\xf0\xde\xee\x65\x77\x8f\xf4\xc5\xd0\xff\x5e\xcc\xec\xc7\x7d\xf0\x28\x29\xf6\x4b\x81\xfa\xc5\xe4\xf1\x76\xbe\xe7\x37\x1f\xab\xeb\x2f\xbe\x28\x8a\xe7\x70\xb7\x47\xb8\x55\xe6\x08\xb7\x9d\xde\xc9\xad\x42\xb8\x33\xef\x51\x83\xf3\x42\x57\xc2\x56\x45\xf1\xfc\x39\x6c\xd2\x8f\xfc\xdb\x06\x4a\xa3\xbd\x15\xa5\x07\xa9\x3d\xda\x5a\x94\x58\x14\x44\x28\x7f\x05\xbf\x17\x1e\x84\x52\x73\xb2\xe9\xa4\x83\xa3\xe9\x54\x05\x7b\x71\x40\xf0\x86\x9e\xd7\xc6\x36\xe0\xcd\xba\x78\x5b\x83\x80\xce\xa1\x75\x70\x14\xda\x3b\xfa\xbd\xc2\x56\x99\x1e\x04\x68\x3c\x82\x9f\x90\x5a\x81\xdf\xa3\xb4\xf9\x7b\x11\x28\x6b\xc4\x8a\x4e\xca\xa6\x55\xd8\xa0\xf6\xf4\x1a\x4c\x14\x19\xe4\x5d\xb3\xfc\x23\x22\x33\xf1\x6a\xa3\xc8\x46\xa4\x10\x51\xb1\x9d\x42\x07\x42\x57\xa0\x45\x23\xf5\xae\x60\x75\xfd\xc4\x02\xae\xc5\x52\xd6\x12\xdd\x3a\x98\xf0\x27\xd1\x29\xbf\x01\x8b\xce\x74\x96\x0c\xf6\xbd\x28\xf7\x20\xca\xd2\x74\x2c\x9b\xf0\x60\x8e\xda\x05\xe5\x92\x79\x92\x12\x2c\x87\x20\x81\xc9\x2f\x25\x16\xa6\x66\x76\x4c\x34\xd3\x04\xe7\x8d\xc5\x0a\xa4\x8e\x26\x49\xd4\xe9\xb9\xd8\x45\x2d\xe7\x87\xf6\xc2\x41\x83\x7e\x6f\x2a\x07\x59\x0f\x73\xd4\x68\x59\x43\xe3\xf7\x68\xa3\x3b\x4a\xa1\xa1\x14\x4a\x45\x95\x7e\xb0\xe6\x20\x2b\xb4\x9b\x15\x6c\x7e\xc4\x12\xe5\x81\x3f\xd3\xa9\xcd\x1b\xa1\x48\xd0\x41\xe1\xc1\x34\x8e\xc5\x70\xe3\x27\x50\x61\xa9\x84\x45\x68\x2d\x5e\x95\x46\x57\xd2\x4b\xa3\x83\x89\x5b\xe3\xfc\xf8\x19\xcb\x68\xd1\x79\x2b\x4b\x5f\x90\xb0\xf8\x01\xcb\x8e\x7e\x84\x68\x96\xba\xd3\x65\x78\x39\x98\x22\xa8\x1c\xd4\xef\x81\xf8\x38\x6c\x85\x15\x1e\x61\x8b\xa5\xe8\x48\x16\x0f\x3b\x79\x40\xc7\xaf\x93\xb6\xfc\x41\x6c\xa5\x92\xbe\x27\x17\xb8\xbd\xb0\x58\x08\xb0\x58\xa3\x45\x5d\x72\x5c\x04\x33\x07\x83\x06\x17\x6a\xd5\x03\x7e\x68\x8d\x8b\xa4\x6a\x89\xaa\x72\x83\x44\x85\xd4\x60\x34\x82\xb1\xd0\x18\x8b\x49\xe2\xc1\x14\xeb\xa2\x78\x4b\xa9\xe3\x4c\x14\x28\x98\x7e\x26\x4d\x23\xde\x23\x94\x9d\xf3\xa6\xc9\x16\x8e\xa6\xc9\x01\x4f\xb6\x99\x5a\x99\x12\xc9\xc0\x41\x58\x69\x3a\x7a\x5b\xea\x9d\x83\xa3\xf4\x7b\x26\x1f\x22\x6f\x5d\xdc\x1a\x0b\xf8\x41\x10\x99\x15\x08\xa8\x45\x57\xa2\x67\xdf\x6f\x71\xa0\x8e\x15\x6c\xfb\x94\xb7\x9c\x03\x6c\x0e\x48\x41\x31\x49\xae\x37\x3d\x74\x4e\xea\xdd\x48\x56\x72\xed\x20\xda\x2a\xaa\x69\xea\xb3\x88\x51\x90\x04\x0e\x75\xc5\x47\x6d\x88\xb7\x94\x2e\x2d\xa2\xbd\xf2\xe6\x8a\xfe\x5f\xb1\x4a\xa6\xf3\x94\x36\xc4\x94\x50\x80\x38\x31\x38\x90\xb6\x02\x4a\x24\xaa\x0a\x14\x56\x3b\xb4\xe0\x1a\x61\x7d\x66\xb5\x86\x3b\x13\x38\x45\xea\xde\x80\xd0\x43\x22\xac\x8a\x80\x4f\x31\x49\x1d\xd9\xa4\x67\xa6\x95\x15\xc7\x91\x2d\xa1\xb6\xa6\x19\x07\x09\x63\x55\xc8\x21\x8e\xdc\x0a\x5b\xe3\xa4\xcf\xe1\x01\x46\x4f\x38\xbd\x70\x29\xb8\x08\x22\xc9\xf4\x1e\x03\x7d\x2b\xb4\xab\xd1\xae\x8b\xe2\x8b\xeb\xa2\xb8\xbe\xbe\x86\x05\x00\x3e\x0b\xbe\xd9\x8b\x6b\x3a\x5a\xb4\xdd\x76\x01\xd3\x67\x60\xf9\xb1\x28\x00\x00\x12\x2b\x6f\xbc\x50\xa0\xbb\x66\x8b\x96\xa3\x38\x68\x2c\x35\xe0\x07\xe9\x3c\x65\xc8\x3a\x1f\x78\xeb\x41\x3a\xe8\xda\x98\x33\xa3\x28\xb2\xf4\x08\xb5\xeb\x2c\x0e\xe8\x13\x68\xbb\xae\x6d\x55\x9f\x69\x38\x2f\x7a\x47\x90\xd6\x71\xe2\x52\x10\x04\x82\x95\xf0\xc8\x6f\x91\x1a\x07\x61\xc3\xf1\x77\x7c\xfa\x06\xfe\x7d\x2b\x3f\x7c\xf5\x97\xa9\xec\x78\xc0\x84\xb9\xd2\x01\x36\xd2\x53\x38\x1f\xc9\x35\xc4\x7e\x30\x85\x83\xd2\xa2\xf0\x58\x65\xfa\xe1\x28\x5b\xc4\xbd\xd5\xd2\x4b\xa1\xe4\xef\x58\x5d\xc8\xf0\x79\xca\xf5\xf2\xe9\x6c\x83\xf5\x08\x9a\x52\x1c\xe9\x10\x3d\x22\x44\xc0\xa2\x00\x3f\xa7\x57\x2f\x44\x43\x40\x9f\xf8\xae\xf8\xe8\x0d\xbc\xae\x2a\x8b\xce\x7d\xfb\x49\x72\xc4\xd8\xe4\x7a\x42\x09\xf0\x80\x1c\x7f\x4f\xaf\x9e\xc8\xe1\xcd\x59\x29\x66\xb1\x8a\x04\x24\x65\x44\x4d\x8b\xbf\x75\xd2\x72\x84\x38\xa8\x8d\xcd\x46\x21\xa0\x49\x44\x66\x39\x36\x04\x15\xe7\x7c\xdf\x0e\xf1\x37\x8e\xc3\xca\xa0\x03\x6d\x32\xc3\x29\x2f\xa3\x61\xb3\x4d\xa5\x6b\x8f\x16\x57\xf9\xec\xa8\x52\x28\x14\x84\xcc\xa6\x8d\x01\xd3\x1a\xe7\x64\x04\x67\x53\x87\x98\x21\x21\x22\x40\xb7\x11\x12\xdd\x20\x3a\x69\x5c\x19\x96\x43\x63\x89\xce\x09\x2b\x55\x1f\xeb\x3d\xe3\x85\x39\x6a\x88\x92\x4c\xf5\x20\xe3\x9f\x16\xd5\x01\x77\x63\x9e\x26\x56\xef\xba\x6d\x4c\xfa\xb9\xbd\xb8\xc6\x27\x84\x99\x9c\x09\x00\xeb\x3b\x4b\xa1\x10\x11\x28\x97\x09\x8b\x8d\x39\x60\x95\xcb\xc5\xe8\xe0\x84\xc8\xdd\xa8\x10\xbf\xe0\xc4\x45\xe7\x40\xe1\x01\x15\x85\x5d\xdb\x6d\x95\x2c\x57\xb0\xed\x28\x14\xa5\xa3\x67\x64\x0e\x41\xe6\xda\x2a\x6c\x26\xc4\x92\xf1\xb9\xbe\x0e\x0d\x0a\x35\x36\xec\x6d\x96\x2b\xdb\x64\xda\xfe\x4c\x08\x95\xdc\x45\x71\xae\xaa\x9e\x81\x38\x70\x4f\x92\x3e\xac\x4f\xe0\xda\x88\x1e\x76\x56\x68\x1f\x9b\xa3\xc8\x27\xeb\x48\x75\x31\x85\x00\xa9\x23\x0f\x09\xa1\x06\x29\xda\x5c\xcc\x63\xa7\x6c\x8e\x2e\xf5\x8c\xe5\xa4\xe9\xa2\xdc\x63\xba\x13\x0a\x1c\x76\xc9\xe5\x59\x75\xbf\xb7\xa6\xdb\x51\x81\xcb\x6d\xca\x53\x15\x0a\x1d\x07\x6b\x45\x46\x79\x44\x27\x76\xde\x53\x54\x22\x5a\x33\x3d\x26\xb2\x4f\x68\x7c\x9a\x1e\xaf\xa8\x95\x6b\x20\x41\x0f\xa9\x15\x3e\x8f\xca\x92\x37\xd4\xbc\xcc\xa0\x95\xe4\x38\x9c\x04\xff\xab\x10\xf9\xb0\xd0\x2a\x53\x61\x10\x52\xa7\x88\x1b\x91\xeb\x74\x35\xf5\x4f\xfe\x42\xe9\x5a\x77\x3a\xbf\x3c\x83\xc8\xcb\x1b\x78\x15\xb8\x7c\xcc\x47\xf8\x98\x71\xf3\x47\x81\x34\x6c\x2c\xba\x38\x4a\xd4\xd1\xae\x21\xfc\x59\xea\x83\x50\x1d\x9e\x1c\x0b\x47\xd6\x11\x4f\xe0\xeb\xaf\x93\xb5\x4e\xde\xa4\x7f\xcf\x52\x5d\x11\x2a\x59\xb2\xe9\x9c\x27\x0b\x12\x27\x27\x1a\x04\x11\xdc\x98\x28\xc6\x36\x76\xb0\x08\xeb\xf4\x6c\x42\xfe\xbe\x98\x7e\xba\xff\x8c\x7a\x10\x8b\xd3\x42\x39\xe0\x62\xf5\xc4\x72\xf0\x33\x26\x10\x96\xba\x54\x5d\x85\xd4\x19\xa6\x49\x23\x88\x51\xee\xb1\x7c\x3f\xd5\x35\x62\x51\xa6\x72\x44\x9e\x53\xc9\x11\xd4\xb1\x3f\xa5\x61\x0f\xb3\x52\x68\xd8\x0b\x18\x41\x53\x65\xd2\x4b\xcb\xdd\xf9\x0a\x94\x7c\x4f\xc3\xa5\x92\xdc\x2a\x35\xd4\x03\x09\x5d\x0d\x5d\x12\xb7\xad\xf4\x03\x75\x46\xb2\xe6\xec\xf1\xd0\xaa\x30\x5b\xc0\xe3\x85\x24\x4d\x72\xf3\x42\x72\x27\xde\xe3\x50\x0e\xa8\x44\x44\x27\x38\x2a\x89\xcb\x66\x1f\x12\xba\x6f\xf1\xb1\x04\x0e\x3d\xcb\xe3\x69\xc7\xc9\x16\xbc\x73\x94\x4a\x51\x58\xe6\x5e\x65\x91\x47\x4a\xc1\xf8\xd6\x45\x60\x14\xd2\xee\x72\xaa\xe4\x1b\xa4\x39\x5f\xba\x01\x77\xaa\x01\x2b\x6e\xff\xf1\xf6\x07\x78\xfe\xd5\x5f\x61\xef\x7d\xeb\x6e\xae\xaf\x77\xd2\xef\xbb\xed\xba\x34\xcd\xb5\xd1\xb5\x32\xc7\xeb\x5a\xc9\xd6\x5d\x6f\x95\xd9\x5e\x37\x42\xea\xf8\xfd\xcb\x97\x5f\xfe\xf9\xe5\x97\x2f\xbf\xba\xaa\x63\x47\x7d\xc5\xde\xbc\x62\xf0\xb9\x22\xdb\x5c\x55\xd2\x95\xe6\x80\xb6\x5f\x37\xd5\x32\x90\xd0\x97\x1f\x63\x51\xe6\xd9\x41\x72\xc1\x12\x96\x7b\x8e\x38\x26\xf4\x2d\x8e\xa6\xf8\x90\x3a\xd1\x9d\xd2\x81\xa0\x59\x20\xe2\x70\x4b\x3e\x03\xf2\xde\x26\xda\x65\x13\xd7\x00\xb3\x3a\x23\x5d\x18\x5a\x64\x5a\x8a\x44\xa4\xd9\x7c\xbc\xeb\x5b\xfc\xdb\xab\x5b\x65\x8e\xdc\x06\xae\x59\x86\x6f\x2e\x2e\x6f\xc0\xdb\x0e\xef\x37\x61\xc6\xab\x41\xe8\x7e\x1e\xfa\x13\x1e\x5d\x1a\x96\x2b\xac\x59\x8d\x1c\x43\x22\x26\xe2\x02\x7b\x6c\x5a\xdf\x8f\x8d\x20\x1c\x6b\xd3\x0a\x0a\xf8\xe5\xb2\x42\xbd\x9f\x7e\xe1\xf3\xb6\x29\x27\xd7\x74\xc1\xb5\x9e\xed\x6a\xce\x97\x9e\xef\xa6\x5a\xcd\x04\x0f\x7d\x34\x7e\x68\xb1\xf4\x61\x8f\xd3\xb5\x3b\x2b\x2a\x9c\x6d\xac\x42\x6d\xac\x2a\xde\xf0\x4c\x28\xcc\x5c\x21\x3c\x0f\x45\xc6\x7a\x17\x1c\x13\x1c\x36\x6e\x4d\xa5\x03\x8a\x22\xae\x03\xec\x6e\x42\xcb\x34\xf1\x8b\xb6\x55\xb2\x8c\xb2\xc5\xb5\xd2\x03\x75\x35\x5a\x7a\x1a\x68\x51\x00\xcc\xe9\x1f\x4a\x68\x0c\xbd\x6d\x7f\x1e\x04\xd6\x0f\x17\xc8\x1d\xfa\x77\x89\x36\x3b\x80\xc2\xcb\x51\x34\x71\xa0\xdd\xc0\x1b\x63\xd4\xfd\xac\x26\xe6\x94\x65\x9c\x26\xed\xc7\x0b\x8a\x84\xbb\xc3\x74\x69\x3b\x7d\xe5\x65\x13\x00\x29\x04\xd4\x9c\x1e\xb7\x98\x3b\xf4\x31\xd0\xc6\x83\x61\x88\xad\x09\x30\x51\x1c\x45\x94\x5e\x0c\xa2\x35\x4c\xe8\xcb\x1a\x1c\xaa\x7a\xbd\x43\x56\xef\xe2\x72\x2d\x1d\x75\xe8\xf4\xd9\xd4\x37\x10\x53\xea\x94\xd0\x37\x17\x97\x97\x0b\xfd\x40\x74\xd1\xc7\x29\xd1\x98\x80\xd3\xea\x0b\xa8\x1c\x2e\xb7\x14\x01\x56\x28\xfc\x96\xb2\x6a\x9c\x99\xdc\x5e\x70\x4c\x65\x23\x1c\xf7\x06\x2a\xa3\x5f\xf8\x25\xca\xc3\xf6\x75\xd1\x3a\x2b\x70\x5d\xb9\x27\x26\xd3\x9f\xdf\x1d\xa5\x2f\xf7\x5b\x23\x6c\xb5\x59\xc1\x86\x9f\xdd\x1a\x7b\x14\xb6\x42\xbb\x01\xf4\xe5\xfa\xac\x29\xee\x3f\xa3\xe9\x88\x95\x26\xe8\x3c\x0c\x82\xbc\xc4\x83\xf1\xce\x35\x13\x21\x88\x1b\xb5\x2a\x54\x93\x28\x5a\x34\x1e\xc3\x8b\x01\x03\xe2\x16\x61\x35\xee\x23\x32\x09\x0a\xda\x61\x93\x00\xa5\xb1\x16\x4b\xaf\xfa\x27\x55\xeb\xb8\x67\x3d\x29\xd6\x79\x8b\x32\xea\xd0\xc4\x69\xb7\x3b\xc9\xc2\x83\xb0\xe9\xf5\xe9\xde\x84\x23\x57\x4b\x7f\x31\xfb\x75\x1e\x91\x67\x9a\x56\x0e\xce\x51\xef\x99\xa8\x2c\x37\x9f\x49\xa3\xd4\x72\x8e\x6d\x93\x7a\x8c\xf0\x28\x11\x3a\xdf\x66\x4e\x6c\x72\x9b\x96\x6c\x71\x83\x1c\xe7\xdb\xb8\xd3\xff\x27\x7a\x51\x09\x2f\xe0\x27\x89\x47\x37\xdf\x73\x8a\xd9\x2e\xed\x51\xd0\x7c\xad\x41\x58\x2b\x18\x32\x19\xc8\x28\x85\x86\x1e\x66\x4c\xfe\x40\x0c\xd7\x70\x47\x80\x1e\xf2\x2b\xb5\x35\x9d\x63\xee\x13\x06\xe9\x5f\x45\x83\xb4\x69\xe3\x04\xf0\x5e\x9b\x23\x1c\xf7\xb2\xdc\x03\x37\x53\x18\x37\x6b\xad\x70\xa3\x09\xc1\x19\x75\x40\xd2\xef\xe2\x32\x96\x8e\x65\xf4\x1f\x41\x32\x5b\x83\x10\xe5\x17\xd2\xe2\xd7\x99\x77\xa3\xb2\xbf\xfc\xfa\x54\x9b\xb3\x04\xd4\x45\x36\xc9\xdc\xa4\x3d\x03\x4a\x1a\xc3\x83\x95\xc3\x1d\x0f\x95\x93\xdc\xb9\x2f\x9a\x3b\xb4\x8e\x44\x24\xb4\x8e\x24\x65\xca\xd4\x0a\x9d\xb4\xd1\xc0\xeb\x65\x2f\x81\xf3\xb6\x2b\x3d\xd5\x07\x8b\xad\x45\x97\xe6\x85\x38\x74\xa0\xf3\x4b\x04\x4e\x2c\x35\xb6\xed\x7f\x92\x38\x7d\x8b\x97\x37\xf0\x5a\xf7\xef\x98\xc9\xb7\xcb\xc6\xd3\x52\x3d\x8c\x51\xa3\xa9\x78\x0e\x51\xc3\x45\x87\x37\xe7\x76\xe3\xeb\x09\xb1\x70\xd1\x22\xd2\x6d\x09\xcf\x3b\xa5\xe5\xb5\x32\x59\x4e\xea\xf0\x68\xbe\x0a\x6e\x50\xe8\xd9\xb8\x82\xdc\x67\x9c\x59\x31\xcf\xae\x22\xdc\x43\x97\x6f\x99\x22\x67\x3c\xa7\x09\x8e\x05\x9b\x5f\x9d\x65\x3b\x84\xda\x1b\xa3\xfb\xcc\x6d\xd4\x04\xa8\x87\x5b\xa9\xf1\xcd\x43\x18\x65\xf8\xfe\xc9\xc5\xce\x2c\xce\x9b\x55\xba\xbe\xa1\x57\x86\x2b\x1c\x38\x07\xcb\x2c\xe8\x4d\x5e\xc5\xad\xf2\x2c\xb5\xfa\x43\x38\x7d\xba\x97\x78\x14\x9d\x23\xa9\xe1\x3a\x26\xb8\x33\x5a\x34\xdc\xad\x0d\x9b\x2f\xf9\xfb\xa4\x03\x9f\x2c\x6c\xc2\x62\x26\xe3\xd4\x14\x69\x4f\x6b\x60\xa0\xf0\x70\x95\x38\xb7\x90\xdc\x84\xe5\xc2\x66\x98\xb0\x98\xee\x0b\x37\x29\x91\xb0\xb8\x94\xcc\x05\x76\x68\xe2\x5d\x24\x4c\x98\x79\x7a\xfe\x7f\x7e\x65\xf4\xd9\x1b\x23\xbb\xd4\xdd\x4d\x6a\xef\x37\x8f\xec\x7d\x5e\x07\x1b\x0c\x42\xa6\x1a\xac\xc2\xda\x4e\x68\x30\x16\xf0\xb7\x4e\xa8\xf0\x6d\x61\x05\xf4\xe0\xe2\x07\x1e\xdc\x6c\xd1\x08\xc3\x8e\x6c\xb1\xa4\xa0\xcb\xb7\x62\x9b\x2d\xd6\xc6\xe2\x86\x57\x2c\xe8\xa3\x17\xa8\x52\x46\xa6\xb3\x56\x6d\x89\x78\x1c\x89\xb7\xb8\x93\x9a\xdd\x31\xbb\x2b\x1e\x6e\x91\x17\x4e\x3f\xde\xd2\xb0\x80\x17\xe3\xc7\x97\x70\xf5\xb0\xb5\xff\x95\x43\x78\x3b\x6b\x79\xc2\x78\x5f\xa7\x8b\xe6\x28\x69\x6b\xf1\xc0\x63\x5c\x7a\x5d\x84\x55\xcf\xd3\xb7\x6e\xff\x0f\xfb\x9c\xd3\x01\xf1\xb5\x73\x68\xfd\xb0\x15\x99\x56\xbc\xdc\x2b\xa4\xdb\xae\x30\xce\x86\xad\x07\xef\x3a\xe7\xf4\xe2\x48\x74\x18\x6e\xfd\xa5\x8b\x2b\x95\xa4\x52\xa4\xf6\x84\xfc\x24\xd9\xd7\xd2\xbd\x8d\x7f\xd8\x71\x31\x1d\xe4\x2e\x6f\x60\x39\x76\xbe\x13\x5a\x1b\x9f\x47\x70\x86\xf6\xd2\x34\xad\xf0\xa3\xee\x89\xf4\xfb\x84\x4c\x7c\x52\x6c\xff\x29\x3d\x66\x05\xd2\xe3\x4f\x8a\x74\xd7\x35\x8f\x86\xf8\xe0\x9e\x3f\xb6\x58\x7e\x1d\x6f\x21\x74\x1f\xff\xa8\xc3\xc4\x59\x6c\x52\x42\xd8\x89\x7b\x41\xd9\xf0\x3b\x5a\x33\x9f\xd0\x32\xb5\x31\xce\x0f\xa7\xf3\x9f\xf4\xc0\xac\x2f\xa0\x18\x0d\xdc\xbe\xa7\xb1\x9a\xdf\xbe\x58\x82\xef\x05\x47\x9c\x6e\xec\x5f\xae\x5f\xde\xc0\xb3\xc8\x5a\xf5\x69\xa6\x8c\x42\xb0\x41\xf9\xcf\x84\xc6\x1a\x3c\x3b\xb1\xcc\x7d\xf1\xdf\x00\x00\x00\xff\xff\xb9\xc5\x60\x3c\xf9\x25\x00\x00" +var _fungibletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x5a\x4b\x93\xdb\x36\xf2\xbf\xeb\x53\x74\x4d\x0e\x96\xf2\x97\x35\x39\xfc\x6b\x0f\x53\x9b\x38\x76\x12\x57\xf9\x90\xad\xad\x78\x9c\x1c\x76\xb7\x4a\x10\xd9\x94\x90\x81\x00\x06\x00\x25\x6b\xa7\xe6\xbb\x6f\x75\xe3\x41\x82\xa2\xe6\x91\xc7\x5c\x3c\x43\x12\x8d\x7e\xfe\xfa\xd7\x80\xaf\xbf\xfc\x72\x36\xfb\x02\x6e\x77\x08\xef\x95\x39\xc2\xfb\x4e\x6f\xe5\x46\x21\xdc\x9a\x3b\xd4\xe0\xbc\xd0\xb5\xb0\xf5\x6c\xf6\xc5\x17\xb0\x4e\x2f\xf9\xdd\x1a\x2a\xa3\xbd\x15\x95\x9f\xcd\x78\xf9\xf4\x4a\x90\x0e\xb4\x01\x65\xf4\x16\x2d\x08\x0d\x52\x7b\xb4\x8d\xa8\x70\xe6\x77\xc2\x83\x50\x0a\x9a\xb4\xd4\xf3\xd2\x24\xd7\xc1\xd1\x74\xaa\x86\x9d\x38\xd0\x2b\x7a\xde\x18\xbb\x07\x6f\x56\xb3\xd9\x87\x06\x04\x74\x0e\xad\x83\xa3\xd0\xde\xd1\x07\x35\xb6\xca\x9c\x40\x80\xc6\xe3\x48\xd6\x12\xfc\x0e\xa5\xed\x75\xae\x0d\x92\x62\x1e\x34\x62\x4d\x8b\xe5\xbe\x55\xb8\x47\xed\xe9\x4b\x28\x4c\xed\x75\x5e\xc2\xa6\xf3\x51\x14\x6f\xe0\x66\xb5\xb9\x20\x22\x2f\x72\x50\x63\x23\x35\xd6\x20\x35\xf8\x9d\x74\x59\x8b\x55\xf0\xeb\xcf\xa2\x53\x7e\x0d\x16\x9d\xe9\x6c\x35\x58\x39\x9b\xfd\x20\xaa\xdd\xd8\x3f\xf9\x3b\x7f\x6a\x91\x37\x77\xe7\xbb\x5f\x16\x1a\x37\xfd\xa7\x35\x07\x59\xa3\x5d\x2f\x61\xfd\x13\x56\x28\x0f\xfc\xbb\xd0\x35\xac\xdf\x09\x25\x74\x85\x53\xab\x1d\x47\xdb\x8d\xcc\xab\x94\xb0\x08\xad\xc5\xd7\x95\xd1\xb5\xf4\xd2\x68\xc7\xa2\x5a\xe3\xfc\xf0\x19\xc7\xdc\xa2\xf3\x56\x56\x7e\x46\x8a\xe2\x67\xac\x3a\x7a\x09\xa6\x61\xcd\x9b\x4e\x57\xe1\x63\x76\x17\x02\x5b\xb2\xe2\x7d\x4f\x40\xfb\x38\x6c\x85\x15\x1e\x61\x83\x95\xe8\x48\x17\x0f\x5b\x79\x40\xc7\x9f\x53\x52\xf0\x2f\x62\x23\x95\xf4\x27\xf2\x8d\xdb\x09\x8b\x33\x01\x16\x1b\xb4\xa8\x2b\xce\xa7\x10\x46\x96\x1e\xf4\x32\x5a\x9d\x00\x3f\xb7\xc6\x45\x51\x8d\x44\x55\xbb\x5e\xa3\x99\xd4\x60\x34\x82\xb1\xb0\x37\x16\x93\xc6\xbd\x2b\x28\x31\x29\xa7\x9d\x89\x0a\x85\x0c\x1d\x69\xb3\x17\x77\x08\x55\xe7\xbc\xd9\x67\x0f\x47\xd7\xe4\x20\x92\x6f\x4a\x2f\x53\x82\x1b\x38\x08\x2b\x4d\x47\x5f\x4b\xbd\x75\x70\x94\x7e\xc7\xe2\x43\x36\xae\x66\xef\x8d\x05\xfc\x2c\x48\xcc\x12\x04\x34\xa2\xab\xd0\x43\x25\x34\x6c\xb0\x97\x8e\x35\x6c\x4e\xa9\xa0\xa4\xde\xce\x82\x3b\x20\x25\x45\x91\x2d\x5f\x5e\xcf\x66\x72\xdf\x1a\xeb\xe1\xea\x67\x89\xc7\x9f\xd0\x19\x75\x40\x7b\x95\x9f\xbe\xeb\xac\xa6\xbf\x67\xd7\xd7\xd7\x65\xe9\xd0\x93\xe2\x69\x84\x87\xac\x89\x08\xa1\x76\x3b\x2e\xf5\x32\x87\xcb\xbc\x67\x31\x03\xbd\x44\x55\xa1\x73\x73\xa1\xd4\x22\x17\x54\xff\xbe\x54\xe3\x06\x86\x8a\xc3\xfd\x6c\x06\x00\x70\x7d\x0d\x6f\x35\xa0\xf6\xd2\xc7\x5d\x1b\x63\x09\x91\xcc\x51\xea\x2d\xab\x40\xfe\xad\xad\x38\x0a\xc5\xc1\x66\x27\x43\x63\xcd\x1e\x44\xc8\x1c\x16\x34\x54\x65\x28\xee\x97\xb8\x3a\x6d\x77\xcd\x40\x8b\x87\x60\x20\x85\xdb\x01\xee\xa5\xa7\x78\x1c\x77\xa8\xd3\x06\x94\xe4\x69\x67\xfd\xc4\x76\x87\xe1\x46\x7a\x4e\x98\x70\x03\x1f\xbd\x95\x7a\xbb\x04\xb1\x37\x9d\xf6\x37\xf0\xe9\xbd\xfc\xfc\xb7\xff\x5f\xb2\xa8\x1b\x78\x5b\xd7\x16\x9d\x7b\x13\xfe\xfe\xf4\xe9\xc3\xf7\x37\xf0\xe9\x83\xf6\xf4\x45\xde\xb6\x7c\xbc\x09\x88\xf0\xb6\xf1\x68\x93\xb8\xc5\xef\x31\xab\xc6\xd6\x38\xe9\x03\x60\x3e\x6e\xd4\xf7\xe9\xd3\x27\x8c\xf2\x66\x68\x92\x37\xa5\xe6\x79\xc3\x17\x19\xf4\xc3\x23\xc6\xec\x10\xb6\xca\x6c\x84\x82\x4d\x67\x35\xec\xd1\xef\x0c\xf7\xb9\x4a\x28\x45\x5f\x51\x4d\x0a\xd0\x46\xbf\xfe\x2f\x5a\x93\xb6\xba\x60\x25\xd7\xce\x53\x26\x8e\xe3\x34\xd0\xf4\xdd\x40\x3a\x15\xdb\x30\x24\x7d\x35\xb0\x25\x6d\xa8\x6e\xd7\x37\xe7\x8c\x6c\xff\xce\xeb\xa8\x04\xb6\xe8\x3d\x55\x40\xd4\x1c\x24\xe3\x04\x97\x6a\xb1\xcf\xd0\x9a\xf3\x56\x91\x54\x83\x7b\xfe\x78\xbc\xe0\x20\x6c\xda\x20\x19\xca\xdf\x3d\xf4\xb6\x25\x38\x7a\x8e\x71\x48\x3a\x56\x11\xb8\x2d\xfe\xd6\x49\xcb\x45\xe8\xd8\xa2\x94\xd6\x84\x75\x49\xc8\xb0\x9a\x19\xc6\x13\xf8\x70\xf1\x9f\x5a\x5c\x9d\xed\xfb\xc1\x43\x26\x0e\x71\xc3\x72\x2f\xa3\x61\xbd\x49\xdd\x73\x87\x16\x97\x79\xed\xa0\x59\x29\x14\xd4\x1c\x4c\x1b\xd3\xa9\x35\xce\xc9\xd8\x1f\x4c\x03\x95\x45\xc1\x4a\xc4\x1e\x11\xe3\x66\x5d\xaf\x3a\x59\x4c\xcc\x83\x09\x0c\xf9\x54\x58\xa9\x4e\x91\x89\x70\x5f\x33\x47\x9d\xdc\xbb\x7a\x49\xd0\x72\x0b\x88\x20\x99\xb6\x7c\x1f\x53\x85\xeb\xd6\xdd\x81\xc8\x6a\x81\x24\x2e\xe6\x5a\xac\x64\x23\xab\x98\xbb\x3d\x5c\x16\x52\xa4\x03\x71\x10\x52\x89\x00\xeb\xd4\x94\x32\xe2\x14\x1f\xde\x06\x9e\x44\x4d\x61\xc3\x3d\xbd\xe9\x14\x6f\x7d\x30\xb2\x86\x56\x68\x59\x91\x87\xb8\x22\xa9\xee\xf8\x8f\x04\xb7\x43\x41\xb9\x66\x73\x32\x3b\xe8\xf4\x9d\x36\xa3\x0d\xdf\xd6\x81\xa3\x08\xa5\x4e\x4b\x32\x89\x03\x93\x4d\x74\xd0\x76\x61\x17\xce\x97\x7d\xa7\xbc\x6c\x15\xc2\x81\x00\x6c\x64\x63\x64\x12\x99\x99\x55\x3b\xac\xee\xc0\x99\x7d\x66\x0c\x61\x15\x74\xda\x4b\xc5\x0f\x6a\x74\xd2\x62\x1d\x9d\x37\x76\x99\x45\x51\xed\xb0\x5e\x42\x6b\x3c\xe5\x27\xe9\x08\x3b\x54\x6d\xb2\x1a\x5a\xb4\x5c\xa2\x39\xda\x69\xf5\x74\xe9\x49\x3c\x52\xed\x83\x74\x6f\x53\x34\x6e\x4d\x6a\x22\xf3\x12\x7d\x16\x37\xf0\xce\x18\x55\x66\x43\x72\x35\xb8\x6e\x13\xc9\xfa\xa3\xe5\x94\x12\xad\x10\x42\x04\xd1\xa2\xef\x2c\xf5\x86\x48\xc4\x32\xa1\xb1\xb8\x37\x07\x6e\x13\x81\xd8\x0c\x16\x8e\x12\xa5\xa7\x8c\xaf\x5c\x34\x13\x14\x1e\x50\x91\xeb\xd6\xd1\xee\x64\xdc\x62\x5d\xac\xfe\x68\x88\x65\x1a\x4b\x31\xa6\xec\x0a\xab\xa5\x5f\x32\xcf\x0b\xf3\x07\x4a\xbf\x43\x9b\x6b\x0b\xcc\xe6\x57\x24\xaa\xe1\x1d\xaa\xa6\x90\x66\x78\xc2\x89\x0c\xa0\x1e\xb0\x4d\xb6\x6a\x9d\x74\x58\x4f\x5b\x33\xd6\x94\x23\x74\xbc\x18\x94\x6f\xef\xd9\x63\x0f\x03\x78\xa5\x1f\x62\xdc\xa3\x47\x61\x23\x58\x5b\x74\x71\x26\x68\x98\x95\x9a\xe8\x68\x8a\x00\x1c\x84\xea\xf0\x6c\x59\x58\xb2\x4a\xb5\xf3\xf5\xd7\xa9\x35\x9d\x7d\x49\x3f\x57\xbf\xf4\x74\x29\xc2\xc0\xbe\x73\x9e\x2a\x98\x76\x72\x62\x8f\x20\x5c\x51\x8d\xb1\x20\x7a\xb6\xc3\x46\x5d\x15\xe2\x1f\x66\xe5\x6f\x83\x0e\x91\x26\x97\x3f\xde\x21\x22\x4f\x98\x68\x10\x52\x47\x4f\x3d\xa3\x41\xfc\x82\x09\x96\xa5\xae\x54\x57\x23\x08\xc8\xe3\x4f\x50\x83\xd1\xa0\x74\x42\x6c\x0d\x59\xca\x11\x79\xa8\xa5\x08\xd1\x18\xf1\x9c\x29\x22\xb8\x21\x4c\x11\x59\x0e\xd1\xfe\xda\xa4\x8f\xa6\x47\x86\x25\x28\x79\x87\xe0\x5a\x25\x99\x75\xef\xa1\x6b\xa9\x32\xb3\x10\x87\xba\x0e\x2f\x68\x02\x91\x0d\xe7\xb4\x87\x56\x85\x81\x07\x9e\xdf\x5a\x52\xb0\xc6\xad\x25\xba\x1e\xbc\xb8\xc3\x1e\x09\x08\x1d\xe2\x1b\xaa\xc8\x0b\x61\x28\x86\xe1\xc7\xca\x8a\x95\xa2\x8a\x8a\x32\xe7\x81\x0b\xa7\x2a\x5a\x94\x2a\x6d\xd1\x7f\xec\x5a\x9a\x6e\xb0\xe6\x0f\x6e\x4f\x2d\xba\x01\x5a\xd5\x92\x11\x47\x58\xee\xd8\x71\x88\xa4\x6f\xce\x10\xee\xb8\x43\xc6\x0f\x76\x39\x4d\xec\xd4\xd8\x3a\x4b\x4e\x54\x27\x70\x69\x17\x1a\xc8\xf8\x70\xa0\x48\xe9\xb1\x01\x19\xb9\xa7\x15\x9c\x2f\x6e\xe0\xfe\x96\xa9\x24\x61\xf6\x43\x69\xd4\x4f\x51\xfb\xa4\x91\xb1\x9c\xa9\x4c\x68\xe5\x81\xda\x64\x54\x8f\x76\x6c\xb3\x4e\x78\xae\x12\x37\xcc\xd0\xc5\x62\x52\x0b\x1d\x57\x81\xd0\xa7\x20\x28\xce\x74\xbf\x12\x02\x44\x90\xf1\xb6\x43\x12\x5a\x63\x93\x89\xff\x45\x13\xa5\x3b\xb7\x30\xf2\x64\xfa\x35\xf5\xa5\x11\x22\xf4\x13\x45\x41\xdc\x6a\x0c\x8d\x9d\x5d\xdc\xa7\x64\x40\x78\x1e\xd8\xfb\xe3\xa5\x6c\xef\x32\x51\xd8\x25\xdc\x5a\xa1\x5d\x83\xd6\xd8\x65\xa6\x48\xe1\xb4\x24\x4d\x95\x3d\xd1\xeb\xfa\xc9\x81\xfc\xdb\x87\xf8\x84\xfe\x25\xf5\xc2\xa6\xdc\x0c\xb4\xe9\x37\xce\x7a\x0d\xe7\xda\x55\xfa\x65\x19\xa6\x0a\xbb\xa2\x7f\x98\x6a\x8d\xc9\x9c\x44\x55\x07\x25\xa9\x7b\xdf\x9d\x61\xb2\x08\xc1\x7d\x36\x71\x2f\xa4\x7f\x17\xe7\x20\x62\x5e\x62\x7c\x7a\x25\x1d\x8f\x4d\x58\xc3\x41\x8a\x70\x54\x15\x95\xa5\xc7\xf3\xc5\x3a\x0e\x54\x85\xc4\x0f\xa3\xe3\x82\x08\x6c\x94\x6a\x1b\x63\xee\xee\x10\x99\x0a\x19\xcb\xa3\x1a\x3f\xe7\xe9\xaa\xac\x46\xb6\x37\x66\xe5\x06\xcb\xa9\x2e\x1a\x4c\xea\xd5\xe8\xbc\x35\x27\xac\x4b\x26\xf5\x23\x49\x1d\x9f\x5b\x1c\xa5\x52\x19\xab\xbb\xb6\x16\x1e\x7b\x6c\x7d\x45\x3d\xd6\x0b\xc5\x19\xa0\x4e\xa5\x2e\x86\xda\xb0\x22\x22\x11\xc2\x90\x01\x39\x9c\x77\x6e\x10\x75\x72\x54\xe0\x49\x81\x0e\x65\x7a\x15\x64\xae\x1e\x75\x13\xe7\x75\x3a\x9d\x74\xe8\x8b\x28\x7b\x03\x61\x3c\xc5\xc6\xd8\xa0\x35\x21\xfd\xe8\x14\xee\x9c\x94\x4b\x66\x0e\xad\x0d\xe3\x6b\xf0\x9a\x39\x6a\x6a\x3e\xac\x9c\x6b\xc5\x7e\xcf\x44\x99\x1a\x54\x18\x6f\x63\x34\x56\xe3\x7c\x4a\xe7\x36\x01\x99\xc9\x5c\xca\x9d\x8d\xa8\xee\xe6\x8b\x31\xaf\xb1\x38\x41\x6b\x38\xdc\xc5\x08\x4d\xa4\x6c\xb5\xc5\x80\x16\x8b\x95\xac\xa9\x51\x34\x92\xab\x35\x52\x28\xfe\x64\x93\x2a\xa8\x9f\xad\xf9\x79\xd7\xc9\x7a\x71\x81\x7e\xc0\x65\x7e\x35\x94\x49\x34\xe9\xab\xd5\x57\x37\x70\x75\x3b\xf0\x77\x62\x42\x1c\x87\xe8\xfb\xba\xb3\xe9\xa4\x69\x68\x7c\x3a\x53\x70\x26\x02\x09\x03\x2c\x61\x09\xad\x27\xff\x62\x7d\x89\x22\x9d\x2b\x43\xba\x0c\x18\xd4\x1f\xe9\x73\x87\xbe\xcf\x8d\x7a\x1b\x4f\x29\xb1\xbd\x87\x46\xe0\xe2\xd9\x68\x8d\x9f\x29\x01\x47\xed\x99\x09\x5a\x6c\x03\xa3\xaa\x02\x46\x68\x66\x4f\x35\xcf\xd0\x79\x74\x8e\x63\x93\xb0\x08\xf8\xb9\xc5\xca\x63\x3d\x2e\x2a\x9e\xbc\x72\xff\xea\x47\x61\xda\x7f\x19\x1c\x8a\xa7\x50\x62\xba\xaf\x8d\x38\xe7\xf1\xfd\x44\xa1\x4b\x21\x9e\x68\x22\x5b\x7a\x56\x1c\x7f\xa0\x45\x8f\x72\xe9\xfa\x1a\xde\xa1\x32\xc7\x38\x34\x92\x2b\x06\x87\xb6\x89\xf6\xb9\xce\x46\x52\x6b\x3b\xfd\xda\xcb\x7d\xa4\x16\xdc\xce\xc6\xf2\xd8\x25\x5b\x4c\x4d\x78\x78\x8e\xd5\x0a\xe6\x72\xb9\xf7\xc4\x1e\x18\x49\x62\x79\xe1\xb3\x0a\x37\x0a\x2b\x28\xe4\xcb\xe6\xac\xe2\xdc\xc7\x6e\x43\xda\xcc\x4d\x13\x3a\xf5\xdf\xbf\xbd\x9f\x90\xf4\xf0\xcd\x7c\x31\x2e\x72\xe0\x91\x83\xa9\xc2\x7d\x29\xf6\x86\xb9\x43\x99\xe6\x0f\x80\xca\x4d\xa1\x42\xe6\x3a\x3c\x8e\xed\x5b\x7f\x1a\xe6\x71\x9c\x40\x52\xf2\xf1\xe0\xc3\xb1\xcd\x6e\x38\xee\x0c\xd4\x46\xbf\xf2\x53\x92\xfb\x33\xea\x49\xff\x2c\xc1\x75\xd5\x8e\x36\x29\x5f\x7f\x3c\x4a\x5f\xed\x36\x46\xd8\x7a\xbd\x84\x35\x3f\x7b\x6f\xec\x51\xd0\xec\xb9\x06\xf4\xd5\xea\xa2\x2b\x1e\x2e\x8e\x43\x65\xdf\x0d\x93\x45\x3c\xbb\x28\x29\xdd\x39\xcf\xfc\xf9\xcf\x62\x60\xa3\x00\x44\xa5\x53\xf8\x26\x4b\xe0\x5f\x24\xe4\x3f\xf0\xe6\x0d\x34\x42\x39\xbc\x64\xd0\xc4\x29\xc3\x3a\x80\xf8\xba\x6f\x84\x2c\xf7\x95\x2b\x8e\x59\x61\xf2\x84\x41\xe3\x71\x7c\xca\x90\x04\x93\x5f\xce\xd7\xff\xd9\xa3\xf9\x64\x0b\x2b\xc0\xfa\x9b\x27\x06\xec\xb7\x61\xaa\xee\xc7\xe5\xd4\x55\x14\x3a\x1e\xfe\x34\x93\xa0\xdf\x3a\xa1\xc2\x5f\x13\xb3\xf6\xa3\x13\x36\x5c\x6e\x71\xf1\x2c\x20\x97\x24\xb5\xb9\x71\x91\x5e\xfd\x38\x64\xfb\x69\xe6\xef\xdb\x06\xd5\x05\xad\xb9\x9a\xaa\x2c\x82\x78\x5e\xd3\x62\x25\x85\xca\x30\x0b\xeb\xc0\x51\xd6\x3c\x10\x47\x1a\x13\xca\x36\x9a\xd4\x9f\xb9\xf2\x95\xdd\x94\xf0\xc8\xb1\x36\xb8\x95\x5a\x33\x59\x2c\x89\x4e\x7f\x11\x39\xb1\xfa\xc9\x76\x1f\x14\x9c\x0f\x1f\x2f\xe0\xf5\xe3\xb1\xfc\x47\x4e\xc7\x31\x45\x60\x78\x8a\x93\x76\x1f\x37\xa2\x5c\x7c\xf7\x97\x3e\x17\x61\x30\x1f\x1f\x9e\xa4\xf7\xe7\x3e\x66\xb6\xd4\xdf\x15\x4d\xaa\x45\x3f\xa1\xc4\xc7\xf1\x1e\x72\xa9\x8b\x4b\x53\x2d\x84\x7f\x2f\x7f\x17\xa6\x6f\xf6\x17\x93\xc7\x37\x2b\x11\xae\x70\x1e\x5f\x32\x22\x6a\x97\x3f\x1e\xdd\x63\x45\x5b\x1e\x5f\x53\xde\x09\x0d\x63\x79\xb6\xe4\x12\x43\x7c\x78\xee\xc9\x86\xa8\x6b\x07\xd2\xbb\x21\x1d\x3f\xab\xd5\x33\x94\x7e\xc9\xb9\xc6\x54\xcb\x1d\xf7\x5b\x1a\xe3\x9d\x43\x3b\x18\x42\x2a\xa3\x2b\x8b\x3e\x12\x8a\x98\x7a\xfd\xad\x5d\x9e\x92\x52\x71\x8f\xe5\xc5\xee\x3a\x38\x1b\xc8\x07\x0a\x89\xea\x46\x69\xcf\xc0\x46\xb2\x65\x25\xdd\x07\xed\x3c\x79\x65\x5e\xc2\xcd\xe2\x06\xa6\x2b\xeb\xbb\x40\x96\x93\xf7\xf9\x7f\x9d\x54\x66\xdf\x0a\x3f\x18\x44\xc9\xbe\xdf\x81\x82\x5c\x43\xfd\xd5\xe4\x13\x35\x14\x71\x81\xed\x98\x2a\xa4\xc5\xd3\x95\x34\x14\x91\xa0\xe5\xf2\x2a\x6f\x5e\x58\x55\xe9\xbe\xf4\x19\x35\x35\xba\x4a\x1d\x2a\xc6\x53\xd3\x5f\x50\x59\xf0\x5c\xac\xfd\xbf\x49\x3f\xfd\x2e\xe4\x75\xdd\xfe\x49\xc8\xed\x0b\xe2\x89\xf3\xea\x02\x0e\xf8\x62\x0f\x7f\x20\x42\x1a\x91\x40\x29\x73\x74\x7c\x5e\x11\xfe\xdb\x8a\x89\xdf\x14\x6c\x85\xab\x68\x27\x08\x40\xce\x2e\x94\xe1\x09\x54\x18\x6f\x39\x7f\xf1\xcd\xc1\xf9\x15\x40\x3f\xdb\x6a\x3c\xaa\x53\xdc\x23\xba\x22\xb8\x92\x07\xac\xa1\xb2\xe7\xcd\xe8\x59\x74\xe2\xe9\x4d\x32\xc9\x48\xf4\x82\x41\x2c\xdd\xa0\x1e\x5e\x74\x9b\xf0\x17\xc4\x67\xea\xa8\x6f\x32\x2e\x87\x44\x8f\x33\xb7\x9e\x86\xf0\x41\x84\x26\x02\x36\xe5\xd4\x81\x64\xf6\x67\x1e\x03\x03\x46\xe7\x0b\xed\xbd\xf0\xd5\xae\xb8\x8d\x3c\x87\xc8\x3f\x3b\x19\x52\x08\x1e\xfe\x17\x00\x00\xff\xff\x9b\x3d\xb9\xb6\x89\x28\x00\x00" func fungibletokenCdcBytes() ([]byte, error) { return bindataRead( @@ -113,11 +115,11 @@ func fungibletokenCdc() (*asset, error) { } info := bindataFileInfo{name: "FungibleToken.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x68, 0x39, 0x37, 0x8c, 0x7c, 0x94, 0xfa, 0x5, 0x1d, 0xb4, 0xf6, 0x3f, 0xcc, 0x5c, 0x57, 0x2e, 0xe7, 0xa7, 0xf4, 0x9b, 0x96, 0x2f, 0x2d, 0x16, 0x1c, 0x8f, 0x2d, 0x73, 0x81, 0x80, 0x52, 0x99}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x51, 0xaa, 0x44, 0xc5, 0x28, 0x30, 0x92, 0x83, 0x68, 0x3a, 0xfb, 0x0, 0x6, 0x8c, 0x53, 0x14, 0x5, 0xb8, 0x85, 0x4c, 0xfc, 0xe8, 0x77, 0xce, 0xb2, 0xf1, 0xc3, 0x90, 0xe7, 0x81, 0xe4, 0xbe}} return a, nil } -var _fungibletokenmetadataviewsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x58\x5f\x6f\x23\xb7\x11\x7f\xd7\xa7\x98\xea\x21\xb1\x01\x9f\x74\x77\x28\xda\x40\x88\x7a\xb9\x20\x16\x5a\xc0\x87\x33\x7c\xba\xf4\xb1\xa6\x76\x67\x25\xc2\x5c\x72\x4b\x72\xa5\x13\x0c\x7f\xf7\x62\x48\xee\x2e\xa9\xdd\x95\xed\xa4\x01\xa2\x07\x5b\x22\x87\x33\xbf\xf9\xcb\x19\xf2\xb2\x52\xda\xc2\xaa\x96\x5b\xbe\x11\xb8\x56\x0f\x28\xa1\xd0\xaa\x84\x69\xb2\x36\x9d\x04\xca\x4f\x68\x59\xce\x2c\xfb\x95\xe3\xc1\x04\xca\x64\x6d\x3a\x99\xcc\xe7\x73\x58\xef\xb8\x81\x4c\x49\xab\x59\x66\x81\x97\x95\xc0\x12\xa5\x35\x60\x77\x08\x65\x38\x00\xc6\x32\x99\x33\x9d\x43\xa5\x55\xa5\x0c\xe6\xee\x2c\x97\xb0\xba\xf9\xd7\xed\x9b\x77\x6f\x7f\xf8\xfb\xcc\xad\xb8\x3f\x77\x58\x2c\x60\x67\x6d\x65\x16\xf3\xf9\x96\xdb\x5d\xbd\x99\x65\xaa\x9c\x2b\x59\x08\x75\x98\x17\x82\x57\x66\xbe\x11\x6a\x33\x2f\x19\x97\x73\x56\x55\x82\x67\xcc\x72\x25\xe7\xef\xdf\xbe\x7f\xff\xf6\x87\x77\xef\xde\x14\x41\xa9\x37\x96\xb4\x32\x6f\x1a\x24\xb3\x32\xef\x04\x7d\xb1\xba\xce\xac\x01\x26\x73\xd0\x68\x54\xad\x33\x34\x90\x31\xd9\xe9\x01\x4a\x22\x28\x0d\xa5\xd2\xe8\xce\xb4\x2a\xd9\x63\x85\xe6\x0a\x32\x26\x04\xe6\xb0\x27\x93\xcc\xe0\x9a\x65\x3b\xf7\xdd\x6d\x83\xc6\x4a\xa3\x21\x73\xb8\xb3\x0c\x72\x5e\x14\xa8\x89\xef\x03\x97\x39\xa8\xa2\xe5\xe7\xf4\x9f\x54\xf5\xa6\x33\x66\xe2\x98\xd4\x1f\x8f\x93\x09\x00\x00\x31\x5d\xad\x69\x09\x0e\x9a\x55\x06\x56\xeb\x5f\xb8\xa9\x04\x3b\x3a\x9d\x56\xeb\x5f\x59\x2d\xec\x2f\xcc\xb2\x2b\xb7\xc0\x0d\xd4\x06\x73\xb0\x0a\xb6\x7c\x8f\xc0\x20\x53\xa4\xa9\x45\x68\xf9\x55\x3c\xb3\xb5\x46\xc2\xc6\x5a\x08\xe0\x30\xcc\xe0\x93\x32\xf6\x64\xb1\xc5\x6b\xc0\xec\x54\x2d\xf2\x8e\x55\x67\x45\x4b\x51\x42\x76\x99\x35\x9b\xee\x3f\xa9\x6b\x9c\x13\x1a\x35\x1e\xdd\x7a\xb3\x27\xd0\x42\x61\x83\x4a\x8b\x4e\xbb\x0f\x8e\x62\x80\xb4\xd5\x77\x11\x2b\xff\xa1\xa5\xe4\x92\xdb\x8b\xf6\x17\x7d\x06\xd9\x5f\x9d\x90\x3c\xc7\xf6\x32\xc2\x4d\x1f\x83\xa2\x98\xb5\x9c\x61\xd9\x49\x19\x22\x6b\x19\x3a\xc2\xf6\x57\x4b\xfa\x34\xf1\x7f\x5b\xbb\xfe\x13\x45\x85\xda\x79\x11\x2d\x79\x69\x3d\x60\x5b\x22\xfc\xa9\x62\x9a\x95\x6e\xf3\x0e\x8d\x12\x7b\xd4\x0b\xf8\x08\x1a\x5d\x10\x66\x48\x2c\x28\x4f\x75\xd8\x6c\xb3\xa0\xe3\xa0\xd1\xd6\x5a\xc2\xc7\xc6\x41\xde\x5d\x3d\x2f\x16\xb5\x24\x30\x9e\xe8\x22\x15\xf8\xdd\x63\x12\xbc\xb3\x66\xe7\xe9\x72\xd1\x77\x3b\xf9\xb1\x64\xc7\x0d\x86\x9d\x65\x82\x7e\x16\x90\x3a\x29\xeb\x63\x85\x3f\x7a\xb2\x7f\x5c\x5c\x5e\x76\x4e\x2e\x9a\x68\xf0\x0c\x62\x76\xa9\x9f\x82\x72\x81\x92\x99\xbf\x04\x3c\x27\xa6\x8f\x48\x83\x82\x63\x21\xe4\x3c\xea\xec\x10\x96\x12\x53\x5c\x9e\x89\xab\xee\x64\xbb\x98\x9e\xed\x82\xed\x34\x1c\x1c\x78\xab\x00\xbf\x51\x69\x75\x0e\xe5\xb2\x50\xba\x74\x35\x11\x24\x62\xee\x73\xde\xec\xd4\x21\x63\x8e\x84\x53\xad\x98\x75\xa9\xea\xcb\x38\x93\xb0\x41\x5f\x22\x36\x47\x88\x0a\xab\xe9\x4a\x86\x04\xb5\x47\xed\x6a\x1c\x95\x94\x96\xc3\x56\xb3\x6a\xc7\x33\x43\x85\x83\x20\xac\xd6\x67\x72\xbd\xc9\x8c\xce\x1d\x1e\x04\x42\x1e\x76\x24\x2b\x11\x0a\xa5\x3d\x56\x57\xc5\x67\x31\x71\x72\xf0\xfa\x1b\xa3\x52\xb3\x80\xe9\x4a\xa8\xc3\x74\x90\xae\x29\x12\xc4\x78\x41\xa5\x9f\xcb\xed\xa4\x27\x9e\x6d\x36\x1a\xf7\x9c\x59\xcc\xc1\x1c\xcb\x8d\x12\xbf\x05\xc4\xcd\xe7\x7f\x4f\x7b\x82\x3d\xbb\x61\xd1\x1f\x21\x47\x93\x69\x5e\x39\x8f\x91\xf9\x2a\xad\xf6\x3c\x47\x93\x18\xdc\x99\xf6\x35\x48\x48\x25\x42\xe3\x4f\x50\xfd\x27\xde\x92\x59\x72\x65\x56\x6b\xaa\x02\xc7\xd6\x63\x42\x1d\x40\xa2\x3d\x28\xfd\x30\xeb\xe3\x8f\x10\x0e\x2b\x71\xfd\xcd\xa2\x96\x4c\x80\xe0\xf2\x81\x02\x86\xc1\xd7\xbb\x1b\xfa\xe2\xc0\xd3\x15\x9a\x04\x26\xdb\xa8\xda\x3a\xc9\xcd\x6d\x7d\xaa\x58\x23\x1a\x03\xe7\xaf\x77\x37\x8b\xb4\x33\x99\x5d\x77\x5b\x29\x9a\xcf\xdd\xc5\x0d\x7b\xd4\xc6\x45\x71\xd0\x34\x95\x07\x42\x6d\x55\x5f\x28\xad\x9a\x53\x71\x9f\x30\xe7\xcc\xa4\x92\xbe\xa8\x8c\x07\xad\x5d\x9e\x68\xa4\x2e\xa0\x2f\xe7\x7b\x03\xc6\x93\xee\x54\x89\x15\xdb\xa2\x49\x7c\x08\xb7\xca\x18\x47\xfe\x80\x47\x43\x65\x8b\xb2\x71\xca\xa5\xb1\x6c\xab\x59\x39\xbd\x82\xa9\x3d\x70\x6b\x51\xd3\xd7\x9c\x9b\x4c\xe9\x7c\x7a\x05\x68\xb3\x3e\x7c\x2f\xca\x2c\xe0\xd1\xfb\xea\x8c\xe1\x9e\x26\x67\x2e\xc8\x38\x5f\xd2\xfa\x95\x06\x74\xba\x37\x10\x2c\x29\xc1\xcb\x5c\x9a\x9e\x39\xe3\x91\x13\x64\xaf\xd1\xbd\x39\x34\x78\x89\xbb\x32\xb4\x74\x46\xe8\x6f\x86\x02\xb1\x0c\x96\xe8\x13\xc4\x49\xbd\x8c\x6d\xd2\x27\x8d\xec\x01\xcb\xd8\x3a\x7d\x52\x67\x06\x58\x7a\x73\x0c\xa0\xf2\xca\x13\x2c\xff\xed\xa5\x8d\x44\x57\x96\xb9\x04\x06\x07\x76\x04\xbb\x63\x16\x0e\x5c\x88\xe6\xfe\xf3\x7d\x6f\x0e\xca\xa9\xc1\x44\x5b\xe3\xe1\x8f\x68\x3a\x64\x2b\x27\x02\xf7\x5c\x07\xd2\xdc\xbc\xff\x81\xd7\xb4\x21\x6d\x67\xf9\x78\xda\x47\xb8\xf6\x21\x6c\xbf\xb0\x25\x09\xd4\xd4\x95\x9c\x04\x55\xe0\x99\x27\xec\x7a\x12\x98\xf9\x30\x78\x49\x36\x9f\x60\x9f\x88\x4b\x42\xf2\x34\xde\xbf\x48\x2e\x7e\x5b\xfb\x60\x2c\x15\x52\x37\x44\x48\x8b\x6e\x3e\x39\x70\xbb\x0b\xdd\x27\xb5\x2c\xb3\x57\x35\x13\x06\x6d\x5d\x45\xa7\x3d\x37\x1a\x0f\x51\x77\xb1\x44\x52\xd9\xd6\xcb\xad\xea\x8d\xe0\x19\x64\xac\x62\x1b\x2e\xb8\xe5\x4d\xf9\x1c\x9e\x26\xda\xa6\x3a\xed\x31\x6e\x99\xdd\x51\x7c\x37\x9c\x0f\x3b\xd4\x6d\x43\x14\xa0\x70\x03\x1a\x33\x55\x96\x28\x43\xe7\xb4\x41\x6f\x80\x7c\xa0\xce\x7a\x46\xc4\x97\x2a\x5d\xfb\x23\xbd\x23\x6e\x3d\xf8\x8a\xa4\x1f\x76\x3c\xdb\x41\x59\x1b\x4b\x7c\xe9\xda\xf0\x42\x22\x07\x04\x5d\x35\x66\xc8\x29\x45\x5a\xa5\x8f\x7d\x00\x0d\x91\x47\xe0\x05\xfd\x6e\x00\x1b\x26\x18\xe5\x6a\x33\x1a\xbb\x44\x1d\xf5\x40\x0c\xa7\x19\x68\x9f\x81\xa3\xf9\x9e\x59\x8c\xf1\x84\xe9\x71\xd4\x24\xbe\x21\x8a\x6d\x41\x14\x14\x36\xb9\x66\x07\xca\xff\xdc\x40\x22\xc4\xbd\x5a\xd0\xd9\x28\x3e\x63\xa8\x0d\xcb\x00\xd5\x43\xea\x63\xa5\xa4\xf6\x95\xb0\x07\x91\xf9\xfe\xe5\x3e\xf6\xc1\xfd\xcc\x27\x00\x37\xc0\xc8\x76\x56\xf3\x8c\xda\xc9\xf0\x22\xf0\xdf\x9a\xd3\x95\x94\x22\x75\x4c\x92\x79\x7f\x76\x17\x58\xde\xfb\x84\x2b\x58\x86\xe3\xbe\xbf\x71\x70\x08\xe8\xc2\xc1\xfd\x33\x28\xf0\xb3\x0f\xa1\x7b\x17\x43\xf7\xc3\xb5\x37\x52\xee\x4c\x28\xfd\x5e\xed\x58\xa1\xb4\x7b\x87\xe0\x4a\x62\x0e\x55\x14\x7b\x41\xd5\x84\x21\x37\x20\xa9\xfc\x09\x71\x1c\x30\x80\xaf\x7a\x34\x76\x97\x5c\xf2\xb2\x2e\x87\x74\xbf\x0d\x91\x75\xd6\x79\x4d\xf8\x9d\x57\x6f\x55\xcb\x2c\x4c\x05\x24\x55\x08\x75\x30\x90\x69\xf4\xd5\x59\x15\x34\x20\x60\x59\xd9\x63\x57\xbf\x1c\x25\x39\x50\x5a\x57\xc1\x52\x4f\xa9\x50\xcb\x43\x83\x9a\x0f\x18\xde\xb1\xc7\x6b\xe2\xea\xea\xe8\x02\x2e\x2e\x2e\x17\xf0\x53\xaa\xa4\xdb\xba\x3c\xd7\x3b\x8e\xd5\xc6\xab\x93\x29\x7c\xb8\x80\xa5\x54\x63\x75\x25\xa5\x1a\x4d\xe9\x61\x91\xa7\xa6\x1f\x16\x79\x9e\x6a\xcc\x8d\x29\xd5\xa9\x49\x1b\xb7\x9e\x35\x6d\x73\xf8\xb4\x8b\xa8\x34\x0e\x76\x05\xa7\x4a\xcd\xb8\xf9\x52\x6f\x28\x6c\x2f\x54\xe1\x51\xfd\xf8\xdd\xe3\x70\x9d\x79\xa2\x6e\x65\x01\xd3\xe6\x77\x53\xed\x5d\xd0\xbb\xbb\x82\xcb\x4c\xd4\x39\xc2\xf0\xf9\x68\x62\x1c\xb7\xdf\x4b\x00\x85\xba\x71\x05\x23\xed\x5a\xc0\xd9\xec\xbe\x14\xe7\xcf\xd1\x8d\x36\xcc\x39\xae\x45\x7d\x65\xfa\x6e\x7e\x89\x32\x4d\x21\x68\x50\x37\xbf\x9f\x85\xdb\x12\x76\x05\x64\x3a\xd2\xe4\x41\xdb\xf9\x77\x19\x46\xdd\x7f\xd4\x8b\xf4\x48\xe3\x9c\x83\x65\x92\x82\x7d\xe2\x38\xf5\xa8\x5d\x8d\x7e\xf6\x89\xe3\x0c\x84\x65\x92\x90\xe3\x30\x3a\xa3\x46\x60\xba\xc5\x71\x48\xc9\xc1\xfe\xe2\x38\xbc\xe4\x60\x7f\xb1\x7f\xf0\x34\x81\x61\x39\x9a\xd3\x2f\x1f\xb8\xba\x2e\xf5\xf9\x91\xeb\xf3\xe9\xc8\xf5\x87\x3c\xf3\x46\x03\x57\x07\xee\xd9\x47\xdf\xf6\xc9\xf2\x75\x43\x57\xf7\x94\xde\x1f\xbb\xf6\x2f\x7c\xfd\x6d\x58\x8c\x0f\x5b\xfb\xc0\x26\x8c\x55\x43\x93\x41\xf3\x09\x66\xd8\xff\x7f\xc7\x29\xab\x2c\x13\x60\xea\xaa\x12\xed\x63\x9b\x43\xf1\x7d\x78\xca\x73\x87\x59\x96\xa1\x31\x17\x4c\x88\xcb\x66\x8c\x59\xd3\xc1\x2f\xfe\x5c\x07\x36\x26\x74\x13\x88\x23\x58\xc0\xd7\x15\xff\xf6\xb7\xbf\x9e\xdc\xc7\xb6\x63\xd1\x50\x0c\x3e\x74\x04\x74\x4b\x88\x0e\xf4\xe2\xf8\x69\x02\xff\x0b\x00\x00\xff\xff\xa3\x45\xf3\x23\x49\x1c\x00\x00" +var _fungibletokenmetadataviewsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x58\xdf\x6f\xdb\xbe\x11\x7f\xf7\x5f\x71\xf3\x43\x9b\x00\x89\xdc\x16\xc3\x56\x18\xf5\xda\x02\x8d\xb1\x01\x29\x1a\x24\x6e\xf7\xb8\x52\xd2\xc9\x26\x42\x91\x1a\x49\xd9\x31\x82\xfc\xef\xc3\x91\xd4\x4f\x4b\x8e\xd3\x7d\x8b\xaf\x1f\x12\x89\x3c\xde\x7d\xee\x07\x8f\x1f\x8a\xe7\x85\xd2\x16\xa6\xcb\x52\xae\x79\x2c\x70\xa5\xee\x51\x4e\x27\xd5\xf0\x57\xb4\x2c\x65\x96\xfd\xe0\xb8\x33\xcd\x30\xbd\xde\xa2\x51\x62\x8b\x7a\x3a\x99\xcc\x66\x33\x58\x6d\xb8\x81\x44\x49\xab\x59\x62\x81\xe7\x85\xc0\x1c\xa5\x35\x60\x37\x08\x79\x50\x03\xc6\x32\x99\x32\x9d\x42\xa1\x55\xa1\x0c\xa6\x6e\x2d\x97\xb0\xbc\xfe\xd7\xcd\xe5\xdb\x37\xef\xff\x1e\xb9\x11\xf7\xe7\x16\xb3\x39\x6c\xac\x2d\xcc\x7c\x36\x5b\x73\xbb\x29\xe3\x28\x51\xf9\x4c\xc9\x4c\xa8\xdd\x2c\x13\xbc\x30\xb3\x58\xa8\x78\x96\x33\x2e\x67\xac\x28\x04\x4f\x98\xe5\x4a\xce\xde\xbd\x79\xf7\xee\xcd\xfb\xb7\x6f\x2f\xb3\xe0\xd7\xa5\x25\xc7\xcc\x65\x85\x24\xca\xd3\xc6\xd0\x9d\xd5\x65\x62\x0d\x30\x99\x82\x46\xa3\x4a\x9d\xa0\x81\x84\xc9\xc6\x0f\x50\x12\x41\x69\xc8\x95\x46\xb7\xa6\x76\xc9\xee\x0b\x34\x17\x90\x30\x21\x30\x85\x2d\x05\x2a\x82\x2b\x96\x6c\xdc\xb3\x9b\x06\x8d\x85\x46\x43\xe1\x70\x6b\x19\xa4\x3c\xcb\x50\x93\xde\x7b\x2e\x53\x50\x59\xad\xcf\xf9\x3f\x61\x49\x82\xc6\x9c\x31\x21\xce\x9b\xa0\x76\x72\xd4\xc9\x0c\x3c\x4e\x26\x00\x00\xa4\x7c\xb9\xa2\x21\xd8\x69\x56\x18\x58\xae\xbe\x70\x53\x08\xb6\x77\xbe\x2d\x57\x3f\x58\x29\xec\x17\x66\xd9\x85\x1b\xe0\x06\x4a\x83\x29\x58\x05\x6b\xbe\x45\x60\x90\x28\xf2\xd8\x22\xd4\xfa\x0a\x9e\xd8\x52\x23\x61\x64\x35\x04\x70\x18\x22\xf8\xaa\x8c\xed\x0d\xd6\x78\x0d\x98\x8d\x2a\x45\xda\xa8\x6a\xa2\x69\xa9\x5a\x28\x3e\x51\x35\xe9\xfe\xb7\xdd\x36\x2e\x29\x95\x3b\x8f\x6e\xbe\x2f\x23\xd0\x42\x66\x83\x8b\xf3\xc6\xdb\x8f\x4e\xf2\xc8\x92\x3a\x0e\xf3\x76\x50\x3e\xd6\x2b\x5c\xea\xb8\xe4\xf6\xac\x1e\xa2\xdf\xa0\xad\x8b\x9e\xc8\x73\xba\xcf\x5b\xce\xd0\xcf\xa0\xc8\xa2\x5a\x33\x2c\x1a\x2b\x43\x62\xb5\x42\x27\x58\xbf\xd5\xa2\x4f\x13\xff\xb7\x0e\xfa\x3f\x51\x14\xa8\x5d\x8a\xd1\x52\x0a\x57\x03\x81\x27\xc1\x4f\x05\xd3\x2c\x77\x93\xd5\xde\x9e\xc3\x67\xd0\xe8\x2a\x35\x41\x52\x41\x9b\x59\x87\xc9\x7a\xab\x34\x1a\x34\xda\x52\x4b\xf8\x5c\x65\xcd\xe7\x70\x34\xc5\x59\x29\x09\x94\x17\x3e\xeb\x1a\x7e\xf5\xd8\x6e\x32\x51\xf5\xf0\x74\x3e\x3f\x2c\x09\xca\x69\xce\xf6\x31\x86\x99\x45\xc7\x89\x28\x00\x76\x46\x56\xfb\x02\x3f\x78\xb1\x7f\x9c\x9d\x9f\xd7\x2a\x78\x56\x55\x86\x57\xd0\x56\xd7\x4d\x57\xf0\x31\x48\x32\xf3\x97\x80\xa7\x97\x81\x96\x68\xf0\x6f\xac\x92\x5c\x62\x5d\x18\xc2\x50\x27\x12\xe7\x47\xca\xab\x59\x59\x0f\x76\xd7\x36\x35\xd7\xaf\x0a\x07\xde\x2a\xc0\x07\x6a\xc3\x2e\xaf\x5c\x66\x4a\xe7\xae\x7f\x82\x44\x4c\x7d\x5f\x30\x1b\xb5\x4b\x98\x13\xe1\xd4\x4f\xa2\x66\x3b\xfb\x96\xcf\x24\xc4\xe8\xdb\x48\xbc\x87\x56\x13\x36\x4d\x5b\x91\xa0\xb6\xa8\xdd\xa6\xa2\xb6\x53\x6b\x58\x6b\x56\x6c\x78\x62\xa8\xb9\x10\x84\xe5\xea\x84\x7e\x50\x6d\x94\x26\x2d\x1e\x0c\x42\x1a\x66\x24\xcb\x11\x32\xa5\x3d\x66\xd7\xf9\xa3\xb6\x70\x67\xe1\xd5\x03\xa3\xb6\x34\x87\xe9\x52\xa8\xdd\x74\x50\xae\xdf\x40\xc8\xc0\x9c\x8e\x0d\x2e\xd7\x93\x03\x18\x2c\x8e\x35\x6e\x39\xb3\x98\x82\xd9\xe7\xb1\x12\xbf\x02\xe6\xfa\xdb\xbf\xa7\xa3\x00\xbc\xda\x61\x08\x9f\x21\x45\x93\x68\x5e\xb8\x4c\x52\x58\x0b\xad\xb6\x3c\x45\xd3\x49\x84\x0b\xf9\x4b\x10\x91\x6b\x84\xca\xaf\xa0\xb3\x83\x74\x4b\x66\x29\xc5\x49\xa9\xa9\x49\xec\xeb\x4c\x0a\xb5\x03\x89\x76\xa7\xf4\x7d\x34\xee\x47\x0b\xe9\xb0\x33\x57\x0f\x16\xb5\x64\x02\x04\x97\xf7\x54\x50\x0c\xbe\xdf\x5e\xd3\x83\x73\x82\x8e\xe3\x4e\xe1\xb2\x58\x95\xd6\x21\xa8\x4e\xfe\xbe\x83\x7d\x08\x18\x2c\x7c\xbf\xbd\x9e\x43\xe7\x54\x8d\xae\x9a\xa9\x2e\xaa\x6f\x0d\x19\x80\x2d\x6a\xe3\xaa\x3d\x78\xde\xb5\x0b\x42\xad\xd5\xb8\x71\x9a\x35\x7d\xb3\x5f\x31\xe5\xcc\x74\x2d\xde\xa9\x84\x87\x28\xb8\x7d\xa5\x91\x18\xc6\xa1\xbd\xd7\x06\x8c\x17\xdd\xa8\x1c\x0b\xb6\x46\xd3\xc9\x2d\xdc\x28\x63\x9c\xf8\x3d\xee\x0d\xb5\x39\xda\xbd\x53\x2e\x8d\x65\x6b\xcd\xf2\xe9\x05\x4c\xed\x8e\x5b\x8b\x9a\x1e\x53\x6e\x12\xa5\xd3\xe9\x05\xa0\x4d\xc6\xdd\xf0\x26\xcd\x1c\x1e\x7d\x0e\x8f\x04\xf2\x69\xf2\xdc\x21\xdb\xde\x5c\xdd\xe6\xd7\xad\xfa\xee\xdc\x40\x25\x75\x05\x4e\xcb\x73\x77\xcd\x91\xf4\xf4\x90\xbd\x24\x00\xd5\xa2\x41\x22\xe0\x7a\xd7\xc2\x05\xe1\x70\x32\x74\x93\x45\x88\xc4\xa1\x40\x7b\xe7\x2f\xda\x31\x39\x14\x6d\xc5\x03\x16\xed\xe8\x1c\x8a\xba\x30\xc0\xc2\x87\x63\x00\x95\x77\x9e\x60\xf9\xa7\x53\xc9\x48\xd3\xcb\xb9\x04\x06\x3b\xb6\x07\xbb\x61\x16\x76\x5c\x88\xea\xf0\xf4\x04\x3b\x05\xe5\xdc\x60\xa2\x3e\x20\xe0\x77\x10\x17\x59\xdb\x69\x81\x3b\x95\xc5\x54\xc7\xf7\x7f\xe0\x05\x54\xa6\x66\xac\x8f\x7d\x2e\xe2\x28\x48\x98\x3e\x91\xd6\x04\x69\x62\x36\xbd\xda\x0a\x3a\xd3\x8e\xba\x03\x0b\xcc\x7c\x1c\x3c\x60\xab\x5f\x08\x53\x4b\x4b\x47\xe4\x69\x9c\x03\x49\x2e\x7e\x8d\x82\x18\x4b\x4d\xd6\x5d\x56\xa4\x45\x77\x0f\xda\x71\xbb\x09\x44\x96\x68\x4f\xf4\x22\x42\x62\xd0\x96\x45\x6b\xb5\xd7\x46\xd7\x51\xd4\x4d\x49\x91\x55\xb6\xf6\x76\x8b\x32\x16\x3c\x81\x84\x15\x2c\xe6\x82\x5b\x5e\xb5\xd4\xe3\xb7\x96\x9a\xa7\x77\x79\xca\x0d\xb3\x1b\x2a\xf7\xca\xc2\x6e\x83\xba\x26\x57\x01\x12\x37\xa0\x31\x51\x79\x8e\x32\xb0\xb0\x18\x7d\x20\xd2\x23\x3d\xd8\x2b\x24\xfd\xd4\x00\xeb\x97\xee\x39\x72\xe3\x9d\x29\x08\xc5\x6e\xc3\x93\x0d\xe4\xa5\xb1\xa4\x9f\x8e\x16\x6f\xac\x95\x90\xe0\xbb\xc6\x04\x39\xed\x9c\x3a\x08\xfb\x71\x20\x95\xb0\x47\xe2\x0d\xfe\xdf\x40\x62\x26\x18\x6d\xe5\xea\x8a\xee\xf6\xf1\x68\x66\x86\x60\x55\x17\xec\xe3\xb0\x68\x23\xf9\x26\x14\x2e\xaf\x0d\x20\xe6\x79\xc5\xcf\xb6\x7f\x3f\x23\x5f\x74\xdc\x00\x23\x5c\x56\xf3\x84\x68\x5f\xb8\xf5\xff\xb7\xe4\x74\x1a\x40\xc7\x84\x53\xd2\xb9\xcb\x47\xb7\x41\xe5\x4f\x5f\xe4\x19\x4b\xf0\xf9\xf8\x5e\x3b\x58\x04\x78\xee\x60\xff\x39\x8e\x0c\xb6\xb6\x96\x1f\x27\x64\xe4\xb8\x23\xcb\x52\x26\x81\xc9\x32\x0b\x4c\x08\xb5\x33\x90\x68\xf4\x5d\x42\x65\x44\x6a\x31\x2f\xec\xbe\xd9\x3f\x4e\x92\x9c\x91\xd6\xed\xa0\x2e\x6a\x15\x7a\x4a\x20\x4f\xe9\x11\x84\xce\x0c\x5e\x91\x76\xb7\x9f\xe7\xb4\xe0\xec\x7c\x0e\x9f\x1e\xbb\x09\x74\xb3\xcf\x53\x9b\xb1\x3d\x7a\xd1\xbb\x61\x0e\x6f\xa0\xae\xd4\x58\x3d\x0f\xeb\xea\xc7\x78\x58\xd7\x71\xa9\x7e\x34\xaa\xcc\x3c\x17\x95\x6a\x7d\xff\x4c\x2a\x34\x0e\x9e\x31\x7d\xc4\x11\x37\x77\x65\x4c\x95\x78\xa6\x32\x0f\xec\xc3\xab\xc7\xe1\x1d\xf4\x44\x67\xdf\x1c\xa6\xd5\x7b\xd5\x23\x5c\x1d\xbb\x0e\xc3\x65\x22\xca\x14\x61\x78\x7d\xeb\xae\x32\x1e\x9c\x53\x00\x79\xdf\x03\x9a\x8a\x0c\xd6\xbd\xad\x46\x13\x23\xb0\xfe\x95\xc1\x15\xf1\x74\xe4\x64\x85\x9a\x75\x35\xe5\x43\xcc\xab\xd5\xf0\x0f\x44\xdb\x05\x05\x8b\x4e\x7d\x1d\x0a\xb7\xeb\x8a\x38\x42\xeb\x75\x5c\x73\x13\x9b\x96\xfe\x66\x70\xdc\x4a\x67\xe1\xe1\xe0\xe1\xc2\x7e\x11\xc2\x62\xb4\x2e\x4f\xa7\xa1\xcd\x61\xfd\x3c\x11\xfd\xd6\x27\xa2\xbf\xe5\x03\x5a\x8b\x86\x36\xe0\x4e\xfe\x9c\x56\x7f\x0d\x7a\x11\x15\x6d\xbe\x55\x1e\x92\xd1\xed\x89\xdf\xd5\x2a\x15\xe3\x14\x74\x1b\xd4\x04\xb2\x39\xc4\x93\x9a\x56\xe0\xa2\xb1\xfd\x63\x49\xa6\x55\x96\x09\x30\x65\x51\x88\xfa\x73\x85\x43\xf1\x3a\x7c\x0c\x19\x23\x75\x2b\x5a\x78\xe7\xd7\x8d\x7f\x8f\xf6\x8a\xe7\xf0\x7d\xc9\x1f\xfe\xf6\xd7\xa1\x23\xc1\x36\x7a\x2a\xb1\xc1\xab\x60\x80\xb8\x80\xd6\x82\x83\x9a\x7e\x9a\xc0\xff\x02\x00\x00\xff\xff\xea\x75\x9d\x1b\xc4\x19\x00\x00" func fungibletokenmetadataviewsCdcBytes() ([]byte, error) { return bindataRead( @@ -133,11 +135,11 @@ func fungibletokenmetadataviewsCdc() (*asset, error) { } info := bindataFileInfo{name: "FungibleTokenMetadataViews.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x97, 0xc4, 0xe2, 0x86, 0xa5, 0x74, 0x6f, 0x14, 0x3e, 0x5e, 0x69, 0xd7, 0xe9, 0xe, 0x85, 0x54, 0x40, 0x72, 0x2f, 0x6e, 0xcc, 0xe9, 0x73, 0xf8, 0xc5, 0xf8, 0x2, 0x3f, 0xca, 0x45, 0x97, 0x5e}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x53, 0xfc, 0xad, 0xee, 0xc4, 0x9b, 0x6f, 0x62, 0xa8, 0xb3, 0x38, 0xb7, 0x4d, 0x4f, 0xa5, 0xe3, 0x6f, 0x64, 0x1, 0x31, 0x9e, 0x70, 0x6c, 0xd2, 0x98, 0x59, 0x34, 0xc2, 0x84, 0x56, 0xd0, 0xbc}} return a, nil } -var _fungibletokenswitchboardCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5c\x4d\x8f\xe3\x36\xd2\xbe\xf7\xaf\xa8\xf4\xe1\x1d\x37\xe0\xd8\x39\xbc\xd8\x43\x23\x9d\xf9\xdc\x09\x72\xc9\x06\x49\x67\xe7\x30\x18\xa0\x69\xa9\xd4\x22\x5a\x26\x05\x92\xb2\xc7\x19\xf4\x7f\x5f\x14\x49\x49\xa4\x44\xd9\xf2\x4c\x6f\x3e\x16\xd1\x61\xa6\x2d\x8b\xc5\xaa\x62\x55\x3d\x55\x2c\xca\x7c\x5b\x4b\x65\xe0\x6d\x23\xee\xf9\xa6\xc2\x5b\xf9\x80\x02\x0a\x25\xb7\x70\x19\xdd\xbb\xbc\xb8\x58\xaf\xd7\x70\x5b\x22\x64\x52\x18\xc5\x32\x03\xa6\x64\x06\x58\x55\xc9\xbd\x06\x26\x80\x65\x99\x6c\x84\x01\x23\x41\x61\x86\x7c\x87\x50\xb3\xc3\x16\x85\xd1\xc0\x05\x6c\x9b\xca\xf0\xba\x42\x28\x3c\x5d\x4b\xd0\x10\x71\x0d\x8d\xe6\xe2\x1e\x18\xd0\x7f\x15\xc2\xdd\xa7\x68\xf2\xd5\xcf\x8e\x9e\x7a\xbc\x83\x8c\xd5\x6c\xc3\x2b\x6e\x0e\x2b\xcf\x11\xd7\xc1\x4d\xd0\xa5\x6c\xaa\x1c\x78\x8e\xac\xaa\x0e\xb0\x41\xd0\x46\x2a\xcc\x81\x11\xc3\x08\x76\xd0\x5d\x44\xfe\x97\x3d\x37\x59\xb9\x91\x4c\xe5\xdd\x4c\x3f\x35\x9b\x8a\x67\x3f\x31\x53\xc2\x0d\xac\x6b\xfb\x69\xfd\x3d\x0a\x54\x3c\x7b\x7b\xdb\x3e\x75\x67\xa9\x6d\x1a\x03\xdc\x40\xc6\x44\x38\x9d\x38\xec\x4b\x54\xe8\xb8\xbc\xa8\x9b\x4d\xaf\xb8\xa9\xd9\xe1\xd3\x05\xc0\x05\x00\xc0\x7a\x0d\xbf\x18\xa9\xd8\x3d\x02\x13\x39\x38\x6e\x80\xd8\xd1\xf6\x7b\x22\x57\xa1\x69\x1f\xa2\x2f\xae\xc3\x0f\xd1\x43\xbd\x2c\xd7\xc1\xdf\xd1\x23\x63\xb1\xa3\x47\x3d\x4f\x6e\xfd\x71\x87\xc2\x2f\x3e\xd7\x80\x5b\x6e\x0c\xe6\xb0\x2f\x51\x00\x03\x81\x7b\xd8\xb1\xa6\x32\xe1\x9a\x70\x0d\x2c\xcf\x31\x27\xd3\x60\x1d\x2d\x1d\x08\xae\x50\xcb\x46\x65\xb8\xea\xbe\xed\xd8\x73\xd3\xfd\x9b\x68\xbe\xee\x48\xbe\x24\x72\x0b\x73\xa8\xf1\x1a\x6e\x0f\x35\x2e\x43\x6a\xff\xda\x0b\x54\xd7\xf0\x32\xcf\x15\x6a\xfd\x7c\xe9\x68\x9d\xba\x7a\x7e\x07\xe3\xaf\xce\x10\x3f\x25\xba\xc2\xad\xdc\x61\xee\xbc\x8a\xc1\x93\xc8\xff\xb3\xa3\x19\x69\xe0\xcb\x55\xf0\x64\x6a\xc8\xb1\x96\xda\xbb\x84\x90\x86\xdc\x22\x93\xdb\xba\x42\x83\xf9\xa4\x88\x3f\x4a\xf3\xba\x7d\xe8\x8d\x23\x10\xc9\xc7\xb6\x14\x5e\xae\xe1\xd7\xb7\xfc\xe3\x3f\xfe\x7f\xa6\x48\xd3\x3a\x19\xc8\xc3\x85\x41\x55\xb0\x0c\x9d\x4c\x28\x0a\xa9\x32\xd4\x36\x66\x6c\xd1\x94\xd2\x59\x2f\x45\x3b\xf2\x6d\x29\x90\x3e\x67\x25\x66\x0f\x20\x05\x3d\xd6\x91\x63\x3b\xc6\x2b\xb6\xa9\xb0\x57\x26\x47\x0d\xb2\xa0\x00\x97\x58\x74\xeb\xe2\xac\xd2\x12\xf0\x63\x2d\xb5\x9f\xb4\x23\xd7\x2a\xd3\x71\xa1\x69\xda\xf6\x56\xd1\x88\x5c\xd3\xf4\xdc\x24\xd4\xda\xd1\xef\x65\x0b\x82\x8d\x8f\x29\x9f\x3a\x35\xd2\x90\xa2\x11\x70\x8f\xc6\x5a\x1b\x69\x5d\x2f\xae\xae\xe1\x3d\xfd\xf5\xe1\xf8\x73\xef\xb8\x29\xbd\x66\x69\xc8\xa7\x5b\xbb\x70\xfe\xce\x63\x6a\xec\x2f\x4d\x4d\xd0\x83\x79\x3c\x99\x1f\xf9\x4a\xca\x6a\x3c\xcc\xcb\xbd\x20\x57\xba\x86\x17\x31\x48\x58\x3a\x57\xa3\x31\x9a\x15\xf8\xe6\xf4\xb8\xf4\xed\xe7\x23\x72\x76\xc5\xdb\x70\xf9\xea\x40\xdc\x06\x56\x7a\xe5\x38\x4f\x32\xf1\x4a\x2a\x25\xf7\xa9\x21\xff\x37\x05\x77\x6e\xfa\xc7\xd8\x52\xbb\x65\xb5\x86\x6a\xe1\xc6\x9b\xe9\x10\x61\x1d\xba\xb6\x68\xac\x7a\x93\x0a\xed\x72\xe9\x8c\x9a\xf0\x97\x88\x48\xf2\x12\x6b\xea\x79\x6e\x0d\xd3\x85\x2f\xfa\x6e\xeb\x0c\xb5\x33\xfe\x91\x85\x32\x71\x18\xce\xcd\xb6\xd2\x13\xee\xbd\x82\x64\xd7\xc7\xec\x35\xb0\xd2\x6b\x48\xab\x66\x79\xcc\x94\x3b\xf5\x13\xf9\x37\x3c\x33\x5c\x0a\xa6\x0e\x50\xca\x2a\x6f\xe5\x9c\xd2\x51\xac\x9a\x88\x12\x17\x39\x7e\xc4\x1c\x36\x87\x14\x05\x17\xfa\x49\xb6\x55\x34\xaa\xfb\xc0\xb2\x8c\xbc\xa3\xcd\x02\xae\x60\xc7\x54\x37\xef\xeb\x60\xda\xce\x09\xfa\x78\xff\xed\xa4\x89\x7c\xe7\xad\xa3\x9d\xee\x65\x9e\x6b\x8f\xc3\x27\x45\x3c\xd0\x2a\x92\x28\x61\x54\x8a\xa8\xc5\xb8\x34\x12\x89\x3e\xbc\xa8\x99\x62\xdb\x80\xe8\xb5\xcb\x12\xa3\x49\x5c\x60\x03\x06\x19\x2a\xc3\xb8\xe8\x93\xc0\x90\x54\xa8\xc8\x20\xc4\xd9\xf5\x03\x53\x2a\xd9\xdc\x97\xc7\x72\x43\x72\x88\x88\xe0\x9e\x57\x15\x81\x4f\x97\x7d\x0c\x84\x9d\x10\xab\xf5\x5a\x96\xe7\x3f\xe2\xde\x06\x82\x45\x28\xdf\xac\x75\xb9\x0a\x42\xab\x9b\x01\x5c\x04\x00\x06\x0a\x0b\x54\x28\x32\x6c\x79\x72\x32\xd7\x92\x22\xb5\x65\xd4\xdb\x58\xa0\xc5\x3d\xc2\x90\xde\x9e\xb9\x74\xdb\xc6\x00\xe0\x42\xf3\x1c\x87\x22\x46\x63\x28\xd5\xb3\x53\xfd\x8c\x05\xdc\x84\xb9\xf4\xc6\xb2\xb6\xb8\x9a\x46\xd5\xe7\xcf\xa1\x66\x82\x67\xb0\xb8\x7c\xcd\x84\x45\x75\x27\x4e\x24\x8c\x13\xc4\xa6\x3a\x3d\xf5\xcb\xab\x21\xe7\xaf\x2d\x6e\xf2\x82\xb8\x25\xd6\xc9\x64\x6b\x85\x3b\x2e\x9b\x28\x9b\x2f\xa4\x02\x43\x19\xbe\x35\x8d\x25\x8d\x10\xd2\x44\xd4\x78\x01\x0b\x8d\x55\xb1\x4a\xb9\xd2\xfb\x56\xda\xd5\x3d\x5a\x8c\x59\x5c\x7d\x80\x9b\x1b\x10\xbc\x1a\xae\x8f\xe7\xac\xd1\x18\xac\x48\x20\xdb\xa1\x46\x60\x1a\x1e\xd0\x71\x45\x3a\x6f\x63\x49\x8a\x4e\x20\x04\x45\x4d\x53\xa2\x18\x3d\x76\x26\xdb\x01\xcd\xd4\x8c\x94\x83\x59\x76\xc2\xd4\x4c\xe4\x3c\x63\xc6\x02\x04\x15\x6b\x36\x2e\x04\xac\x95\x4c\xc3\x06\x51\x24\x45\xb0\x5e\x33\xfa\xc2\x4e\x73\x24\x1d\x1f\xb3\xbe\x9c\x9d\x7c\xb6\x7a\x19\x25\x6d\x56\x53\x16\x9a\x9e\xaf\x98\x4b\x2a\xce\xc8\x69\xbb\x6b\x94\xdc\x06\x1e\xe0\xc9\xc6\xa6\xfa\x08\x58\x69\x4c\x5b\xca\x0f\xad\xf5\xee\x99\x06\x56\x29\x64\xf9\x81\x22\xdc\xd0\x7a\xa9\xf0\x74\xd6\x6b\xfd\x67\x44\xca\xde\x5d\x5c\xde\x76\x9e\xd0\x91\x72\x36\xc8\x6d\x76\x19\xe2\xdd\xc0\x2d\x06\xee\xd5\xa7\x4d\x13\xd0\xd0\x6c\x37\xa8\x28\x1d\x9d\x05\x12\x94\xba\x6e\x0e\xae\x42\x8f\xa3\x75\x49\x05\xbe\x29\x35\xd8\x42\x97\x3e\x1f\x80\xa9\xb6\x02\x8e\x63\x6b\xe2\x4a\xa1\x88\xa5\xe7\x00\x64\x40\x1a\x5c\x0d\x1e\xf3\x35\x35\x9b\xa7\xe6\x97\xd4\xd1\xf3\x1f\x48\xee\x3e\xcf\xf1\x1f\x42\xa2\xf3\x31\x41\xbf\x3a\x50\x75\xbc\xf0\x4c\xbf\xef\x0b\xe6\x0f\xcb\x7e\x6e\x9f\x03\x27\xe0\xe0\x7b\x74\xfe\xda\x6e\x9c\xcc\x95\x75\x14\xd2\x9d\x2c\x37\x94\x55\xbf\x74\xb4\x16\x49\x6b\x5e\xaf\xe1\xad\x54\x80\x2c\x2b\xad\x7a\x97\x34\xc2\x01\x06\xa3\x0a\x75\x10\xb3\x3c\xac\x98\x11\xee\x70\x31\x86\xd2\x67\x7a\xc2\x76\xf2\x2e\xff\x8a\xc8\x90\x09\x13\x0f\x64\xde\x6e\xa9\xc7\x4e\x46\xb2\x05\x3c\xdd\x38\x41\x29\xb0\xcc\x42\x60\xbb\x30\x57\x29\xd7\xfd\x22\x20\x4e\xc6\xca\x3d\x9e\x8f\xc6\x10\xc6\x11\x3f\x33\xc5\x12\x87\xab\x98\x83\x6e\x6c\xca\x58\x34\x55\x75\x58\xad\x56\xa3\xc1\xbc\x98\x83\xe8\x63\xbd\xfa\x89\x57\xab\x15\x2d\x73\x88\xc2\x42\x26\x61\xd8\xe5\x4f\x5d\x38\x9b\x22\x68\x43\x48\xf2\xcb\x79\x20\xfd\xd5\x3c\x94\x0e\x66\xfc\xf5\x29\xd0\x3a\xa0\x77\x04\x61\xdb\xeb\x5c\x31\xe6\xd0\x24\xb0\x15\xf9\x7c\x04\x4f\xd8\x60\x52\x88\x1e\xdf\xd3\x58\xde\x5e\x9f\x81\xe9\xc7\xd1\xf7\x29\x10\x7c\x04\xd6\xc9\x98\xd6\x5e\x8f\xa3\xbb\x8f\xe7\xa1\xe2\xd3\x16\x4c\xa0\x6b\xcc\x78\x71\x20\xa3\xdb\x97\x3c\x2b\xe1\x8e\x14\x77\x47\x88\x73\x97\xda\x69\xb8\x6b\xf7\x8f\x23\x72\xbe\x0a\x72\xa1\x88\x9b\x95\x35\x78\x6e\xc3\x0c\x17\x59\xd5\xe4\x14\x68\xe0\x20\x1b\x15\xb1\x74\xb9\x57\xac\xae\x51\x5d\x0e\x78\x73\xf2\x68\x0a\x2c\x25\xb9\x07\x83\xbb\x17\x96\x87\xb7\x52\xed\x99\xa2\xe2\x78\xe5\xff\x44\x75\xb7\x82\x1f\xdc\x16\x9e\xdd\x9b\xda\xc4\xb5\x5a\xa3\x1d\x53\x72\x87\x6a\xaf\xb8\x71\x7e\xe8\xfc\xce\x18\x96\x95\x7e\xbb\xb7\xab\xf8\xc2\x52\x86\x9b\x52\x36\x26\x16\xb5\x64\x3b\xeb\xa1\xb2\xdf\x71\x60\x51\xf8\x2f\xb8\xd2\x26\x42\xe7\xff\xcd\x3a\x34\x25\x95\xdf\x2e\x6a\x35\x2c\x8b\xa1\xad\x7a\x65\x59\x0b\x8a\x8c\x66\xc4\x4b\xaf\x90\x25\x28\x46\x91\x9f\x9e\x71\x39\xa6\xb7\x51\x5b\xbe\x19\xbb\xd5\xd4\x06\xd4\x0e\x93\xe8\xbb\x88\x9e\x66\x3c\x4f\xc5\xb8\x53\xd9\xd3\x3b\x67\xa2\xe7\x17\xd6\x9f\x93\xf8\x4f\x5c\xc1\x2e\xdc\x38\x3d\x0b\x6b\xd4\xc1\x96\xfe\x5e\xaa\x87\x30\x1d\xa6\x8b\x69\x8d\x2a\xdc\x27\x58\xd9\xad\x42\x0a\x95\x5b\xd4\x9a\xdd\xe3\x35\x5c\xba\xc4\x56\xeb\x38\xd9\xb2\xc0\x4b\x38\x5e\xf1\x7c\x5c\x2b\xb7\x18\x67\x57\xde\x9a\x03\x1a\x54\x21\xba\xc5\x0c\x46\xe3\xa7\xd1\x8a\xc8\x1d\x81\xa7\x27\x2d\x28\x93\xc5\xe4\x29\xd0\xa1\x7f\xff\xa2\xa5\x63\x0a\x62\x7e\x43\x25\x41\x2a\xd8\x52\x76\x38\xbb\xf2\xf2\xb1\x22\x0e\x95\xc9\x26\xc2\x04\xe0\xe8\x69\xc4\xd1\x03\xb2\xa9\xf0\xf1\x17\xc1\x1c\x1d\x81\xce\x08\x72\x48\x93\x73\x41\x87\xf0\x21\x1a\x38\xc6\x9d\x94\x7d\xfc\xf7\xab\x59\x2b\x67\x0f\x02\x5d\x25\x3b\x44\x02\x19\x2f\xa2\x14\x7d\xc1\xf7\x47\x54\xc9\x3e\xce\x1f\x2d\x96\xbd\x68\xae\xd1\xf4\x24\xf1\xfd\xef\xf2\xfb\x74\xf9\xcd\x97\xe7\x57\xe0\xa7\x97\xe6\xef\x1a\x3d\xba\xc6\x35\xfa\x17\x5b\xf7\x59\x45\xfe\x93\x55\xc8\xa7\xab\xe3\xe3\xb9\x86\x7e\xcf\x3f\xcc\x28\x87\x9f\xa8\x14\x3e\xbb\x0c\x9e\x93\x8d\x90\x08\x47\xa2\xd3\x97\xe6\x1e\xe7\x15\xbc\x9f\x5b\xef\xba\xa3\x23\x84\xc3\x33\xca\xdd\xae\x12\x48\xf9\xc7\x53\x36\x08\x47\xdc\xf8\x76\xea\x28\x07\x88\x4e\xd3\x9c\xd7\xce\x73\x43\xff\xfc\xed\x3c\x9f\x8a\x1c\xd5\x3d\xcc\xea\xe6\xfd\x3e\xcd\xbc\xc9\x10\x23\xa1\xe0\xae\xf7\x35\x58\x6d\x27\xe1\xbc\x42\x65\xe5\x1e\x5e\x3c\xe0\x21\xb5\x11\x35\xe2\xe6\x9f\x4f\x59\xb5\x78\x6b\x3b\x59\xb7\xc4\xe7\xb1\xfe\xea\x2d\x30\xff\x68\x10\x41\x60\x78\xcb\x1e\x46\x61\x0f\xa9\x38\xe2\xcc\xc0\x1e\x1d\x91\x0d\xe9\xdc\xd5\x0e\x36\xb1\x52\xb2\x46\xd5\x0f\x48\xec\xba\x24\xa3\x90\x54\x6d\x42\x4b\x10\xc5\xcd\xe9\x68\xe3\x4e\xfa\x50\x9c\xe9\x33\xe1\x24\x9f\x27\x02\xd8\x19\x27\x8f\xa6\x33\xcc\x54\x40\x95\x02\xf5\xe0\x68\xea\x31\x3f\xef\xa4\x18\x18\xde\x39\x16\x70\x73\x04\xa1\x89\xaf\x70\xdb\x7a\x44\x36\x88\x18\xb1\x56\x7d\x93\xd2\x6d\x61\xf4\x87\x7c\xec\x4e\x19\xd7\xa1\x50\xe3\xc8\xe1\x23\x68\xbc\xd5\xe4\x6d\x25\x47\xcd\x55\x4b\xff\x58\xdc\xfb\xac\x7c\x6a\x4a\x9f\x33\x0e\x42\x0c\xd5\xf1\xba\x3d\xe4\x38\x09\x07\x5d\x70\x1c\x68\xa0\x8b\x13\xb1\x75\x7d\xfb\x35\xfd\x3f\xb9\x9b\x70\xd2\xed\x8c\xf2\x3b\x07\xd6\xff\x46\xee\x17\x11\x9b\x93\x03\xc4\xde\xe7\x4b\xce\x7c\x78\x3a\x8a\xed\x24\xb7\xa7\xab\xac\x5e\x1e\xac\xa3\x86\x59\xf3\xd0\x42\xa6\x2b\xea\x94\x3f\xef\xda\x43\x82\xf1\x2e\xa8\x65\xc6\xb4\xc9\x02\xc5\x76\x02\x51\xed\x8b\xe0\xf4\x56\xfa\xb1\xe0\xa1\xd0\x34\x4a\x9c\x13\x37\x96\xdd\xc6\x42\x7b\x04\x34\x50\x6d\xae\x5b\x1d\xb4\xdb\xc8\x54\x3b\xf4\x25\xc3\x12\x6c\xe6\xcd\xab\xca\x1e\x0e\x67\x5c\x44\x1a\x8e\xc8\x79\x42\x23\xe3\x12\x88\x79\xe7\x86\x44\x9e\xb4\x5c\xc8\x46\x9c\x4a\x87\xbe\xec\x60\xe4\x38\xda\xdd\x2a\x8b\xed\x6d\x4d\xeb\x63\xfd\xe8\x44\xf4\xc9\xb4\xa6\x2f\xb7\xa2\x10\x40\x06\x54\x2b\xd4\x04\xea\xee\xc0\x6d\x94\xfa\x0d\x4a\x2f\x5f\x76\x4d\xb9\xf9\xec\x98\x71\x4e\xcc\x4c\x9e\x12\x79\x87\x60\x9c\x62\xa6\xe3\x43\x90\x67\x1d\xd9\xca\xed\x75\xb3\x47\xb7\x57\x77\x9c\xe0\xbc\x6a\xf4\x73\xc2\xe7\xe9\xe0\x39\x59\x8e\xbe\xeb\x5d\xa1\x33\x73\x5a\x4e\xdb\x45\x18\x87\xfa\xf6\x3a\x1a\x29\x57\xe4\x81\xb9\x62\xfb\x45\x7b\x44\xdc\xde\xdd\xb0\x8a\x89\x0c\xaf\xc6\x59\xf0\x54\xa5\xe4\x79\xe4\x45\xdf\xf5\x61\xbc\xf2\x9d\x6f\x2d\xb7\xe4\x7d\x4c\x4b\x31\xb4\xb4\x70\x3a\xf8\x0e\xbe\x59\x7d\x93\x50\x80\x4d\x1b\xa7\xcf\xb8\xc7\xc6\xd4\x9f\x76\x0f\x69\x9f\x9f\xef\xcd\x4a\x23\xaf\xe2\x31\xa3\x39\x7c\x50\x74\xca\x3e\xa2\xba\x1c\xb5\x51\xd2\x7b\xf8\x45\x82\x82\xe0\xd5\x14\xa8\xd9\x66\x8b\x4f\xcf\x87\xf5\x02\x6f\x5b\x89\x36\xea\x73\xed\x1a\x25\xa7\x5a\x66\x73\x10\x63\x1f\xef\xf6\x1e\x6c\x30\x6d\xd1\xc3\xb6\x6f\xf0\xc8\x3c\x5e\x2a\x06\x1b\x29\x2b\x64\x02\xb6\xcc\xb6\x85\x46\x39\x9f\x54\x2d\xf3\xcc\x33\x4f\x71\x3f\x3c\xc8\x78\xd6\xe9\xf2\x81\x71\xf1\xe2\x74\x97\xc7\x9e\xa5\x48\x18\xa5\x17\xa1\x60\x95\xc6\xc1\xca\xa6\x16\xf0\xc4\x3c\x5f\xb5\x2d\xaf\xa9\x55\xfe\x1e\x8d\xf6\x28\xe6\xf3\x0c\xa6\x35\xbf\x17\xed\x02\xd7\x4a\xee\x78\x8f\x66\xe3\xc3\xd4\xf6\x6d\x2f\xca\x24\x90\x10\x94\xa9\x03\x6c\x30\x63\x8d\xc6\x0e\x85\xb9\x59\x52\xc6\xe3\xb3\x8d\x5a\x6a\xed\xa1\x1b\x2a\x29\x1f\xa0\x11\x39\xba\x86\x59\x29\xa5\x3b\xe0\xae\x11\x49\x87\x6c\xaa\x89\xc9\xdd\xab\x1b\x02\xf0\x63\x8d\x99\x2d\xe8\xad\x2d\xd9\x15\x5c\x39\x96\x4a\xac\x6a\x0d\xf7\x0d\x53\x39\xb0\x7b\xc6\x85\xa6\xa2\xb3\xe0\x82\x1b\xac\x0e\x90\x95\x8c\x93\x90\x83\xbe\x07\xd1\x90\xb6\x03\xcb\x85\x33\x8b\x68\xe2\x2d\xab\x78\x66\x8f\xe2\x3c\x70\x1b\x26\x0b\x68\xea\xbc\x2f\x63\x33\xfb\xa6\x5b\xad\x5c\xa1\x5b\x71\x4d\xf9\x99\x76\xee\xb7\x41\xa2\xbf\x65\xb9\xef\xa3\x33\x85\xad\xe5\x09\x57\x76\x14\x4a\x0a\xa3\x4f\x76\x9e\x7f\x3f\x37\x12\x20\x6b\xbb\x55\x5d\x4d\xa6\xa1\x99\x14\xba\xd9\xa2\xea\xfa\x13\x61\x03\xaa\x7d\x1d\x67\x6d\xe5\x64\xc6\xd7\x20\xc8\x15\xc8\xbd\x48\xa6\x3f\x9f\xf3\x4a\xc6\xd8\xfb\xbe\xb2\x6e\x31\xed\xba\x26\xd1\x5f\x86\x74\x54\xfc\x02\xd7\x1b\xed\xf9\x0c\x9b\x90\x94\x99\x19\x57\x7d\xfb\x93\x0c\x12\x1e\x84\xdc\xfb\x76\xa1\x7f\x13\xb3\x3f\x1a\x71\xfa\x8c\x8b\xcb\xc8\x6a\xa6\x9c\xff\x7a\xee\x8e\x98\x54\x90\x5e\x3f\xe0\x41\xf7\x29\x4f\xdf\xa5\xa0\x95\xf5\x65\x71\x34\x76\xce\x2b\xa1\xbc\xf3\x0c\xd7\xc9\xc4\xa2\xc0\xcc\xf0\x1d\xb9\x60\x44\xac\xdd\xbd\x4f\xb3\x7a\xe2\x45\xa8\xc1\x4a\x52\x3e\xd5\x4d\x74\x1b\x36\xb2\xe0\x06\xde\x7f\x18\x75\x5d\x3a\x87\x02\x7e\x64\x55\x57\x56\x3f\x63\x9b\x39\x1a\xec\x3b\xd2\x7d\x24\x9e\xc8\xc4\x62\x86\x57\xac\xae\x51\xe4\x8b\x6e\xfc\x79\x29\x93\x5f\xd5\x98\xe6\x1f\x6e\x86\xc0\x2a\x29\xee\x2d\x2e\xb8\x36\x9f\xef\x6c\xda\x36\x5f\xbc\xf1\x64\xc3\x97\x9f\xb8\x3d\xaa\x93\x2e\x17\x93\xe6\xfc\x32\x34\xdf\x2d\xab\xeb\x36\x07\x38\x62\xb3\x31\x03\x64\x0d\x3e\x75\xef\x42\x9f\xcd\xd1\x9e\xe9\x8e\xef\xf9\xa6\x7a\xfc\x5d\xbc\x93\xe6\x1b\x0c\x1f\x0f\xbe\x81\x4f\xa3\x7c\xb9\x3b\x28\x63\x3b\x9b\xf1\xb9\x96\x8a\x0f\xf6\x79\xff\x34\x2e\xe0\x1b\x4d\xee\xdc\x40\xb0\x49\x32\xd0\xfb\x0c\xf7\x09\x14\x16\xcc\x7f\xce\xce\xd4\x3c\x79\xa6\x38\x3a\xdb\x37\x03\x86\xcf\x70\x53\x0a\xac\x8e\x9c\xcb\xe1\xfc\x71\x03\x7b\x14\x41\xb7\x2f\x73\xba\x4e\x87\x7d\xeb\xd9\xef\x8f\x44\x64\x9d\x8f\x8f\x0e\x9a\xb8\xd7\xff\x89\xe8\x33\x7f\xf3\x59\x37\xf1\x69\xff\x7b\x13\x81\xc7\xdb\x5b\xcf\x53\xf2\x48\xdc\x2a\xe5\x3a\x33\x5e\x45\x85\x4f\x30\x72\x1b\x1d\x0d\xd3\x83\x01\x23\x4f\xe9\x0a\x6f\x3b\x41\xbb\xb3\x30\x00\x99\x09\x5f\x21\x47\x09\xc6\x8e\x2d\x7a\xc0\xcb\x8a\x0b\x7b\x1a\xad\x6f\x9a\xdc\x2e\xc1\xa8\x06\xa7\x5e\x15\x09\x6c\x65\x40\x2a\x65\x21\x94\xd7\x8e\x1c\x6b\xbd\x86\x1f\x04\x37\x9c\x55\xfc\x37\x1c\x1d\x18\x99\x3a\x88\x30\x69\xfa\xb1\x02\xfd\xe4\xc1\xab\xb0\x6f\x23\xc3\xf4\x3f\x43\x41\x39\xa0\x42\xca\xfd\x5c\x8f\x67\x53\x31\xf1\x10\xed\x13\xc1\x4b\x68\x34\x2a\xd8\x36\x9a\xac\xa3\xaa\x3a\x82\xd6\x6c\x3b\x73\xef\x4f\x60\xb8\xa8\x4c\xaa\xc1\x3c\x7c\xa7\xda\xe7\x96\xda\xfd\xea\x42\xf7\x3e\xeb\x45\x68\x5c\x8e\x99\xe0\xd5\x1d\xb2\xab\x17\xc3\x9f\x7c\x88\xd4\xff\xed\xd7\x5e\x82\x68\x54\x28\xfd\x48\xfb\x56\x87\xc1\xaf\x3f\xc0\x0d\xac\x3d\x5b\xeb\x62\xe2\xb7\x26\xe2\xc1\xc9\x9f\xbb\x98\x1a\xea\x1e\x8e\x09\x9c\xf7\xbb\x19\xad\x34\x8f\x17\xff\x09\x00\x00\xff\xff\x0b\xe3\x25\x86\x80\x44\x00\x00" +var _fungibletokenswitchboardCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x5c\x5f\x73\xdb\x38\x0e\x7f\xcf\xa7\x40\xf3\x70\xb5\x67\xb2\xce\x3e\xdc\xdc\x43\xa6\xd9\xfe\xdb\xeb\x4e\x5f\xf6\x76\xda\xec\xf5\xa1\xd3\x99\xd0\x12\x14\xf3\x22\x93\x1a\x92\xb2\xeb\xed\xf4\xbb\xdf\x80\xa4\x24\x52\xa2\x64\x39\xcd\xed\xde\xdd\xac\x1f\xda\xd8\x16\x41\x00\x04\xf0\x03\x08\xd2\x7c\x5b\x49\x65\xe0\xfc\x4d\x2d\xee\xf8\xba\xc4\x1b\x79\x8f\xe2\xfc\xec\xec\xf2\xf2\x12\x6e\x36\x08\x99\x14\x46\xb1\xcc\x80\xd9\x30\x03\xac\x2c\xe5\x5e\x03\x13\xc0\xb2\x4c\xd6\xc2\x80\x91\xa0\x30\x43\xbe\x43\xa8\xd8\x61\x8b\xc2\x68\xe0\x02\xb6\x75\x69\x78\x55\x22\x14\x9e\xae\x25\x68\x88\xb8\x86\x5a\x73\x71\x07\x0c\xe8\xbf\x12\xe1\xf6\x4b\x34\xf9\xea\x9d\xa3\xa7\xbe\xde\x42\xc6\x2a\xb6\xe6\x25\x37\x87\x95\xe7\x88\xeb\xe0\x43\xd0\x1b\x59\x97\x39\xf0\x1c\x59\x59\x1e\x60\x8d\xa0\x8d\x54\x98\x03\x23\x86\x11\xec\xa0\xdb\x88\xfc\xfb\x3d\x37\xd9\x66\x2d\x99\xca\xdb\x99\x7e\xa9\xd7\x25\xcf\x7e\x61\x66\x03\xd7\x70\x59\xd9\x77\x97\x3f\xa1\x40\xc5\xb3\x37\x37\xcd\x53\xb7\x96\xda\xba\x36\xc0\x0d\x64\x4c\x84\xd3\x89\xc3\x7e\x83\x0a\x1d\x97\x67\x2c\xcb\x50\xeb\x05\x2b\xcb\x65\xa7\xc0\x31\x2e\xe0\xcb\x19\xc0\x19\x00\xc0\xe5\x25\xbc\x37\x52\xb1\x3b\x04\x26\x72\x70\x5c\x01\xb1\xa5\xed\xf7\x21\xd9\x12\x4d\xf3\x30\x3d\x70\x15\xbe\x49\x3e\xdc\xc9\x78\x15\xfc\x9d\x7c\x74\xa8\x96\x68\xc8\x60\x0c\x0a\xc3\x4d\x89\xb4\xf8\xf0\x8f\xbd\x40\x75\xe6\xc5\x71\x26\x84\x3b\xfa\xc2\xda\x0f\xd7\x80\x5b\x6e\x0c\xe6\xb0\xdf\xa0\x00\x06\x02\xf7\xb0\x63\x75\x69\xc2\x65\xe5\x1a\x58\x9e\x63\x4e\xd6\xc5\x5a\x5a\x3a\xd0\x99\x42\x2d\x6b\x95\xe1\xaa\xfd\x76\xc8\x95\x9d\xf6\x9f\x44\xfb\x75\x4b\xfa\x25\x91\x5d\x98\x43\x85\x57\x70\x73\xa8\xf0\x22\xa4\x6a\x79\xbf\x82\x97\x79\xae\x50\xeb\xe7\x17\x8e\xe6\xb1\x57\xc7\x77\x6f\xfc\xf2\x04\x35\xa4\x54\xa0\x70\x2b\x77\x98\x43\xa1\xe4\x16\x18\x3c\xaa\x1e\xde\x39\xda\x91\x26\xbe\x5d\x15\x8f\xa6\x8e\x1c\x2b\xa9\xbd\x97\x09\x69\xc8\xd3\x32\xb9\xad\x4a\x34\x98\x1f\x15\xf5\x67\x69\x5e\x37\x0f\xff\xe8\x08\x45\x72\xb2\x2d\x45\xae\x2b\xf8\xf5\x0d\xff\xfc\xb7\xbf\xce\x14\x6d\x5c\x37\x3d\xb9\xb8\x30\xa8\x0a\x96\xa1\x93\x0d\x45\x21\x55\x86\xda\x86\xa3\x2d\x9a\x8d\x74\x56\x4d\x81\x94\xc2\x86\x14\x48\xef\xb3\x0d\x66\xf7\x20\x05\x3d\xd6\x92\x63\x3b\xc6\x4b\xb6\x2e\xb1\x53\x2a\x47\x0d\xb2\xa0\xd8\x99\x30\x02\x1b\x35\x58\xa9\x25\xe0\xe7\x4a\x6a\x3f\x69\x4b\xae\x51\xaa\xe3\x42\xd3\xb4\xcd\x47\x45\x2d\x72\x4d\xd3\x73\x33\xa1\xde\x76\x9e\x4e\xc6\x20\x8e\xf9\x70\xf5\xa5\x55\x67\x38\x74\xc7\x71\x4f\xb3\xc0\x1d\x1a\x6b\x8a\xb4\x14\xfa\x03\x37\x1b\xaf\xc6\xc5\xf2\x0a\xbe\xdc\xd8\x55\xf2\x9f\x7c\x3d\x4a\xe8\x7d\x5d\x11\x78\x61\xde\x51\x0c\xc8\xbc\x92\xb2\x3c\x42\x83\xeb\x21\x89\xc0\x54\x96\x8e\x48\x92\x06\x0d\xf7\xda\x5b\x90\x83\x5e\xc1\x8b\x1e\x8c\x59\x8a\x5f\x97\xa3\xa3\x35\x2b\xf0\xc7\x39\x14\xc6\xbe\x78\x3e\x2d\x1c\xd1\x7f\x25\x95\x92\xfb\x57\x87\xa1\x60\x7f\x19\x03\x5d\x47\xf5\x6b\x6c\xd4\xed\xca\x5b\x9b\xb6\xa0\xe7\x2d\xba\x8f\xf3\x0e\xe3\x9b\x9c\x40\x75\xd6\x17\x9a\xf0\x85\xb3\x7f\xca\x02\x88\x88\x24\x87\xb2\x5e\x91\xe7\xd6\x86\x5d\xe4\xa3\xef\xb6\xce\xa6\x5b\x3f\x19\x18\x33\x13\x87\xfe\xdc\x6c\x2b\x3d\xe1\xce\x81\x48\x76\x3d\xc7\xb4\x03\x83\xbe\x82\xb4\x8a\x2e\xa6\xac\xbe\x5d\x13\x9a\xe6\x47\x9e\x19\x2e\x05\x53\x07\xd8\xc8\x32\x6f\xe4\x1d\xd3\x55\xac\xa2\x88\x12\x17\x39\x7e\xc6\x1c\xd6\x87\x14\x05\x87\x1e\x24\xe3\x2a\x1a\xd5\x37\x90\x26\x17\x59\xc2\x8e\xa9\x76\xde\xd7\xc1\xb4\xad\xf7\x74\x50\xf1\x6c\xd4\x54\x7e\xf0\x56\xd2\x4c\xf7\x32\xcf\xb5\x87\xf4\xa3\x22\x1e\x68\x35\x49\x94\x30\x90\x45\xd4\x62\x68\x1b\x88\x44\x6f\x5e\x54\x4c\xb1\x6d\x40\xf4\xca\xe5\xac\xd1\x24\x2e\x16\x02\x83\x0c\x95\x61\x5c\x74\x29\x69\x48\x2a\x54\x64\x10\x15\xed\xfa\x81\xd9\x28\x59\xdf\x6d\xa6\x32\x55\x72\x8c\x88\xe0\x9e\x97\x25\xe1\x56\x9b\xc8\xf4\x84\x9d\x5e\x29\x8b\x31\x2e\x4e\xb0\x3c\xff\x19\xf7\xd6\xe5\x17\xa1\xa4\xb3\x56\x68\x19\xc4\x63\x37\x17\xb8\x98\x00\x0c\x14\x16\xa8\x50\x64\xd8\x70\xe7\xa4\xaf\x24\x85\x77\xcb\xb2\xb7\xb6\x40\x9f\x7b\x84\x3e\xbd\x3d\x73\x65\x80\x8d\x0a\xc0\x85\xe6\x39\xf6\x85\x8d\xc6\x50\x8a\x69\xa7\x7a\x87\x05\x5c\x87\x39\xfe\xda\xb2\xb6\x58\x8e\x43\xf2\xf3\xe7\x50\x31\xc1\x33\x58\x9c\xbf\x66\xc2\xa6\x06\x4e\x9c\x48\x18\x27\x88\xcd\x9b\x3a\xea\xe7\xcb\x3e\xe7\xaf\x2d\xe8\xf2\x82\xb8\x25\xd6\xc9\x78\x2b\x85\x3b\x2e\xeb\xa8\xca\x28\xa4\x02\x43\x95\x87\x35\x92\x0b\x1a\x21\xa4\x89\xa8\xf1\x02\x16\x1a\xcb\x62\x95\x72\xaa\x8f\x8d\xb4\xab\x3b\x74\x18\xb3\xfc\x04\xd7\xd7\x20\x78\xd9\x5f\x1f\xcf\x59\xad\x31\x58\x91\x40\xb6\x43\x85\xc0\x34\xdc\xa3\xe3\x8a\x74\xde\x44\x95\x14\x9d\x40\x08\x8a\xa3\x66\x83\x62\xf0\xd8\x89\x6c\x07\x34\x53\x33\x52\x22\x67\xd9\x09\xf3\x3b\x91\xf3\x8c\x19\x0b\x19\x54\x44\xda\x08\x11\xb0\xb6\x61\x1a\xd6\x88\x22\x29\x82\xf5\x9f\xc1\x17\x76\x9a\x89\xdc\x7e\xc8\xfa\xc5\xec\x0c\xb6\xd1\xcb\x20\xe3\xb3\x9a\xb2\x60\xf5\x7c\xc5\x5c\x92\x72\x42\x62\xdc\xbe\x06\x19\x72\xe0\x01\x9e\x6c\x6c\xaa\x5f\x01\x4b\x8d\x69\x4b\x79\xdb\x58\xef\x9e\x69\x60\xa5\x42\x96\x1f\x28\xd6\xf5\xad\x97\x0a\x62\x67\xbd\xd6\x7f\x06\xa4\xec\xa7\x8b\xf3\x9b\xd6\x13\x5a\x52\xce\x06\xb9\x4d\x4d\x43\xe4\xeb\xb9\x45\xcf\xbd\xba\xcc\x6b\x04\x24\xea\xed\x1a\x15\xe5\xb2\xb3\xe0\x82\xf2\xde\xf5\xc1\xed\x1c\xc4\x71\x7b\x83\x50\x51\x85\x0c\xb6\x00\xa7\xf7\x07\x60\xaa\xa9\xcc\xe3\x28\x9b\x78\xa5\xf0\xc4\xd2\x73\x50\xd2\x23\x0d\x6e\x6f\x20\xe6\x6b\x6c\x36\x4f\xcd\x2f\xa9\xa3\xe7\xdf\x90\xdc\x5d\xe6\xe3\xdf\x84\x44\x1f\x82\x0e\xfa\xd5\x81\xea\xf3\x85\x67\xff\x63\x57\xb2\x7f\xba\xe8\xb8\xf0\xd9\x75\x02\x18\x7e\x42\xe7\xb9\xcd\xd6\xce\x5c\xa9\x07\xc1\xdd\x49\x75\x4d\x29\xfa\x4b\x47\x6b\x91\xb4\xeb\xcb\x4b\x78\x23\x15\x20\xcb\x36\x56\xd1\x17\x34\xc2\x41\x07\xa3\xc2\xb7\x17\xbd\x3c\xc0\x98\x01\x02\x71\x31\x84\xd7\xa7\x7a\xc4\x8a\xf2\x36\x27\x8b\xc8\x90\x31\x13\x0f\x64\xe8\x6e\xd1\x87\xee\x46\xb2\x05\x3c\x5d\x3b\x41\x57\xd1\xba\xdd\xa1\x99\x80\x63\xbb\x36\xcb\x94\x1f\x7f\x0b\x2a\xa7\xe8\xed\xf1\x74\x60\x86\x30\xa4\xf8\x79\x29\xac\x38\x88\xc5\x1c\x74\x6d\xed\xaf\xa8\xcb\xf2\xb0\x5a\xad\x06\x83\x79\x31\x07\xdc\x87\x8a\xf5\x13\xaf\x56\x2b\x5a\xe7\x10\x90\x85\x4c\x22\xb2\x4b\xaa\xe2\xc8\x96\xa4\x3a\x0f\x97\x9f\xcc\x03\xe6\x80\xd5\x5f\x4f\x07\xe8\x29\x72\x13\x6b\xd9\xbc\x4e\x95\x62\x0e\x4d\x82\x57\x91\xcf\xc6\xec\x79\x12\x74\x70\x9e\x86\xee\xe6\xf5\xd8\x10\x3e\x0f\xaf\x27\x49\x0c\x90\xf9\xe8\xa8\xa1\x2f\x43\x04\x7e\xe9\x4f\x8e\x82\xe3\xe3\x56\x50\xa0\x2b\xcc\x78\x71\x20\x43\xdc\x6f\x78\xb6\x81\x5b\x52\xe8\x2d\x01\xcf\x6d\x7a\x6f\xe1\xb6\xd9\xe0\x8e\x08\xfa\xc2\xc8\x85\x21\x6e\x56\xd6\x0d\xb8\x0d\x32\x5c\x64\x65\x9d\x53\x98\x81\x83\xac\x55\xc4\xd4\xf9\x5e\xb1\xaa\x42\x75\xde\xe3\xce\x49\xa4\x29\xac\x6c\xc8\x69\x18\xdc\xbe\xb0\x4c\xbc\x91\x6a\xcf\x14\xd5\xcb\x2b\xff\x27\xaa\xdb\x15\xbc\x75\x1b\x82\x76\x87\x6b\x1d\x97\x6f\xb5\x76\x4c\xc9\x1d\xaa\xbd\xe2\xc6\x79\xa7\xf3\x46\x63\x58\xb6\xf1\x9b\xc9\x6d\x11\x18\xd6\x34\xdc\x6c\x64\x6d\x62\x51\x37\x6c\x67\xfd\x56\x76\x9b\x11\x2c\x8a\xfe\x05\x57\xda\x44\x30\xfd\xff\x59\x9a\xa6\xa4\xf2\x3b\x49\x8d\x86\x65\xd1\xb7\x56\xaf\x2c\x6b\x41\x91\xd1\x0c\x78\xe9\x14\x72\x01\x8a\x51\xdc\xa7\x67\x5c\xb2\xe9\xad\xd4\xd6\x71\xc6\xee\x42\x35\x61\xb6\x45\x24\xfa\x2e\xa2\xa7\x19\xcf\x53\xa1\x6f\x7e\x1a\xf5\xc1\x19\xeb\xe9\xb5\xf6\x43\x6a\x81\x91\x57\xb0\x55\x37\xcc\xd3\xc2\xb2\xb5\xd7\x32\xd8\x4b\x75\x1f\x66\xc8\x56\x58\xad\x51\x85\x5b\x07\x2b\xbb\xd9\xbc\x58\x5e\xc0\x16\xb5\x66\x77\x78\x05\xe7\x2e\xd7\xd5\x3a\xce\xba\x2c\x00\x13\x9e\x97\x3c\x1f\x96\xcf\x0d\x06\x5a\x1b\xb0\x86\x81\x06\x55\x88\x7e\x13\x69\xca\x38\x9c\x11\xb9\x09\xfc\x7a\xd4\x1a\x33\x59\x5f\x8e\x03\xd3\x60\x7d\xdd\x3a\xd1\xbf\x43\x88\x78\x20\x1e\xcd\xa8\x0e\xe3\x41\xcb\x49\x30\xf9\x0d\x95\x04\xa9\x60\x4b\x39\xe0\xec\x52\xcb\xc7\x84\x38\x24\x26\x5b\x0e\x23\xd0\xa2\xa7\xb0\x45\xf7\x08\xa7\x02\xc5\xff\x08\xba\xe8\x08\x5e\x06\xe0\x42\xba\x9c\x0b\x2f\x84\x04\xd1\xc0\x21\xc2\xf4\x6d\x05\x7e\x97\x02\xd6\xca\xd9\x85\xfb\xb6\x78\xed\xc7\x7c\x19\x2f\xa2\x14\x5d\x65\xf7\xc7\x16\xc6\x3e\xa2\x4f\xd6\xc7\x5e\xc8\x8f\x64\xbd\x9f\x1e\x25\x92\xff\x59\x71\x1f\xaf\xb8\xf9\xc5\x9f\x45\xf7\x1f\x5c\x74\x3f\xa0\x92\x3d\x56\x5a\x4e\x63\xbb\xfe\xc8\x3f\xcd\xa8\x4f\x4f\xac\x4d\x4f\x2c\x40\x4f\xc0\xf8\xe6\xd5\x61\x3d\x49\x30\x5e\x12\x7e\x63\x1d\x7a\x5a\x0d\x3a\x34\xeb\x99\x95\xa6\x3b\x00\x42\xa8\x38\xa3\xd0\x6c\x33\xf0\x94\x11\x3f\x66\xaf\x6e\xc0\x8d\xef\x6c\x0e\x10\x39\x3a\x1b\xf3\xd0\xce\x9a\x23\xf2\xdf\xdf\x59\xf3\x29\xc2\xe4\x2a\xc0\xac\xc6\xda\xef\xd3\x57\x1b\x0d\x29\x12\x0a\xee\xda\x50\xbd\x75\x77\x12\xce\x2b\x10\x56\xee\xe1\xc5\x3d\x1e\x52\x9b\x44\x03\x6e\xfe\xfe\x98\xd5\x82\xb7\xbb\xa3\xf5\x42\x73\xbe\x6a\xa4\x62\x98\xb3\xb7\xf5\x47\xd4\x0f\xcd\x5f\x91\x07\xdd\xb0\xfb\x54\xa0\x70\xab\x6b\x8f\x6b\xc8\x9a\x54\xe9\x52\x75\x9b\xbd\x28\x59\xa1\xea\x06\x24\xb6\x33\x92\x61\x46\xaa\x26\x7f\x24\xa4\xe1\xe6\x78\x38\x71\x07\x67\x28\x90\x74\x89\x67\x92\xcf\x23\x11\xea\x41\x47\x7b\xc6\x13\xba\x54\xec\x94\x02\x75\xef\x78\xea\x94\x23\xb7\xf2\xf4\x2c\x0b\xae\x27\xf0\x95\x26\x0b\x76\x81\x07\xc6\x11\xb8\x79\xac\x33\xdf\xe4\x73\xf5\x7e\x77\x6c\xc6\x6e\x30\x71\x1d\x32\x7a\xbe\x3c\x1b\x89\x7b\xf1\x16\x8d\x37\x85\x1c\x35\x57\xcd\x04\x53\xd1\x6a\x4c\xde\xf1\xd8\x15\xc7\x2c\x08\x82\x56\x22\x02\xb7\xf1\xa8\xcf\x7f\xeb\x8a\xf1\x92\x3f\xfb\x8e\xfe\x1f\xad\xad\x8f\xfa\x84\x51\xbe\x8e\xb6\xce\x31\xf0\x8d\x88\xd8\x1c\x04\x8e\x5d\xc3\x97\x5f\x79\xff\x98\x10\xdb\x49\x6e\x8f\x19\x59\xc5\xdc\x5b\x2f\x0a\x13\xcb\xfe\x02\x8f\x57\x97\x29\x67\xdb\x35\x67\xe4\xe2\xbd\x3f\xcb\x8c\x69\xa0\x9a\xe2\x29\x01\x97\xf6\x05\x61\x7a\x03\x79\xca\xb3\x15\x9a\x5a\x89\x53\x9c\xfa\xa2\x2d\xb2\xc3\x3e\x8b\x57\x6d\xae\x1b\x1d\x34\x9b\xa7\x94\x5e\x77\x59\xf5\x05\xd8\xec\x96\x97\xa5\x3d\xab\xcd\xb8\x88\x34\x1c\x91\xf3\x84\x06\xd6\x25\x10\xf3\xd6\x8b\x88\x3c\x69\xb9\x90\xb5\x38\x92\x8c\x3c\xe2\x61\xc0\x61\x30\xba\x51\x16\x5b\x9b\x0a\xcf\x07\xe5\xc1\x49\xe3\xa3\x69\x45\x57\x9d\x44\xce\x4c\xc6\x54\x29\xd4\x04\xaa\xee\xe0\x6a\x94\x84\xf5\x2a\x15\x5f\xa5\x3c\x46\x54\x4b\x1f\x84\xf8\x80\x60\x9c\xc0\xe3\x41\x20\xc8\x5f\x8e\x17\x73\x6f\x0b\xca\xc9\xec\xde\xd4\x34\xc1\x79\x45\xd9\xd1\xf8\x36\x5e\xa2\x7d\xe8\x4c\xb7\x35\x4b\x52\xb9\xdd\xeb\x1e\x06\xd6\xe6\x35\x19\xd9\x56\xe4\x31\xb9\x62\xfb\x45\x73\x1c\xda\x7e\xba\x66\x25\x13\x19\x2e\xe7\xd7\x15\x9e\x47\x5e\x74\xbd\x09\xc6\x4b\xdf\x9d\xd5\x72\x4b\xde\xc2\xb4\x14\x7d\x6b\x08\xa7\x83\x1f\xe0\xfb\xd5\xf7\x09\x05\xd8\xd4\x2a\x75\x9e\x3b\x29\xb0\xcb\xad\x62\x6b\x49\x97\x4d\x29\x99\xd3\x4f\x3e\x30\x0b\x1b\xea\xcf\x47\x35\xa7\xfd\x09\x5d\xe6\xa8\x8d\x92\xde\x2d\xcf\x12\x14\x04\x2f\xc7\x50\xc9\x76\x06\x7c\x4e\xdb\x4f\xb2\x79\xd3\x01\xb3\x61\x9b\x6b\xb7\xab\x7f\xac\xd3\x33\x27\xe4\xef\xe3\xad\xcb\x83\x8d\x86\x4d\xf8\xb7\xbd\x06\x9c\x98\xc7\x4b\xc5\x60\x2d\x65\x89\x4c\xc0\x96\xd9\x1e\xc6\x20\x8f\x92\xaa\x61\x9e\x79\xe6\x29\x70\x87\x07\xf1\x92\xc7\xa0\x2d\x03\x4d\xd9\x96\x3a\x09\xfd\x4a\xca\xb2\x67\x7a\xbc\x38\xde\x9f\xb0\xa7\x04\x12\x26\xeb\xe5\x29\x58\xa9\xb1\xb7\xcc\xa9\xd5\x3c\x32\xcf\x93\xa6\x59\x33\xb6\xe4\x3f\xa1\xd1\x1e\x93\x7c\xd6\xc0\xb4\xe6\x77\xa2\x59\xed\x4a\xc9\x1d\xef\xb0\x69\x78\x46\xd8\x5e\xa9\xa2\xbc\x00\x49\x79\x4c\x1d\x60\x8d\x19\xab\x35\xb6\x98\xca\xcd\x05\xe5\x2f\x3e\x77\xa8\xa4\xd6\x1e\x88\xa1\x94\xf2\x1e\x6a\x91\xa3\x6b\xf5\x6c\xa4\x74\xe7\xb7\x35\x22\xe9\x90\x8d\x35\xe2\xb8\xbb\xc4\x20\x00\x3f\x57\x98\xd9\x92\xd8\x1a\x96\x5d\xce\x95\x63\x69\x83\x65\xa5\xe1\xae\x66\x2a\x07\x76\xc7\xb8\xd0\x54\xb6\x15\x5c\x70\x83\xe5\x01\xb2\x0d\xe3\x24\x64\x6f\x47\x9f\x68\x48\xdb\x45\xe4\xc2\xd9\x48\x34\xf1\x96\x95\x3c\xb3\x87\x49\xee\xb9\x0d\xa2\x05\xd4\x55\xde\x15\x82\x99\xbd\x4e\x56\x29\x57\x2a\x96\x5c\x53\xb6\xa5\x9d\x2f\xae\x91\xe8\x6f\x59\xee\x7b\xc1\x4c\x61\x63\x86\xc2\xe5\xf5\x85\x92\xc2\xe8\xa3\xdd\xd3\xdf\xcf\xa7\x04\xc8\xca\x6e\xbd\x96\xa3\x49\x65\x26\x85\xae\xb7\xa8\xda\x9d\xf7\xb0\xb5\xd2\x5c\x4c\xb9\xb4\x72\x32\xe3\x0b\x02\xe4\x0a\xe4\x5e\x4c\xfb\xdd\x43\xaf\x1f\x0c\x5d\xf1\x89\xf5\x91\x71\x3f\x36\x89\x36\x29\xa4\xe3\xe5\x37\xf8\xe1\xa0\x0c\xe9\x77\xdb\x28\xd1\x32\xae\xea\xf5\xad\x79\x09\xf7\x42\xee\x7d\x5f\xcc\xdf\x7d\xec\x7a\xfd\xc7\x8f\x6d\xb8\x04\xab\x62\xca\x39\x73\x73\xcf\x92\x95\x52\xdc\x59\xef\x74\xcd\x03\xdf\x39\xb1\xcd\x83\xb8\xd2\xb6\x46\xe4\x27\x6e\x9a\xfe\xe9\x14\x3c\x69\x3f\x2f\x83\xad\x7b\xd8\xb2\xaa\x6a\xc2\xf2\xc4\x61\x83\x98\x01\x32\x6d\x9f\x2a\xb5\x06\x68\xa1\xf3\xa9\x6e\xf9\x4e\xb2\xf1\xad\x77\x87\x7a\xe6\x40\xb9\x18\x16\x05\x66\x86\xef\xb0\x3f\x7c\x38\xf8\x1a\xbe\x0c\x12\x9c\xb6\xeb\x6e\x9b\x27\x71\x93\xbc\xe4\xbd\xcd\x2b\xf2\xac\xd6\xcd\x81\x4f\x98\xd7\xea\x1e\x0f\xa9\xb6\xc7\x24\x04\xb5\xa4\x3b\x7c\x18\xcf\x1e\xed\x05\x1a\xdb\xa4\x0c\xaa\xd0\xde\x22\xa4\xf7\xc8\xc7\x14\x16\xcc\x3f\x99\xb7\x87\x6c\x8e\x4d\x34\x95\x56\x7a\x33\x1c\xe5\xe3\x04\x57\xa4\x80\xed\xc8\x39\xb4\xf4\x2d\x4b\xdb\xce\xd4\xcd\x1d\x30\xb7\x2b\x6b\x6f\x5e\xfa\xba\x32\x22\xeb\xfc\x78\xd0\xac\x76\xb7\x99\x89\xe8\x53\xff\xe1\xd3\x76\xe2\xe3\x3e\x16\x5c\x11\x92\x05\xbc\xb9\xf1\x3c\x25\x0f\xd0\xac\x8e\xba\xc7\x8c\x1b\x71\xf0\x05\x06\xae\xa1\xa3\x61\xba\x37\x60\xe0\x0d\x64\xdd\xcd\x82\xff\x67\x0c\x3c\xa4\x7e\xd4\xc6\x79\x11\x71\xb3\xe2\xfa\x7d\xbd\x26\x35\x2e\x64\xe1\x00\xe7\x59\xba\x66\xfe\x61\xb1\x9c\x3a\xe6\xd9\xd3\x4a\xcc\x14\x5c\x83\x51\x75\xfa\x50\xe7\xf0\xf8\xdf\x03\xd9\x0c\x7a\x98\x93\x9c\xd2\x1a\x36\xb4\x5d\xb5\x39\x5b\xb5\x0d\xac\x3d\x99\x24\xae\xeb\x75\xc3\x4b\x6b\x62\xd6\xba\xe0\x3a\x9c\x78\x35\x66\x82\xa3\xc4\x6d\x91\xd8\x11\x6f\xad\x69\x6c\x3e\x6f\x4d\x63\xe4\x60\xba\x71\x4f\x36\x17\x4f\xf6\x68\xc6\xd2\xbc\xfa\x46\xd3\x9b\x6f\xd2\x6e\x9a\x57\xda\x7e\xc6\xbf\x99\x7f\xdc\x14\x82\x84\x27\x66\x74\x2c\x96\xbe\xf3\x41\x73\xbf\x41\x9b\x56\xbb\x1c\xdd\x86\xbb\x3b\xbe\xf3\x31\xd4\x5e\x18\xc9\x32\xac\x4c\x77\x45\xb1\x91\xba\x17\x99\x83\x5d\xc2\xcc\xfd\x8c\x04\x56\xee\x16\xa7\x25\xe4\x7f\xd0\xe1\x5f\xb5\x6e\xe2\xb5\x55\x17\x11\xcd\xb1\x88\xb6\x3a\xbe\xe1\x46\x6f\x22\x3b\xe8\xa9\xa3\x71\xa1\x59\x06\xed\x37\x7b\x3a\x1c\xb9\x1e\x98\x81\x2b\x1a\x47\x73\xd4\xf6\xf1\x78\xdd\xfc\xbd\x9f\xa8\xa6\x4c\xb7\x74\xa9\x2c\x1a\x04\xc8\xcb\x4b\x78\x2b\xb8\xe1\xac\xe4\xbf\xe1\xe0\x24\xcd\xd8\xb9\x8c\xd1\xd0\x11\x03\x81\x9f\x3c\xb8\x28\xfc\x26\x42\x5b\xff\x53\x21\x54\x42\x28\xa4\xd2\xc1\x35\xd9\xd6\x25\x13\xf7\xd1\x46\x21\xbc\x84\x5a\xa3\x82\x2d\xad\x79\xc6\xca\xb2\x25\x68\xb1\xb8\xc5\xf0\xee\x40\x8a\x4b\x27\x49\x25\x98\x87\x97\xd2\x7d\x69\xa2\xdd\x2f\x61\xb4\xb7\x7d\xcf\xfa\xd6\x62\xb7\x05\x2c\x53\xc1\x75\x26\xc2\xc9\x17\xfd\x9f\xe5\x88\x16\xe9\xd9\x77\x5e\x92\x68\x54\xa8\x85\xc1\x2a\x58\x5d\x06\xbf\xcc\x01\xd7\x70\xe9\xd9\xbb\x2c\x46\x7e\x0f\x24\x1e\x9c\xfc\x69\x92\xb1\xa1\xee\xe1\x98\xc0\x69\xbf\x71\xe2\xa5\xf9\x7a\xf6\xef\x00\x00\x00\xff\xff\x0b\x41\x31\xcf\x18\x46\x00\x00" func fungibletokenswitchboardCdcBytes() ([]byte, error) { return bindataRead( @@ -153,11 +155,31 @@ func fungibletokenswitchboardCdc() (*asset, error) { } info := bindataFileInfo{name: "FungibleTokenSwitchboard.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3, 0x82, 0x5f, 0x8b, 0xf8, 0x65, 0x9c, 0xcf, 0x94, 0x17, 0x96, 0x18, 0x59, 0xab, 0xcb, 0x2a, 0x7b, 0x4a, 0x76, 0xb9, 0x69, 0x19, 0xab, 0x8e, 0x80, 0x45, 0x8e, 0xe2, 0xaf, 0xf8, 0x6c, 0xdf}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x41, 0x6e, 0xba, 0xd8, 0xc5, 0xc5, 0xea, 0x2b, 0x18, 0xd1, 0x2b, 0x1b, 0x4c, 0x66, 0x2a, 0x3e, 0x9a, 0x98, 0x8a, 0x38, 0xe1, 0x41, 0xd7, 0xdf, 0x8c, 0x6, 0x85, 0xf, 0xe3, 0x84, 0xfa, 0x10}} return a, nil } -var _utilityMetadataviewsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x3d\x6b\x73\x1b\xb9\x91\xdf\xfd\x2b\xda\x4a\x95\x23\x5d\x28\x52\xde\xec\xb9\xee\x58\xcb\x38\x5e\xdb\xca\xea\xca\xf6\xa9\x64\x39\xb9\x2a\x97\xcb\x02\x67\x40\x12\xd1\x0c\x30\x0b\x60\x44\x31\x2e\xff\xf7\xab\x6e\x3c\x06\xf3\xe0\xc3\x8e\x77\xcd\x0f\x16\x39\x03\x34\x1a\x8d\x7e\xa3\x01\x8b\xb2\x52\xda\xc2\x79\x2d\x97\x62\x5e\xf0\x6b\x75\xcb\x25\x2c\xb4\x2a\xe1\xa8\xf5\xec\xe8\x81\x6f\xf9\x46\xc9\xa1\xc6\xdd\xc7\x47\x0f\x1e\x4c\x26\x13\xb8\x5e\x09\x03\x99\x92\x56\xb3\xcc\x82\x28\xab\x82\x97\x5c\x5a\x03\x76\xc5\xa1\xe4\x96\xe5\xcc\x32\x30\x96\xc9\x9c\xe9\x1c\x2a\xad\x2a\x65\x78\x4e\x7d\x85\x84\xf3\x57\x17\x97\xa7\x67\x4f\xfe\xfc\x64\x4c\x4f\xe8\x9f\x2b\xbe\x98\xc2\xca\xda\xca\x4c\x27\x93\xa5\xb0\xab\x7a\x3e\xce\x54\x39\x51\x72\x51\xa8\xf5\x64\x51\x88\xca\x4c\xe6\x85\x9a\x4f\x4a\x26\xe4\x84\x55\x55\x21\x32\x66\x85\x92\x93\x1f\xce\x7e\x78\x7c\xf6\xdf\x8f\x9f\x9c\xca\x85\x3d\x0d\xa3\x8f\xcb\xbc\x01\xfe\xd6\xea\x3a\xb3\x06\x98\xcc\x41\x73\xa3\x6a\x9d\x71\x03\x19\x93\x0d\xee\xa0\x24\x07\xa5\xa1\x54\x9a\x53\x9f\x38\x0d\xbb\xa9\xb8\x19\x41\xc6\x8a\x82\xe7\x70\x27\xf8\xda\x8c\xe1\x25\xcb\x56\xf4\x9d\x5e\x83\xe6\x95\xe6\x06\x49\x40\x7d\x19\xe4\x62\xb1\xe0\x1a\xe1\xde\x0a\x99\x83\x5a\x44\x78\x23\x30\x75\xb6\x02\x66\x80\x41\xa6\x39\xb3\x4a\xc3\x5c\xa8\xa5\x66\xd5\x6a\x43\xbd\x95\x06\x06\xff\x73\xf9\xf2\x6f\x20\x4a\xb6\xe4\xb0\x10\x05\x27\x4a\x3d\xa8\xea\x79\x43\xf6\xd7\x1e\xe0\xdf\x11\x23\xf8\xf4\xe0\x01\x00\x00\xf6\xbf\xd4\xea\x4e\xe4\xdc\x00\xcb\x32\x6e\x0c\x58\x05\x0c\x0c\xb7\x29\x16\x61\x1e\xcf\xc0\x10\x6d\x70\xd0\x08\x20\x90\x08\x8e\xf9\x78\x39\x06\x26\xe1\xcd\xf9\xf5\x49\x87\x5e\x16\x79\x40\x48\xcb\xf5\x82\x65\x1c\x07\xa9\xdc\xb8\xc9\xb0\x11\x22\xf2\x05\x8d\x08\x76\xc5\x2c\x08\x0b\xa6\xae\x90\xf1\xcc\x38\xb4\xa1\xbf\x38\xc1\x38\x7a\x03\xfc\x8a\x1b\x55\xdc\x71\x0d\x9f\xa8\x55\x68\xb9\xa8\x25\x2c\xb9\x25\x02\x1c\x9f\x4c\xe1\xfd\xf5\xa6\xe2\x1f\x7a\x4d\xb4\xeb\x8d\xcd\x8e\x3f\x12\x1a\x53\xc0\x96\x27\x53\x78\x26\x37\x8e\x37\x9e\x52\xaf\xcf\x0d\x11\x9f\xc1\x52\xab\xba\x42\x9a\xd1\x32\x7b\x20\x1a\xe7\x9c\xf3\x7b\x9e\xc3\x7c\x03\x17\x2f\xbe\x08\xfd\xe7\xaa\x28\x78\x86\x3c\x3b\x30\x91\xb9\xd2\x5a\xad\x11\xc9\xd0\xfc\x58\xe4\x53\x78\x77\x21\xed\x93\x1f\x4f\xa6\xf0\xe8\x53\x78\xfe\x79\x88\x08\x17\x2f\x1c\x09\x5c\xfb\x0f\xdd\xe9\xbc\x39\xbf\x46\xd0\xb0\xd6\xac\x32\xc0\x8a\x02\x9e\x2b\x1d\xd6\x84\x15\x4a\x2e\xe1\x46\xe4\x37\x24\x21\x37\x75\x8d\x5f\x17\x82\x17\xb9\x19\xd1\x23\x61\xa0\x36\x3c\x4f\x16\x54\xc1\x52\xdc\x71\xe4\x61\x85\x2c\x61\x39\x54\x22\xb3\xb5\xe6\x48\x31\xc7\x31\x63\x78\xad\x8c\xc5\x6f\x06\xcc\x4a\xd5\x45\xde\x65\x9f\x08\x0e\xf1\xe8\x93\xd2\xb3\x66\xc0\xbd\x4d\xb3\x82\x5b\x68\x08\xd4\x7b\x85\x73\xd8\xfa\x32\x17\xa6\x2a\xd8\x66\x0a\x2f\xdc\x97\xa7\xbd\x16\xfc\xde\x72\x2d\x59\xf1\xee\xea\xd5\x14\x5e\x36\x3f\xfa\x2d\xb3\xb8\xa8\x2f\x98\x65\x53\xc4\xf6\x79\xeb\xd1\xce\x2e\x01\x91\x76\xaf\x6d\x58\x69\xb5\x61\x85\x15\xdc\x4c\xe1\x2a\x7c\xed\xb7\xb2\x9a\x09\x6b\xa6\x70\x4d\x7f\x9f\x3e\x88\x0d\x84\x14\xf6\x38\xfe\xa2\x27\x39\x04\x22\x8d\x5a\x2f\x90\x7c\x5b\x5e\x79\xe2\x41\x43\xbd\xf6\xfb\x84\x74\xd0\xa6\x5d\xbb\x5d\x9b\x70\x30\x44\xb9\xad\x1d\x22\x0a\x83\x74\x6b\x77\x8b\x44\x83\x94\x6a\xed\x36\x5d\x92\x85\xe7\x27\x09\xd3\xe1\xc7\xf0\x62\x31\x16\x39\xcc\x40\xe4\xfd\x17\x44\xb4\x19\xd1\xae\xff\x32\x90\x6d\x16\x08\xd8\x6f\x92\x52\x6e\x96\xd2\xb1\xdf\xb4\x43\xbc\x59\x87\x9a\x3b\x3b\x44\x44\x7a\xcf\xfa\xdd\x1a\xe2\xcd\x1a\x42\xf6\x9b\x39\xfa\xc1\xcc\x13\x32\x36\xf8\xdc\xd5\x43\xbf\xf0\xa2\xe2\x9a\xd4\x07\xb7\x5e\x4f\x38\x05\xdb\x92\x7e\x6c\xfa\xd7\x8a\x69\x56\x92\x8c\x5f\xaf\x38\x35\xf4\x74\x4d\xde\xde\x25\xfa\x72\x0a\xcf\x40\x73\x32\xbb\xce\x20\xa1\xd5\x09\x7a\x3b\xea\xe5\x06\x82\xe6\xb6\xd6\x12\x9e\x45\x05\xe3\xf4\x4d\x4f\x0d\x79\x0d\xeb\x5b\x25\x5a\x79\xd4\x19\x3e\x51\xd1\x27\x8e\x37\x3b\x7a\x0b\xa5\x53\x2e\xc8\x60\xc1\xac\xd5\x79\x9c\x1a\x29\x34\x4e\x3f\xf9\xde\x7f\x39\x3e\x39\x69\x04\x78\x11\xbb\x3f\x9c\x81\x14\x45\x87\x3d\xfd\x8c\x7c\x9b\x87\xc0\xcc\xc3\x80\x45\xb2\x24\x0f\x3a\xcd\xc3\xc4\xfa\x9a\x41\xe4\x7d\xad\x30\x6d\xe3\x8d\x8f\x06\xf5\xc3\xd4\x71\xc6\x92\x5b\xcf\x5c\xc7\x69\xbf\x93\x5d\x3a\x23\x74\x4c\x74\xc7\xae\xce\x3d\x45\x12\xfa\xf7\x14\xca\x81\x50\xa2\x76\x19\x06\xb4\x7f\x3a\xa9\xca\x09\x30\xa2\xea\xd9\xd5\xd1\xcb\x51\xd3\xcb\x29\xa4\x76\x97\x46\x3b\x75\xa5\x2b\x60\x2e\xd0\xb9\x9c\x33\x23\x32\xef\xa3\x92\xd3\x25\xb3\xa2\x46\xb7\x10\xc5\x42\xb2\x92\x8f\x20\xe7\x26\xd3\xa2\x22\x8f\x84\xc9\x3c\x71\xd7\xea\x72\x2e\x99\x28\x60\x81\xce\xa8\x04\x35\xff\x27\xcf\xac\x37\xe8\xee\xc7\x36\x9b\xbe\xd3\x94\x07\x04\x3f\x35\x4c\xe8\xe2\x09\x87\x11\xfa\x0e\x88\x5d\x18\x2e\x6d\xd4\xe9\x20\x8c\x73\x50\x60\x2d\x8a\x02\xe6\x3c\xb0\x1d\xcf\x31\xc2\x28\x84\xf1\xee\xbe\x5d\x71\xcd\x17\xe8\xeb\x38\x74\x5b\x60\xe6\xf4\x54\x93\x22\xca\x94\xcc\x84\xe1\xe3\xc1\x31\x83\x69\x45\x24\xa7\x18\x4e\x08\xb9\x6c\x4f\xe1\x19\xac\xb5\xb0\x96\xcb\x16\x51\xbf\xd5\x7c\x18\xe4\xdc\x32\x11\x02\x90\x36\xdc\x51\x0b\x94\x51\xe4\xa8\xcf\x39\x85\x32\x70\xc7\xf5\x5c\x99\xe8\xca\x03\xaa\x4d\x8a\x35\x40\x48\x63\x39\xa3\xd8\x84\x81\x11\x72\x59\x70\x28\x84\xe4\x27\xbb\x49\x90\x4c\x6f\x1b\x25\x4c\x89\x0e\x66\xc3\x44\x31\x3a\x62\x03\x44\x39\x84\x26\x9e\xd3\xe6\xe8\x6f\xae\xf9\xfc\x74\xa1\x05\x97\x79\xb1\xa1\xd0\x08\x8e\xc5\x98\x53\xbc\x34\x82\xcb\x37\x7f\x3b\x69\x01\x21\xce\xf7\xf4\xe8\x73\xc8\x08\x27\x7c\x0b\x95\xe6\xe4\x08\x8f\x80\xdb\x6c\xf7\xec\xe3\xa4\x92\xd8\xe1\xd3\xb9\x28\xf8\xe7\x5d\x6e\x56\xca\x36\x1d\x65\xd9\xa7\x66\x47\x23\x6c\x1f\x30\x34\x19\x74\x52\x48\x9c\x66\x34\xf2\x80\x2f\x92\xb0\xe8\x2c\xc5\x61\xc0\xb2\xc7\x55\x9c\x35\xb8\x1c\x6a\xdf\xa3\x3e\x42\x0e\xa6\x38\x9a\x2d\x38\xac\xbd\xa3\x31\x60\xec\xbf\x85\x39\x97\xa0\x68\x2e\xac\x88\xe3\xef\x36\xec\x41\xa1\x7f\xdc\x6d\xce\x83\x77\x99\x50\x5b\x2c\x88\x29\xee\x0e\xb1\xe7\xbe\x3b\xda\xf3\xce\x7a\x05\x28\x1e\x04\x30\xf3\x34\x51\x94\xd0\xf9\xf8\x69\xde\xb5\x5e\x7c\x7e\xd0\xff\x16\x9c\x01\xbf\x5c\xc9\x22\xfd\x8d\x4b\xae\x45\x96\x46\xef\x28\x26\x4d\x12\x03\x98\x93\x2c\x63\x95\xe6\x39\xa0\xcc\x6a\x50\x8b\x05\x64\x2b\x26\xe4\x18\x90\xff\x92\xe8\xcd\xcb\x17\x45\x88\x56\x35\x8b\x66\x5c\x02\xc3\xa0\x9f\x94\x73\xe5\x14\xb2\x42\x8d\x0c\x25\xcf\x05\xdb\x6a\x26\x1a\xc4\x70\xa4\x81\x60\xb9\xd6\x02\xa3\x5d\xaf\x7e\x3a\xd3\x23\xff\xc8\x2a\xe0\xf7\x15\x6a\x3e\x3f\x17\x67\x03\x43\x52\x44\xcc\x0b\x0e\x8c\x14\xff\x2f\xd7\xd7\x97\x70\xac\x34\x7d\x79\x7b\x02\xef\xae\x5e\x8d\x61\x1b\x66\xd8\x06\x71\x9a\x0e\x61\x46\x71\xa7\x2e\xfa\x6a\x91\x34\x42\xf2\x66\x50\x62\x6b\x8d\x32\x56\xeb\x62\xc8\x55\x1b\x9c\xf8\xb0\xf7\x17\x80\x6d\x17\xd2\x61\x02\x35\x8b\x7d\x71\x79\xfe\x36\xae\x0d\xfd\xf2\x0b\x09\x4c\xf3\x66\x79\x29\x05\x62\x57\x5c\x68\x4a\x4a\xa1\x07\x20\x72\x2e\xad\x58\x08\xae\xe1\xf8\xf9\xc5\x8b\x93\x08\x44\x33\x5a\x76\xbb\x62\x64\xcc\x84\xe6\x99\x85\x77\x57\x17\x63\x78\x06\x59\x21\xb0\x6f\x92\xd2\x23\x8e\xaa\x0d\x77\x1e\xc5\xf3\x8b\x17\x69\xde\x61\x21\x64\x4e\x9c\x54\x28\x46\xf6\xdd\xa7\xc9\xee\x04\xc3\xe5\x24\x74\x97\xcc\xf2\x35\xdb\x6c\x65\x30\x6c\xd4\x5a\xc6\x96\xd1\x78\x7e\xf1\x02\x39\x05\x41\x0f\x4c\x0c\x5d\x22\xc2\x8b\x46\x72\xc9\xb9\xa4\x77\x0b\x52\x2b\xab\x99\xab\xcc\x8c\x45\xb5\x30\x63\xa1\x26\xe8\x6e\xf0\xca\x9a\x89\x1f\xe1\x94\xe5\xb9\x46\xc6\x94\xcb\xc9\x4e\x0b\x94\xa1\x0b\x3e\x64\x77\x2f\x99\x5d\x11\x83\x27\x0a\xb0\xc2\x67\x5e\x75\xd2\x22\x27\xd9\xa9\x48\x2c\xb7\x1a\x4a\x6f\x0e\xb2\xc5\xc2\x80\x92\xc5\x06\x24\xe7\x39\x9a\xd2\x45\x03\x9c\x12\x82\x86\x52\x80\x87\x00\x3d\x80\x38\x08\xf6\xd4\x6c\x8c\xe5\xa5\xd9\x4d\x16\x9c\x69\xa0\x4b\x37\xe5\x91\x90\x6c\xd4\x6e\x38\x28\x88\x19\x45\xf1\xd9\x50\x10\x4f\xf4\x9c\x11\x8c\x21\x29\x6d\x48\x55\x4b\x97\xe7\x73\x32\xe9\x78\x89\x88\x2d\x99\x15\x77\x1c\x95\x4c\xc3\x48\x3d\x1e\xda\x41\x9a\x95\x5a\x9f\x5a\x35\xf1\xdc\x72\x8a\x8f\x4f\x95\x3c\x5d\xf3\xf9\xe4\x0f\x0e\xf6\x69\xad\x0b\xb3\x95\xe8\xc1\x4c\xa2\xcb\x6d\x9c\x16\x41\x0e\x64\x42\xe2\xd7\xb8\x94\xb5\x16\x5b\xc9\xbd\x4f\x0f\x79\x7b\xe6\x69\xd5\xd0\x6d\xab\x2d\x3b\xc2\x59\x4c\x27\x93\xa3\x31\x2e\x3c\xb3\xc7\x61\x19\x4e\xc2\x83\xa3\xc9\x51\xfc\x8e\xb0\x4e\x3a\xd6\x6f\x48\x0f\x6e\x87\xba\x5d\x33\xfe\x6f\x10\x1c\x32\xc4\xb8\x40\x4d\x58\x18\x72\xd7\xc6\xd4\x1c\xca\xba\xb0\xa2\x2a\x82\x17\x6b\x22\x84\xb5\x40\x89\x43\xe2\x52\x3c\xa3\xc1\x88\x52\x14\x4c\x27\xf9\x7f\x04\xcb\xef\x19\x86\x4d\x28\x83\xff\x87\x0e\xf1\xe3\xb3\x33\x30\xdc\x8e\x1d\xfb\x44\x68\x42\x2e\x94\x2e\x9d\x4e\x74\x39\xd8\x45\xed\x82\xb2\x35\x2b\x0a\xee\x63\x9c\x92\xe9\x5b\x6e\xab\x82\x65\xbc\xc9\xa7\xa3\x23\xf4\xe6\xfc\x1a\x4a\xb1\x5c\x59\x34\xcf\x15\xd3\x6e\x0b\x20\xa0\xce\x73\x41\xf3\x1a\xc1\x7a\x25\x32\xd2\x1d\xeb\x15\x69\xf4\xf0\x6a\x2b\x22\x8e\xc4\x3c\xa7\x6d\x0c\x09\x4c\xcf\x85\xd5\x4c\x6f\xc0\x88\x7f\xe1\x53\xad\x3b\x3e\x5e\xa2\x7b\x5f\x7a\xd8\x7b\x62\x40\x8f\x42\xab\xcd\x79\x43\xb9\x91\x13\x9d\x2c\x04\x06\x6f\xb9\x1d\xc1\x65\xc1\x36\x23\x78\xcb\xb5\xe0\xa6\x1d\x15\x51\x18\xbb\xf1\xce\xc7\x9a\x6d\x30\x12\xd2\x0a\x97\xce\x83\xc8\x0a\x66\x8c\x58\x6c\x00\xe3\xef\x40\x99\x9d\xf1\xdf\xd3\x3e\xfe\x81\x6c\xb2\x2e\xe7\x5c\xef\x08\x74\x68\x26\x4c\xc2\xd1\x0f\x3f\x86\xd5\x3f\xfe\xc3\x0f\x3f\x4e\x1e\x9f\x9d\x9d\x1c\x81\xb0\xbc\x1c\xb9\x30\xdd\x01\x12\x06\x7e\xf8\x71\xdc\xc7\x86\xde\xc6\x2c\x77\x0f\x9d\x92\xdd\x0f\xa2\x84\xb6\x6d\x53\x11\xa5\x3d\xfb\x8e\xf7\x44\x5e\xa4\xf1\x91\x87\xdc\x16\x4f\x4e\x2c\x58\x88\x52\x58\x9e\x9f\xfa\x21\xd0\x77\x18\x82\x76\xc0\x54\x11\x51\x61\xf0\xdd\x60\x57\x6c\xe4\x04\xab\x96\x7e\xd0\x30\x2f\xd7\xb7\x89\x0f\x0d\xc6\x68\x0a\x9d\xde\x36\xa4\x1e\xed\x4a\x76\x1f\x08\xd7\x35\x17\xad\x45\x1e\x75\xa8\x3c\x6a\xf5\x1c\x70\xe5\x11\x9f\xc1\xe4\x1c\x7e\x98\x31\x5c\xdb\x63\xbf\x18\x3f\xcd\xb0\xf5\xc3\x11\x94\xdc\x18\xb6\xe4\x53\x38\xba\x6e\x16\x3d\x63\x52\x2a\x92\xdc\xa5\xe6\xcc\x06\xef\xc9\xfa\x85\x75\xad\x1e\x1e\x75\x55\x61\xfa\x6b\x7f\x24\xe8\xc7\x9a\x79\x70\xfd\x06\x38\x14\xa1\xb9\x5d\x69\xfe\x43\xb3\x0a\x83\xbe\xa8\x33\xa3\x86\x09\xa2\x4e\xd1\xf5\x83\xd6\x5a\xf4\x15\x82\xe9\x6a\x84\x67\x89\x62\x39\x75\x8a\x05\xa3\x76\x9f\x93\xda\x24\x2c\xdd\x93\xd7\x18\xfa\x5b\x9f\x39\x8e\x5a\x90\x05\x3d\xd8\xe3\x08\x54\x71\xaf\x84\xb1\x53\x78\xef\x31\xfa\xd0\x61\x8c\x8f\x43\x6d\x86\xb7\x08\x7c\x3b\x98\xc5\x2e\x87\xc6\xcc\x91\x1a\xdf\x2b\x68\x8e\x08\xec\x8e\x9a\x43\xb3\x7d\x61\x73\x68\xf7\xb5\x71\x73\xe8\x7f\x60\xe0\x9c\x30\x53\x57\xf8\xbe\x41\xe4\xfc\x77\xb7\x15\xec\xe3\x64\x74\x7d\xa2\x1d\x39\xcd\xf9\x42\xa0\x12\x34\x5c\x0b\x56\x04\xee\x24\x66\x05\x53\xf1\x4c\x2c\x44\x86\xbc\x18\x81\x5d\xba\x8e\x06\x56\xec\x8e\x27\x15\x03\x04\xc8\xcf\x82\x4c\x3d\x32\x32\xeb\xc0\x8d\x2a\x2f\x82\x7b\xab\x4a\xd4\x0c\x1b\x1f\x38\x71\xb7\xf1\xaa\xf9\xb2\x46\xf7\xe3\xe2\x05\xb9\x0a\x26\x6d\x94\x96\x29\x34\xc1\xbc\x33\x84\x21\x12\x73\xce\xf7\xd8\xf9\x8b\x2d\x0c\x84\xc1\x00\x92\x67\xd6\x45\xfd\x73\x0e\xb5\x14\xbf\xd6\x1c\x58\xa9\xe4\xb2\x01\xe8\x6c\x2e\x21\x83\x3a\x5c\x48\x27\x99\x9e\x6c\xdb\xbc\x84\xb7\x6e\xac\x7e\x80\xbd\xcd\xe8\x79\x09\x6d\xbf\x1e\x4e\x8d\x6d\xd1\x79\x7b\x04\xd3\x63\xf4\xbd\xc4\xd2\x0f\xbf\x5b\x28\x5d\xa3\x7d\x22\xe9\x5a\x7d\xad\x40\xba\xde\x07\x8a\x63\x6f\x19\xff\x7d\x61\xc4\x7f\x3b\xa9\x0c\xe4\x27\x27\x7e\x21\x6a\x2f\x2b\x65\xd8\x1c\x03\x5e\xda\x76\xd9\x34\xc5\x48\xd4\x78\x29\xee\xb8\x69\xf9\xcd\xc0\x1a\xa0\xb5\xc4\x48\x3f\x6f\x57\xb7\xf8\x82\x15\xb2\x26\x71\x7f\x67\x6b\x82\xe1\xca\x0f\xdb\x31\x69\x21\xf3\xd6\xae\xb5\xba\xe2\x19\x17\x77\x31\xb5\xc0\x61\xce\x25\x5f\x88\x4c\xa0\x47\xed\x9d\x48\x3f\x8f\x76\x9e\x82\xd1\xa2\x87\x44\x45\xa6\xb9\xe5\xd1\xb3\x73\x1c\xe6\x01\x93\xf3\x14\x7e\xd1\xbe\xd2\xa6\xe2\xc7\x27\x9d\x98\x33\x53\x65\xc9\x65\xee\x04\xff\x14\xde\x19\xae\xe3\x2e\x0f\x95\x2a\xa1\xca\x90\x7c\xed\xb2\xe6\x4e\xb3\x9d\x17\x6a\xed\x66\xd1\x02\xa6\xdb\x53\xa2\xd8\x05\xd5\xe5\x4d\xdc\x09\xdb\x84\x59\x5f\xd6\xf3\x42\x64\x97\xcc\xae\x8e\x4f\x6e\x5c\xb9\x09\xfa\x3d\x2d\x70\x41\xa5\xe5\x7c\xc1\xea\xc2\x26\xa3\xc6\x49\x39\xaf\x95\x76\x4f\x58\x51\xa8\x35\xf6\xd1\x54\x85\x54\x57\x39\xa2\xde\x71\x0e\x38\x64\xac\x62\x73\x51\x08\x4b\x09\x6a\x0a\x7d\x6b\xaa\x60\xc1\x3e\xa4\x1e\x69\x07\x65\xe9\xd7\xac\x69\xde\xd3\x49\x01\x89\x29\x3c\x8f\x8d\x7e\x7a\xf4\x4c\x6e\xae\xbc\x64\x7f\x6a\x2d\xf8\x38\x4c\xfd\xf3\x5f\xda\xec\xf1\xda\x39\x4e\x82\xeb\x98\x4c\xcd\x58\x91\xd5\x05\xe2\x8f\x08\xb2\x52\xd5\x92\xa2\x38\xc3\x0a\x0e\x77\xac\xa8\x39\x58\xcd\xa4\x59\x70\xad\x5d\x8f\xf6\x3a\x78\x3e\x6c\xc8\xf4\x46\x59\x0e\xa7\x70\x61\x13\xaf\x79\xce\xed\x9a\x73\x09\x67\xe3\x33\xa2\xff\xe3\xf1\x59\x1b\xcc\xcb\x7b\xec\xb2\xf0\x81\x6d\x1c\x59\x18\xb8\x77\x11\x68\x83\xb8\x30\x70\x36\xfe\xcf\x27\xd8\x54\xa6\x9c\xdb\x06\xe8\xfa\xaf\x03\x02\xd4\xe3\x3f\xe0\x7e\xdc\x97\x16\x56\x14\x1b\xa8\xb8\xce\xb8\xb4\x6c\xc9\x89\xe1\xa3\x05\x76\x7b\x39\x96\xeb\xd2\x20\x51\xe6\xcc\x08\x03\x95\x12\xd2\xb6\x7d\x41\x21\xc1\xa8\x42\xe4\xb8\xd6\x73\x86\xa4\x35\x25\xba\x81\xa1\x98\x0e\x23\x5f\x51\x20\x4b\xe4\xa4\xa1\x15\x9a\x45\x03\x37\xef\xce\xc5\xfd\x93\x1f\x6f\xba\xbc\x83\xf6\xb8\xd0\x9c\xe5\x9b\x58\xc7\xe6\xe4\x36\x19\x9f\x58\x28\x63\x06\xa9\x9b\x31\xfc\x81\x91\x65\x3b\x28\xad\xb8\x66\xce\xce\x33\xcd\x01\x3d\x0a\xcd\x8b\x0d\xe4\x1c\x67\x24\xa4\x30\xd6\x67\xe9\x97\xe8\xe7\x26\xad\xd1\x92\x7b\x7d\xd4\x96\x93\x0a\x39\xe0\xbf\x02\x0a\x6a\x01\x95\xe6\x99\x30\x42\xc9\x7e\xf8\x98\xd5\x76\x0a\x6e\x86\x6d\x36\x8c\x59\x90\xd6\xee\x94\x2b\xfa\x74\xa9\x7e\x27\x3e\x38\x29\x1c\x82\x6d\x42\xee\xc8\xaf\xf5\xa8\x27\x6b\x9a\x17\x0e\xf7\x95\xa8\x22\xbb\xe1\x8b\x1b\x97\xc8\xb8\x09\x9b\xb5\xa8\x5f\x47\x3e\x5c\x47\x67\x61\x09\xbc\x30\x7c\xd8\xb1\x57\x6b\xc9\xb5\x77\xed\xd7\x4c\x52\xe4\xe7\x3c\xad\x4d\x7f\xb6\x3b\xf7\x2d\xc9\x79\xf8\x7a\x29\x1e\xa5\xb4\x1c\x0d\x0d\xd5\xb5\x95\x95\xe6\x03\x46\x31\xab\x2d\xfc\x65\x46\x62\xf8\xe8\x11\xfd\xfa\x69\x46\xc2\x38\x85\xa3\xe7\xb5\xf5\x52\xd3\xc8\xad\x90\xf8\x48\xe4\xa0\x99\x5c\x72\x10\x63\x0e\xef\xcf\x46\x8f\x3f\x1c\xed\x8b\x09\xa3\x7a\x9e\x45\xcd\x30\x90\x07\xad\x31\x7e\xc9\x6a\xdb\x7f\xb5\x7f\x03\xf1\x0b\xa2\xc4\x60\x2b\x5d\x49\x6a\xec\xf0\x3a\xb5\xce\xc8\x77\xbf\xd6\x5c\x6f\x9c\x31\xb9\x89\xd5\x14\x37\xc1\xe2\x52\xc1\x32\x79\x99\x11\x02\xb2\x14\x09\x56\xe2\xa6\x56\x6c\x93\x94\x67\x38\x5d\xa0\x88\x15\x0d\x8f\x6e\xba\x63\xd5\x3d\xc6\x1d\xfb\x77\x23\x56\xad\xd9\xc6\xf3\xa7\x66\xd9\xad\xd3\x0a\x42\xe6\xe2\x4e\xe4\x35\x2b\x06\x4a\xa8\xdc\x76\x14\xe5\x26\x4f\x82\x54\x5e\xc8\x85\x32\x53\x78\xef\x09\xf3\xa1\xbd\x0d\xe4\x1d\xdd\x81\x76\x5d\x26\x43\xff\x08\xd9\xc3\x59\x0f\x66\xc1\xd4\x25\x6d\xf7\x17\x05\x31\x57\xa3\xb5\xa3\x99\x1f\xca\x38\x3c\x1e\x9f\xb5\xc0\xde\x31\xf4\x89\x2d\x2b\x9e\x13\x83\x9c\x75\x5e\xe3\xda\x06\x9d\x2f\x64\xc4\x73\x80\xdd\x13\x20\xf1\xeb\x9f\x42\xdf\x71\x97\xf1\xda\x6c\xec\x33\x29\xb1\x9f\x13\x94\x34\x95\xf2\xd6\x4d\x36\x8e\x7f\xf8\x6c\x3b\x39\x15\x5c\x58\x63\xc4\xd2\x29\xac\x00\x6f\x50\x5e\xdc\x48\xb3\x7e\xa3\xce\x26\xc1\x95\x73\x6a\x53\x78\x94\xdb\x48\x1b\xb5\x3a\x24\x11\x01\x25\x57\xd3\xa4\xbd\x2b\xb6\xe0\x09\x5b\x3b\x3e\x1d\xde\x04\x48\xa2\x85\xa6\x24\xe9\x24\xe1\xa2\x1d\xbb\x8a\x03\xd3\x82\x5d\x21\x53\x23\x28\xbf\x6b\xd4\xd4\x04\x4d\x57\x1d\x92\x6c\x8b\x9b\x1a\x4a\xec\x09\x9d\x9a\x02\xd2\xaf\x8c\x9e\x22\x80\x03\x03\xa8\x54\xd7\x74\xe5\xe7\x9b\x94\x02\x38\x53\xea\x36\x0a\x49\x47\x44\xeb\x42\x2e\x28\x49\x33\x99\x08\x64\xb5\xb6\xfe\x8a\xb9\x62\xaa\x37\x6b\x40\x90\x13\xce\xef\xb8\xb4\x35\x79\x6f\x29\x2c\x16\xfd\x69\xb3\x16\x36\x5b\xcd\x15\x06\x65\xc1\x08\x8d\x22\xdc\x95\x5b\xf3\xb0\x29\x30\xaf\x3d\xd8\x90\x89\x6e\x90\x8b\x04\xc2\x5f\x52\x75\x8a\xcf\xba\x7b\x5e\x4d\xb4\x11\xa3\xad\x80\x10\x06\x76\xa9\x31\xdc\xca\x27\x83\xa1\xcb\x34\x05\xfd\xa9\x4b\xfa\x49\x45\x2f\x27\x3e\x00\x3c\xbf\xbe\x4a\x47\x1a\xd8\x9b\x8f\x2e\xee\x28\xec\xcf\x53\x0c\x47\x85\x6a\x5a\x73\x53\x29\x91\xe3\x8a\x50\x21\x05\x72\xd6\x56\x6b\xf5\x1a\x5b\x74\x2d\x15\x6d\x7b\x07\x02\x10\x8c\xad\xca\x02\x59\x72\x41\x7b\xe5\x5b\x2b\x9e\xdc\x79\x99\x5c\xb0\x53\x8a\x3e\x33\x55\x72\xe3\xad\x2a\x0e\x42\x7a\x18\xdf\x4c\x4c\x3d\xa7\x16\xcc\x78\xa7\x61\xce\x73\x58\x71\xdd\x89\xce\xe2\xce\x27\xbf\xe3\x05\xfa\xbd\xe3\x52\xfd\x4b\x14\x05\x1b\x2b\xbd\x9c\x70\x79\xfa\xee\x2d\xed\x8a\x4e\xfe\xc1\xe7\x93\x5f\xae\xaf\x2f\x27\x3f\x33\x23\x32\xf3\x51\x2d\x3e\xd2\xcf\xd7\x17\xaf\x5f\x7e\x24\x75\xb3\x73\x5a\x91\x78\x5b\x3c\xc2\xc1\x69\x8f\xfa\xdd\xda\x82\x4c\xaa\x12\xbb\xce\xf0\x9f\xee\x8b\xd8\x79\x16\xbf\x7d\x8d\xd3\x44\x9d\xdb\x89\xf5\xc1\x85\xff\x37\xb2\xea\x8e\x71\x84\xe5\x65\x7f\x23\x8c\x9e\x4e\xe1\x3d\xb5\x19\xc8\x93\xb7\x5e\x0f\xa7\xc8\xb1\x09\xcc\x3a\xf0\xf7\x18\x14\x3f\xa5\xef\x64\x4d\xfc\xe8\xbb\x4d\x89\x6b\xb4\xcf\x8e\xb8\x56\x5f\x6b\x44\x5c\xef\x03\x2d\x48\x64\x03\xe8\x7c\xbe\x55\x3e\x3c\xd5\x56\xc0\xa0\x10\x19\x97\x86\x8e\x81\x29\x4d\x3a\xca\xaa\x28\xd1\xa6\xca\xef\x49\x88\x7d\x2b\x33\x69\x5b\x12\xc2\x3a\xad\x27\xf3\xf5\x25\xa1\x0e\x27\x1e\x2e\x42\x9b\xe3\x61\xe4\x5b\x55\xdf\x2b\x8f\x4a\x3f\x8b\x8c\x78\x5c\xc4\x9a\x9e\x2d\xe2\xff\x31\x29\xfb\xd9\x59\xba\xd5\x86\x46\xa7\x43\xc2\x8f\x43\x39\x3b\xa0\xfa\x9d\x58\x3b\x0c\xbf\x9b\xb7\x7d\xab\x7d\xcc\xed\x9b\x7d\x2d\x77\xfb\xee\x07\xb2\x77\x7f\x8d\x7f\x03\xfe\x8e\x95\x72\xef\xae\x5e\x39\xfa\xa2\xd7\x63\x79\x09\x54\x39\x1f\xcf\x2f\x80\x11\xb6\xb1\xc4\xad\x94\x09\x71\xf3\x7c\x93\x96\xb9\x21\x07\xdf\x72\x18\xc7\x8a\xb6\x9f\x0b\x95\x21\x74\x15\x2a\xe4\x5c\x0e\x33\xc2\xf3\x2b\xab\xb4\x58\x0a\x1c\xad\xc9\xc3\xba\x03\x77\xdb\xe4\x20\x39\x48\xf1\x45\x25\x8b\x1f\xe1\x80\xa2\xc5\xd9\xce\x5a\xc3\xce\xe6\x66\x82\xc8\x77\xe2\xf4\x14\x85\x3d\x3b\x9c\xc9\xf1\x93\x7d\x9b\x9c\xc9\x29\xb7\xaf\xdd\xe7\x6c\x40\x1c\xba\xd5\x39\xb8\xaa\xbf\x1d\xf7\xbb\x5c\x46\x53\x07\xe4\x2b\x00\xa9\x6e\xd4\x1f\xad\xb6\x5a\xf0\x3b\xde\x65\xc7\xfd\x72\x60\x15\x18\x6e\xeb\x0a\x18\xe9\xf6\xa6\xe8\xca\x79\xbd\x95\x46\x27\xb0\x91\x03\x1c\x92\x2d\xdd\xa0\xce\xb1\x6e\xb2\xf3\xbb\x76\x65\x7a\x07\x82\x12\xba\x35\x25\x94\x32\xc2\x5f\x93\x6b\x4a\xc2\xee\x4d\x8e\x0e\x9b\x24\x71\xd3\xd3\x95\xcd\xf6\xf3\x8d\x1e\xc6\xa5\x2f\x37\x8c\x3f\x3a\x45\x9b\x0e\x7b\x8a\x9d\x5c\x15\x56\x59\x1b\x4a\x4a\xa0\x6c\xbb\x41\x3c\xf9\x07\x26\x1a\xcb\x79\xc2\xb6\x32\xc4\x7c\x77\x56\xd4\x64\x7b\xe3\xbe\x17\x4d\x20\x6c\x68\xf9\xba\x31\x5f\x92\xe6\x4e\x01\x37\x2f\x7b\x73\xa9\x62\x64\x93\x46\x39\x9d\x99\x68\x71\xc7\x2c\x4f\xa7\xd2\x84\x92\xbd\xc9\x50\xcc\xe9\x8a\x89\x74\x0b\x4c\xb2\x29\x63\x15\xad\x7e\xae\xd9\xda\x25\xf6\x28\xc5\xe7\xbc\x81\xc8\x1f\x2b\x55\xd0\x3c\xb1\x41\x1f\x6f\x3f\x82\xc7\xdc\x61\xb8\x75\x11\x12\xa8\x14\xa4\x84\x8a\xf1\x56\xfa\xd0\x9f\x71\x37\xf5\x62\x21\x32\xaa\x5b\xd6\x9c\xe5\xa7\x14\x96\x36\x07\xdf\x03\xd5\x5b\xc3\x84\xa2\x50\x03\xc7\x39\xaf\x94\x11\x16\xfe\xe4\x8f\x6e\xc3\x9f\xfc\xf9\xef\x37\xe7\xd7\xed\x5d\xb9\x76\xe5\x2d\xea\xfa\x39\xcb\x6e\xd7\x4c\xe7\x86\xb6\x39\x99\x15\x9e\x5c\x24\x29\xbd\x72\x45\xaa\x2d\x90\xca\xfa\x0d\x25\xaa\xfa\x1c\xc0\xad\x7b\xd1\xc3\xb8\x91\x13\x4f\x9d\x66\x33\x74\xbd\xe2\x12\xc5\x95\xea\x1f\xea\x2a\x1d\x73\x4c\x25\x5b\x32\x39\x6e\x48\x6b\xda\x34\xf0\x65\x7b\x25\xdb\x24\xd5\x5a\x73\x0e\xfc\xd7\x9a\x15\x41\x9f\x13\xf5\x7d\x2e\xd6\xed\xf0\xdc\x38\x0e\x7c\x45\x6c\x84\xea\xf2\xa6\x2f\x70\xae\x49\x83\xb7\x3b\xe4\xdf\xa9\x8a\x8b\xeb\xda\xe3\x4d\xbf\xa7\xc0\x16\x4a\xd3\x69\x36\x57\xd1\x56\x35\xf2\x39\x8e\xb9\x0e\x89\x2a\xb0\xc0\x05\x6f\x01\xd7\xdc\x58\x2d\x1c\xa7\xe0\x38\xb4\x20\x25\xc6\x54\x8d\x68\xd1\xfe\x1b\x9b\x17\xae\xcc\xf2\x06\xb5\x64\x97\xd2\x37\xed\xdd\x13\x6a\x13\xb2\x05\x7e\x7f\xf4\xa6\x75\xf7\xc3\xb8\x7f\xbf\xc0\x4d\x4b\xd4\xa9\x68\xff\xd7\x5a\x0c\xea\xa9\x2e\x65\xbf\x0d\xd9\x12\x65\xd0\xa7\x5b\x0b\x36\x1b\xa6\x1b\x95\xbc\x94\x42\x8a\xb2\x2e\x1b\x5a\xf9\xab\x2d\x74\x32\xbf\xad\x42\xbf\x7b\x4a\xe7\xa1\x42\xdb\xef\xe6\x15\x6a\x6d\xdc\x26\xb7\x3f\xa2\x86\x5e\x5d\x59\xd9\x4d\xd7\x20\x05\xad\x80\x08\x04\x33\x40\x36\xa0\x05\x3e\x68\xe5\x81\x5d\x37\x4a\x36\xbf\x44\xd0\x29\xaf\x1e\x1f\x9f\x4c\xe1\xaf\x3b\xc4\xf0\x64\xd7\x01\xb3\x6d\xc6\xa6\x7d\x96\x6c\x58\x8d\x77\xda\x6c\x53\x99\x43\xa0\xba\xc2\x36\xd4\xa6\xbb\x0c\xc3\xc3\xed\x6e\x35\x48\xb3\xb0\x82\x07\xd1\x2e\x40\x3a\x6c\x1f\xae\x8b\xf9\x58\x98\xb7\x2e\x73\x75\xac\x16\x0e\xc1\x9f\x1e\x7d\xda\xab\x33\x47\x7d\xb5\x1a\x04\x79\x04\xfb\x44\xf8\x33\x7a\x81\x53\x38\xf2\xea\x97\x24\x83\x7c\x03\x7f\x8e\x77\xbf\xca\xde\x39\x3c\xaa\x91\x7d\x28\xa4\x7a\xeb\xa8\x4f\xa4\xde\xd2\x1d\x48\xa6\x20\xc4\x03\xf8\xf5\xa7\x70\x30\x99\x3c\xd0\x43\x08\xf5\x45\x08\x7c\x19\xa1\xc6\x7b\xb7\x5e\x13\x51\x9d\x25\xdf\xfb\x0d\x1b\x69\x9d\x35\x5f\x07\x9a\x25\x02\x0b\xb3\x96\xfc\x6e\x83\xd9\x20\x3e\xeb\x3e\xd8\xd6\xa5\x59\xe4\x59\xf7\xc1\x76\x94\x9a\x36\x09\x62\xbb\x3a\x0e\xca\xf9\x6c\xa7\xf4\x1f\x1a\x79\xf6\x5d\x7f\x8a\x3f\xd7\x61\xbf\x96\x36\x17\x7c\x28\xc4\x9c\x03\x98\xc7\x42\x88\xdf\x27\x32\xed\xa3\xb8\xf7\x42\x8a\xce\xf5\x06\x7b\xa2\xd4\xfe\x05\x2b\x5f\x19\xab\xf6\x00\x1d\x18\xb1\xee\x8a\xbf\xc2\xe7\x77\x8b\x5b\xd1\x6e\xaf\xd4\x9a\x4a\x74\x82\xb9\xfe\x63\xb3\xb1\xd5\x98\xfc\xf1\x41\xf1\xab\xbb\x0e\x49\x82\xba\xe3\xda\x4d\x58\x26\xf7\x25\xd1\x91\x7b\x91\x99\x50\x99\xd7\x73\x2a\x7c\x88\x39\xe7\x85\x92\x4b\x04\x78\x60\x10\xdb\x3b\x27\x8c\xce\x3c\x2b\x7b\xee\x1a\xa1\x4d\x9e\xbb\x3f\x06\xef\x4a\x76\xfc\xb0\xc9\x64\x7b\x0e\xcb\xb6\x3b\x0f\xe0\x45\x52\x04\x32\x34\xda\x10\x51\x42\xc0\xba\x6b\xc0\x3d\x37\x0c\xc4\xbc\x87\x4b\x7f\xd1\xed\x66\x3e\x2d\x47\x43\x50\xd1\x5e\xba\xde\x6c\xae\x6a\xbb\x7f\xd8\x6d\x57\x3e\xb5\xc6\x7e\xfb\x6b\xcd\x34\xf7\xfb\x26\xee\xdc\x69\x2b\xfd\xbd\x77\x14\x43\x00\x2e\x4a\xaa\x51\xa0\xd4\x7c\x0b\xfe\xcf\x4c\x4a\xae\x5b\xf0\x63\x05\x65\x03\x76\xd4\xcd\x43\x50\x94\xc7\xe8\xf4\x15\x48\xce\x34\x3c\xfe\xe1\xec\xec\xfe\xc9\x9f\xcf\xfa\x08\xcc\x69\x84\xad\x08\xbc\x55\x99\xf0\xa4\x35\x6e\x6a\x2c\x5b\x75\xc7\xff\xa3\x01\xe3\xda\xad\x54\xc9\x2b\xb6\xe4\xad\x33\x3f\x70\xa9\xfc\x09\xeb\x5b\xbe\x89\xc1\xde\x91\x90\xc6\xb2\xa5\x66\xe5\xd1\x08\x8e\xec\x5a\x58\xcb\x35\x7e\xcd\x85\xc9\x94\xce\x8f\x3a\xd7\x2f\x44\x8a\xd1\x48\x66\x0a\x9f\x1c\x2f\xb4\x16\xe7\xb7\xba\x76\x61\x1b\x33\xb4\x5b\xf5\x17\xb3\xfd\xbe\x4f\xeb\x4e\xff\xdd\x53\x0b\xcd\x7e\xd3\x0b\x1e\xbe\xe0\xd2\xa9\x64\xba\x30\x4b\x27\xdf\x6f\x9a\xcc\x1c\x66\x29\x1d\x06\xa0\x3a\x22\x20\x44\xf7\xed\xeb\x4c\x7a\x7a\xd5\xc4\xb0\x55\xf7\x46\x3d\x42\xfb\x8e\xd6\xfd\x8b\x2c\xfb\x61\xd7\x53\x0c\xde\x84\xf6\x4d\xec\xfb\x17\x5d\x5c\xb1\xc7\x3a\x85\xcf\xb7\xb7\xf2\x9a\x69\x57\xc9\xdd\x28\x7e\x7f\xf6\xc6\x5d\x6d\xe3\xde\xc7\xde\x54\x06\xed\x62\xff\xd0\x15\xfd\x02\x13\xb5\x29\x17\x74\x6e\x05\x55\x13\x9d\xe3\x4d\x45\x6a\x5e\xd3\x1d\x96\xe8\x11\x44\x80\xd4\x69\xae\xbc\xd7\x3d\x54\x35\xe8\x46\xf9\xd4\x49\xef\xf1\x30\x84\x2f\xd9\x77\xad\xe8\x7a\xd0\xce\xf9\x94\xa8\x10\xb1\x7d\xa8\x36\x1d\x38\x85\x5a\xb2\x7b\xca\x9a\xb8\x6a\x51\xb5\x70\x1d\x7a\x60\xdc\x39\xc6\x6d\x40\x06\x6e\x31\x4a\x51\x73\x47\xc7\xf7\x5c\x18\x10\x0f\xe7\xbe\xe2\x4b\x2e\x73\xa6\x37\x23\x78\x59\x61\x50\x75\xc5\x34\x1f\xc1\x3b\x89\x46\x0c\xcd\xd9\x73\xfa\xdb\x3e\xa5\xeb\x4f\xa7\xd3\x2c\x0e\xf1\x11\xba\xc7\x38\xdb\x64\x1a\xb5\xe6\x3b\x58\xa3\x3b\x74\x9a\xd3\xad\xcd\xcc\x9d\xe7\x7c\xf4\xa8\x45\x96\xd9\xb6\x53\x9e\x15\x93\x22\x3b\x3e\x7a\x16\x96\x3c\x32\x96\x09\xab\xd7\xbe\x7a\x4b\x69\x62\x9c\xde\x51\xce\x01\x5d\xe9\xd0\xe9\xac\x28\x6c\x3f\xac\x09\xff\x46\xc5\x6e\xa7\x96\xcf\xcd\x85\x04\xfd\x7b\x55\xf3\x39\x14\xf6\x94\xf2\x51\xa3\xbd\x75\x7c\xd4\xea\xab\x8b\xf8\xa8\xf7\xa1\x15\x7c\x5d\xb9\x0f\x9f\xdf\xa8\xfe\xc2\xeb\x3b\xb7\x67\x90\x5e\xf9\xeb\xb6\xaa\xfb\x1b\x73\xe1\x72\x57\xbf\xd0\xfe\x0e\x3a\xb5\x48\x0b\x97\x6f\xf9\x66\xe2\xf4\x49\xc5\x84\x0e\x57\xc6\x52\xa6\xd6\xa8\x92\x27\x51\x93\xb4\xfc\xde\xd6\xac\x20\x0f\x96\xc6\x0d\xfe\x37\x77\xa0\xb7\xe9\x47\xba\xea\xae\x1d\xc8\x74\xef\x04\xa0\xfe\x63\x78\x25\x6e\x39\xfc\xcc\xb2\xdb\xa5\x56\xb5\xcc\x47\xf0\x72\xc3\xcd\x08\x7e\x61\x42\x6f\xf1\x21\xb7\xc6\x30\x38\x42\x2d\x73\xae\x8b\x4d\x54\x36\xad\xd1\x46\x81\x4d\x6d\x78\xec\xee\xc5\x75\xd7\xa6\x51\x93\xb8\x29\xe4\x27\x1f\x78\x9b\x80\xf5\x71\xa1\xc7\x49\x55\x59\x0b\x1f\x1f\x9c\x51\xce\x24\x59\x17\x0c\x54\xdd\xd9\xcd\x30\x86\x23\xea\xda\x1d\x85\x10\xc6\x91\x09\x43\x4e\x37\x85\xc8\x10\x29\x70\xb4\x87\xe4\x84\xcb\x8c\x8f\x60\xa3\x6a\xaf\xa1\x4d\xc0\xca\x05\x53\xb5\x14\xf7\x60\x45\xc9\x8d\x65\x65\xe5\x32\x60\xfe\x58\x45\x0b\x3f\x66\xe0\xe8\x05\xb3\xfc\x88\x26\xcc\x8b\x22\x1d\xab\x2a\x98\x45\x4b\x4c\x7a\x2f\x53\xd2\xd4\xa5\x0f\xb3\x1d\xcd\xc8\x8a\x50\x65\x7a\x38\xf0\xb5\xd5\xde\x25\x63\x0e\xde\xbd\x10\x24\x0c\xcd\x31\x2b\x8c\x8a\x01\xa8\x2b\xa2\x28\x36\x9e\xf3\x99\xb5\x5a\xcc\x6b\xdb\xba\x6b\xa5\xcd\x0c\x4e\x1a\xa2\xc2\x09\x27\x77\x08\xbd\xa2\x68\x20\x18\xd2\xe9\x7e\x6a\xfe\x59\x58\x76\x4a\x23\x78\x63\xd9\x5f\x7d\xf7\x3c\x2a\xa0\x1d\x57\x0f\x8c\x7a\x9c\x32\x1a\x24\xc5\xa8\x0b\xf3\xcb\xc3\x05\xb7\xf8\xb3\x8e\xad\x85\xce\xd5\xb5\x3e\x91\x97\xfc\xea\x37\xf5\x3e\xc2\x2c\x75\xb7\x60\x6f\x65\x23\x69\x30\xe7\xa4\xfb\x5a\xf6\xa0\x84\xf6\xab\x2c\xdf\xd1\x77\xa0\xe2\xc0\x03\xb4\x56\x04\x97\x0a\xd5\x80\xd6\x72\xd1\x2f\xa9\x9d\x41\x7d\x65\x06\xea\x69\xc2\x65\xc2\xef\xa9\x45\xbf\x38\xb2\xf3\x7e\x70\xb9\x76\x5f\xa8\x1b\x3e\x2d\x97\xeb\x59\x9e\x9b\x46\xfd\x3b\x6d\xea\x59\xd2\xa3\x7a\x27\x3a\x1b\xb3\xad\x1f\xde\x64\x53\x5b\x77\xe5\xae\x93\x54\x3f\x5d\xb7\x4f\xcb\xf2\x9c\xe7\x83\x5e\x5f\x30\xc1\x2c\xcf\x09\x04\x4e\xd4\x5f\xa8\xbc\x63\x86\x63\xe4\x02\x99\x1f\xdb\x1d\x97\xf2\xb4\xfd\x90\x64\x2e\xdf\xcb\x0f\xf1\x28\xec\xf6\x43\xfc\xcd\xad\x7b\xfc\x10\x7f\xe1\xf4\x57\xfa\x21\xae\xf7\x81\x7e\x48\x8f\x5f\xc3\xe7\x1b\xf8\x21\x7e\x89\xe2\xb5\x57\x18\x96\x31\x23\x0a\x3a\xa7\x72\xc7\xb5\xa5\xbb\x06\xe8\x1d\xd3\x54\xd9\xe1\x97\x9f\xea\x05\xde\x9c\x5f\x27\xf7\x0f\x74\x2b\x18\x72\x45\xfa\x97\x14\xae\x0f\xca\xc2\xc5\x3a\xf1\xb6\x26\x94\x71\x6f\x92\xaf\x9d\xd5\x8e\xf0\x5c\xbd\x01\xb7\x2b\x15\x6f\xb3\x71\xc5\x1b\x3c\x26\x28\xed\x8a\x97\xee\x1a\x23\xcd\xe8\xc0\xb5\x3b\x54\xe7\x51\xdc\xc6\x53\x38\x1f\x27\x27\xed\x99\xcd\x79\x98\xb4\x53\x50\xd7\x8d\x04\x27\xbd\xf9\x3d\x6d\x4e\xe5\x6f\x58\xc9\xcd\xb4\x7d\xd2\xdf\x05\x3e\x0e\x1b\x6f\x78\xc3\x01\xcb\x1b\x1c\xeb\x26\x02\x0b\x1f\xca\xb3\xb9\x68\x56\x3b\x73\xb5\x66\x32\x5e\xcc\x90\xa1\x8e\xbb\x71\x78\xdc\xf4\x18\xfb\x3a\x1c\x81\x60\xd8\xa1\xab\x2a\xba\x9c\x8d\xe3\x5f\x2b\xcf\xdc\x8e\x04\x31\x79\x15\x0d\xd5\xe7\x51\x77\x7e\xef\x5d\x9b\x0f\x4f\x4f\xa6\x7d\x46\x9c\x4c\x20\x49\x8d\xd0\xa9\x4e\xe3\x8f\x75\x86\xa9\x44\xc3\xe0\xbd\x2f\x77\x60\x5b\x34\xd7\x6a\x85\xdd\xbe\x7c\xdc\x71\xef\x36\x9d\x03\xa2\x2b\x26\xf3\x82\x3b\xbd\x4f\xc4\x65\x45\xb1\xa1\x13\xa7\xb6\x69\xfc\xcf\xda\x24\x63\x13\x7f\x04\xf8\xe0\xca\x05\xc6\xa9\xc0\xb6\x26\x3b\x7c\xfb\x0f\xfa\x5e\xb7\x88\x76\xab\xed\xc3\x01\x71\x44\xa2\x8e\x35\x2f\xd5\x1d\x3f\xbe\xe5\x9b\x29\xdc\x6e\xbb\xe2\x27\x89\x10\x07\xec\x0e\xcc\xe0\x7d\xf3\x9f\x61\xc4\xf1\x09\x3c\xf1\x4b\x7b\xe8\x08\x01\x66\x6e\x85\xbc\x33\x72\x1b\xfd\x10\xec\xf9\xfe\xf6\xc3\xc3\x8e\x1b\x22\x45\xd1\xb8\x20\x52\x14\x6d\x6c\x3b\x6a\x9e\xcc\xc1\xd0\x04\x02\x33\x3a\xc6\x72\xbd\xe2\xfd\xd6\x9f\x1f\xc0\xff\x07\x00\x00\xff\xff\xa0\x22\xd7\x31\xd2\x66\x00\x00" +var _utilityBurnerCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x54\x41\x8b\xe3\x46\x13\xbd\xfb\x57\xbc\xbd\xd9\xc3\x8c\xbd\xdf\xd5\xec\x7c\xbb\xb3\xce\x2e\x09\x21\x09\x24\x03\x39\x84\xb0\xb4\x5a\x25\xab\x71\xab\xda\x74\x97\x46\x28\x8b\xff\x59\x6e\xf9\x63\xa1\x5a\x96\xac\x71\x66\x20\x87\x0c\x0c\x98\xee\x57\xf5\x5e\xbd\x7a\xad\xcd\x66\x83\x8f\x6d\x64\x8a\x70\x09\x06\x36\xb0\x44\x63\x05\x52\x1b\x81\x35\x8c\xca\x58\xe7\x9d\x18\x21\x48\x4d\x28\x29\x49\x6c\xad\xb8\xc0\x08\x15\x0c\xf7\x88\x94\x42\x1b\x2d\x21\x30\x2a\x1f\xba\xf5\x62\xb3\xd9\xe8\x3f\x76\xda\xcd\x15\xad\x84\x98\xf2\xc1\x1d\x1e\xda\x24\x8e\xf1\xbd\x77\x4c\xb8\x43\x2d\x72\x4c\xdb\xcd\x46\x3a\x27\x42\x71\x6d\x43\xb3\x31\x19\xf2\x45\x5b\x49\x7f\x2e\xfb\x86\xd8\xfd\x81\x4f\xa5\x63\xeb\x0e\xaf\xd4\x15\xbe\xa5\xe4\xf6\x7c\x2e\xf9\x68\x92\x38\xc3\xf8\xe1\xaf\x3f\xbd\xa7\xf8\x4a\x91\xb4\xb1\x08\x9e\x58\x16\xc6\x5a\x4a\x69\x69\xbc\x5f\x5d\x6c\x38\x7b\xf3\x75\x01\x00\xda\xf7\xd7\x9a\x18\xbb\x48\xc9\x12\x97\x01\xcb\x9d\x29\x89\x2d\xe1\x7f\xeb\xb7\x2b\xb5\x30\x92\x27\x93\xa8\xbc\x85\x6d\x93\x84\x66\x32\x2c\xc4\x84\xce\x79\x8f\x82\x10\xa9\x09\x4f\x54\xa2\x8a\xa1\x81\x35\x25\x59\x5a\x4f\x0c\x4a\x69\x0a\x4f\x79\x21\x0c\xc7\x42\xb1\x32\x96\xd0\x90\x61\x81\x04\x44\x3a\x7a\x3d\x90\xda\x25\xf8\x90\x04\x15\x19\x69\x23\xdd\xc2\x78\x1f\x3a\xc7\x7b\x5d\x4c\x60\x52\xb4\x29\x4b\x5d\xac\xf1\xbe\x30\xf6\x30\xd1\x34\x24\x75\x28\x15\x40\x9c\xda\x98\xb7\xdb\xa3\x0c\xe0\x20\x83\xe8\xd0\x23\x05\x85\x69\xbf\xae\x76\xb6\x56\x49\x7a\x3d\x29\x29\xe8\x76\x6a\x18\xe2\xc8\xe6\xc3\xde\x59\x14\x6a\x83\x66\x62\x1e\x99\xd4\xda\x1a\x26\x41\xdd\x3d\x68\x5f\xcd\x54\x6a\x8f\x47\xdf\xe7\x38\xe1\xf3\x23\x76\xc1\x7b\xca\xf0\xb1\xf7\xc4\xf1\xe3\x4f\x8f\x9f\xb6\x78\xac\x35\x6b\xbe\x47\x67\x7a\xe5\x4c\x44\x28\x88\xa9\x72\x32\x58\x9a\x8d\x99\x8c\x9b\xaa\x5d\xca\x0a\x7d\x67\xfa\x84\x36\x0d\x81\x2e\xda\xc8\xa3\x19\x8e\x87\xd2\x71\xfd\x6b\x3c\x0c\x36\x76\x75\x40\xe8\x58\x5f\xc8\x94\x76\x7d\x1c\xe7\x5e\xa4\x7a\x71\x73\xc3\x41\x6e\x6e\x26\x3a\x09\x93\x8f\xb3\xb2\x4c\xd0\x99\x3e\xc3\xe6\x99\x9b\x10\x97\x8d\x4f\x51\x18\xf2\x37\xab\x18\x15\xae\x50\xb5\x9c\x67\xd8\x9d\x17\xbc\x5c\x65\xec\x69\x31\xe9\xc8\x13\xe6\xd7\xbd\xf7\xa1\x30\x7e\x9c\x76\x58\x69\xce\xe4\xa4\x73\xfe\x9c\x9d\x68\xd5\xde\x3d\x11\x5f\xd2\xf9\x5d\x95\x5d\x3b\xc6\xf0\xe4\x4a\x2a\x67\xe8\xe6\xe8\xa9\x21\x96\x94\x01\x97\x14\x8f\xd3\x5c\x92\xe2\x64\x60\xd5\x4c\x4e\x3b\x18\xf5\x8f\xea\x0c\x97\x7a\xc7\x17\x6d\x95\x50\xec\x4c\x2c\xd3\xfa\x1f\xde\x8d\x26\x2c\xbf\x40\x82\x52\x6f\xf1\xe1\x81\xfb\x9f\xcf\xe2\xde\xaf\x66\x0e\xba\xea\x8c\xc1\xfd\x3d\xd8\xf9\xd9\x95\xfe\x8d\x74\x03\xe6\xd9\x55\x24\x99\x1f\x9d\xa6\x5f\x9e\x04\x11\xef\xee\xce\x45\x6f\x16\x73\x32\xbd\x4c\x7a\x19\x61\xd2\x7b\x7c\xf8\x3a\x5a\x73\xba\x62\x4e\xeb\x17\xf6\x78\x2d\x2b\x5d\xe8\x41\x3e\xd1\xc8\x60\x62\x9c\x71\xfc\x36\x1b\xfe\xf7\x2b\x9a\xae\x76\x9e\x14\xbf\xf6\xc4\x7b\xa9\xf1\x7f\xbc\xbd\x82\x8c\x33\x39\xa1\x46\xbb\x2a\x78\xf8\x66\x7d\x76\x31\xc9\x95\xb4\xac\x9d\x7c\x95\xe5\x2f\xdf\xdd\x69\xd5\x73\xc4\xe9\xc5\x51\x4c\x8c\xaf\x0c\x53\x3a\x2b\x73\xc7\xbe\x35\xa9\x56\xc7\x7e\xc9\xdf\x91\x2d\x66\xd3\x5d\x9b\xa8\xe5\x07\xea\x13\xee\x73\x97\xb5\xfe\x7e\x61\x7c\x3d\xfe\xf7\xf3\xe7\x4e\x83\x01\xcb\x03\xf5\xdb\xa1\xfc\x99\x23\xab\x37\xff\x89\x27\xca\x74\x6d\xca\xcb\xf9\x8c\x57\x39\x3c\x2d\x4e\x7f\x07\x00\x00\xff\xff\x5f\x32\xec\xc3\xcd\x07\x00\x00" + +func utilityBurnerCdcBytes() ([]byte, error) { + return bindataRead( + _utilityBurnerCdc, + "utility/Burner.cdc", + ) +} + +func utilityBurnerCdc() (*asset, error) { + bytes, err := utilityBurnerCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "utility/Burner.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x71, 0xaf, 0x18, 0xe2, 0x27, 0x98, 0x4c, 0xd4, 0x34, 0xa3, 0xad, 0x0, 0xbb, 0x2f, 0x36, 0x18, 0xb7, 0x64, 0x82, 0x84, 0x2b, 0xae, 0x92, 0xe, 0xe5, 0x56, 0x62, 0xc3, 0x7c, 0x8b, 0xf3, 0x31}} + return a, nil +} + +var _utilityMetadataviewsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x7c\x6d\x73\xdb\x38\x92\xf0\xf7\xfc\x8a\x1e\x6f\xd5\xac\xfd\x3c\xb2\xe4\xcc\xce\x4d\xdd\xa9\x46\x3b\x9b\x49\xe2\xdd\x5c\xcd\xe4\x52\x89\x67\xf7\xaa\x52\x53\x31\x44\xb6\x24\xac\x49\x82\x0b\x80\x96\xb5\xa9\xfc\xf7\xab\x6e\xbc\x10\xa4\x28\x8b\xf6\x66\x36\xfe\x90\x50\x24\xd0\x68\x34\xfa\x1d\x0d\xc8\xb2\x56\xda\xc2\xc9\x65\x53\xad\xe5\xb2\xc0\x2b\x75\x83\xd5\xc9\x93\xf0\xfa\xb5\xaa\x0e\x7c\xf9\xab\xc4\xed\x5b\x34\xaa\xb8\x45\x7d\xf2\xe4\xc9\x6c\x36\x83\xab\x8d\x34\x90\xa9\xca\x6a\x91\x59\x90\x65\x5d\x60\x89\x95\x35\x60\x37\x08\x25\x5a\x91\x0b\x2b\xc0\x58\x51\xe5\x42\xe7\x50\x6b\x55\x2b\x83\x39\xf7\x95\x15\x5c\xfe\xf4\xea\xcd\xf9\xc5\x77\x7f\xf8\x6e\x4a\x6f\xf8\xed\x5b\x5c\xcd\x61\x63\x6d\x6d\xe6\xb3\xd9\x5a\xda\x4d\xb3\x9c\x66\xaa\x9c\xa9\x6a\x55\xa8\xed\x6c\x55\xc8\xda\xcc\x96\x85\x5a\xce\x4a\x21\xab\x99\xa8\xeb\x42\x66\xc2\x4a\x55\xcd\xbe\xb9\xf8\xe6\xe9\xc5\x7f\x3d\xfd\xee\xbc\x5a\xd9\xf3\x30\xf8\xb4\xcc\x23\xec\x77\x56\x37\x99\x35\x20\xaa\x1c\x34\x1a\xd5\xe8\x0c\x0d\x64\xa2\x6a\x31\x07\x55\x21\x28\x0d\xa5\xd2\xc8\x7d\xe2\x24\xec\xae\x46\x33\x81\x4c\x14\x05\xe6\x70\x2b\x71\x6b\xa6\xf0\x52\x64\x1b\x7e\xe6\xcf\xa0\xb1\xd6\x68\x88\x00\xdc\x57\x40\x2e\x57\x2b\xd4\x04\xf7\x46\x56\x39\xa8\x55\x84\x37\x01\xd3\x64\x1b\x10\x06\x04\x64\x1a\x85\x55\x1a\x96\x52\xad\xb5\xa8\x37\x3b\xee\xad\x34\x08\xf8\xef\x37\x2f\xff\x0c\xb2\x14\x6b\x84\x95\x2c\xd0\xd1\x49\x64\x19\x1a\x73\x2a\x8a\xe2\xac\x25\xfe\xcf\x1e\x30\xad\x92\x81\x8f\x4f\x9e\x00\x00\x10\x9c\x17\xd2\xd4\x85\xd8\x81\xa4\xa1\x96\xc2\xc8\xcc\x63\xbc\x11\x16\x64\x95\x15\x4d\x8e\x6e\xc1\x2a\x51\xe2\x04\x72\x34\x99\x96\x35\x91\x94\x28\x15\xe1\xd8\x4d\x53\x2e\x2b\x21\x0b\x58\x11\x6a\x15\xa8\xe5\xdf\x31\xb3\x53\xf8\x59\x19\xeb\x7f\x18\x30\x1b\xd5\x14\x79\x42\x50\x4b\x2c\x42\x03\x4e\x03\x24\xfe\x3f\x9d\x83\xe1\x75\x89\x88\x7a\xdc\xc3\xb8\x57\x1e\x33\xa2\x1e\x61\xe9\x87\x4d\xdb\xf4\xda\x4b\x03\x2b\x89\x45\x0e\x5b\x59\x14\xb0\x44\xc8\x1d\x64\xcc\x89\xe9\x0a\x69\x3c\x0f\xd8\x0d\x6a\x5c\x29\x8d\x1e\xeb\x0e\x98\x25\xbf\xd5\x96\x66\x9a\xa9\x2a\x93\x06\x87\xc7\x4c\x67\x52\xa0\x65\x5c\xe7\xc4\x6b\xb2\x5a\x77\x67\xf2\x0c\xb6\x5a\x5a\x8b\x55\x87\xc6\x9f\x69\x5a\x02\x72\xb4\x42\x06\xe6\xec\x82\x9d\x74\x40\x19\xc5\x4c\xbf\x44\x66\x73\xb8\x45\xbd\x54\x06\xe1\x14\xa7\xeb\x29\x08\xa8\x85\x16\xcc\x87\x20\x2b\x63\x51\x30\xdf\x0a\x30\xb2\x5a\x17\x08\x85\xac\xf0\x6c\x1c\x25\x92\x59\x1e\x22\x88\x29\x45\x51\x24\xac\x15\x25\x48\x3c\x92\x36\x9e\xff\x96\x08\x02\xb6\xb8\x3c\x5f\x69\x89\x55\x5e\xec\x58\x7c\xe0\x54\x4e\x91\x65\x6a\x02\x6f\x5e\xff\xf9\xac\x03\x84\xe5\xc1\xd3\x65\x9f\x61\x26\x34\xf1\x1b\xa8\x35\xb2\xe8\x4f\x00\x6d\x36\x8e\x0a\x71\x72\x73\xf8\x78\x29\x0b\xfc\xd4\xd2\x80\x17\x4a\x56\xd2\x9e\xc6\x57\xf4\x97\x72\xd0\xa4\xf3\x65\x80\xa2\xdd\x06\xfb\x83\x85\x2f\x67\xf0\xb1\xd3\xd2\x60\xb1\x9a\xb2\x5c\x2d\x78\xc0\xfd\x8f\x29\x93\x2e\xd2\xa1\xf7\x9b\xb6\x0b\xb8\x68\x51\x88\xcd\x1c\x12\x9f\x5a\x95\xf4\x17\x2c\x6a\xd4\x60\x15\xac\xb1\x95\x7b\x66\x62\x56\xb3\x62\x85\xb0\x15\xbb\x8e\xc2\xa0\x7e\x7f\x22\xd6\x2c\x99\x6c\xc1\x10\xcd\xe1\x19\x68\x64\x25\x9b\x21\x41\x24\x7e\xd1\xfe\x63\xd4\xf2\x2d\x04\x8d\xb6\xd1\x15\x3c\xab\x40\xf1\x5c\x44\x11\xc7\x77\x6a\xe8\xa0\x96\x5a\x35\x15\xa1\xeb\x5b\x9f\x7e\xe8\xa1\xf1\xf5\xc7\xd4\x3e\x4e\xc3\xc3\xa7\x33\x98\x87\x11\x7e\x48\x96\x40\xae\x98\x39\x98\x03\x16\x1d\x50\x53\x8f\x3d\x81\x3b\xbd\xda\xd5\xf8\xbd\xef\xfe\xc7\xd3\xb3\xfe\x22\x06\x28\x1e\x04\x08\xf3\x43\xa2\x46\xa1\xf7\xe7\xe7\x7e\xdb\xf9\xf0\xe9\xc9\xfe\x93\x6f\x58\xf9\x35\x4c\x56\xee\xcf\x58\xa1\x96\x19\xc8\xca\xa2\x5e\x09\x22\x39\x89\x4d\x6b\xf8\x40\x38\x49\x33\x56\x69\xcc\x81\x64\x58\x83\x5a\xad\x20\xdb\x08\x59\x4d\x81\x98\xd2\x44\x70\x5e\xdc\x1a\x83\x39\xad\x5d\x5c\x48\xe3\x6c\x9e\x99\xc0\xad\xcc\x51\x39\x75\xad\x48\x5f\x43\x89\xb9\x14\x47\x6d\x49\x8b\x1f\x0d\x98\xd0\x22\x6d\xcb\x24\xa3\x65\x6d\xb4\x3c\x3d\x8b\x2a\xaa\x37\xe5\xbf\xb2\xb1\x54\x80\x77\xe4\xbb\x84\xf9\x39\xeb\x69\x3c\x3c\xf2\x96\x40\xb0\xad\xf8\xcb\xd5\xd5\x1b\x38\x55\x9a\x1f\xde\x9d\xc1\x2f\x6f\x7f\x3a\x8a\x2d\x35\x25\x3c\xe7\xf7\x61\x4b\x0b\xdd\xe8\x62\x5f\x93\xb6\x5a\x24\xf9\x3c\x28\xee\x8d\x26\x01\x6d\x74\x2a\x9a\x0f\xa0\x4c\x0f\xa4\xe7\x92\x00\xf9\xb0\xb8\x0f\x53\xb0\xe5\x90\x57\x6f\x2e\xdf\x45\x1a\xf1\x2f\xbf\xfc\x20\x34\xb6\x4c\x91\xc3\x72\x47\xe2\x2d\x35\x7b\x3d\xe4\x5c\xc8\x1c\x2b\x2b\x57\x12\x35\x9c\x3e\x7f\xf5\xe2\x2c\x02\xd1\x82\x99\xc5\x6e\x04\x5b\x46\xa9\x31\xb3\xf0\xcb\xdb\x57\x53\x78\x06\x59\x21\xa9\x6f\xe2\x3a\x32\x1f\x36\x06\x9d\xb3\xf2\xfc\xd5\x8b\xd6\xe9\x51\xb0\x22\xcf\x8d\xf8\xaf\x50\x82\x7d\x06\xef\x8f\xdd\x4a\x41\xeb\xcd\xe8\xae\x85\xc5\xad\xd8\x1d\x5d\x68\x6a\xdc\x59\xe8\x8e\x05\x7a\xfe\xea\x05\xb1\x14\x0d\x31\x30\x41\xf2\xba\x18\x3f\x1e\xd1\x79\x83\x49\xef\x0e\xa4\x8e\x17\x9d\xab\xcc\x4c\x65\xbd\x32\x53\xa9\x66\xe4\xca\x60\x6d\xcd\xcc\x8f\x70\x2e\xf2\x5c\x13\x07\x57\xeb\xd9\x28\x73\x96\xc9\x7c\xd8\x98\xbf\x11\x76\xc3\x12\x91\xa8\xd6\x9a\xde\x79\xa5\xcc\x8b\x1e\x14\x32\x2b\x7b\x4f\x3c\xb7\x3a\x4a\xef\x46\x19\x78\x69\x40\x55\xc5\x0e\x2a\xc4\x9c\xec\xf3\xaa\x05\x2e\x0d\x79\x2c\x32\xc7\xb8\xe4\xf7\x02\x1d\x41\x24\x02\x7b\x6e\x76\xc6\x62\x69\xc6\x91\x87\x66\x1c\xe8\xf3\xc3\x90\x8c\x26\xf4\x9b\x74\x5b\x0f\x8a\x6c\x26\x73\x58\x10\xd1\xf7\x3f\x31\x71\x17\x0c\x63\x48\x9e\x5b\xba\x35\x55\xc6\x5c\xee\x04\xd6\x31\x18\x53\xbe\x12\x56\xde\x22\xa9\xa8\x96\xbb\xf6\x18\xeb\x1e\x3a\x6d\xd4\xf6\xdc\xaa\x99\x67\xa1\x73\x7a\x7d\xae\xaa\xf3\x2d\x2e\x67\xbf\x73\xb0\xcf\x1b\x5d\x98\x83\x2b\x10\xac\x31\xb9\xf8\xc6\xa9\x18\x62\x4b\x21\x2b\x7a\x8c\xeb\xda\x68\x79\x94\xf6\xa3\x34\x96\x37\x97\x9e\x70\x2d\x11\x0f\x9a\xca\x13\x9a\xd2\x7c\x36\x3b\x99\x12\x4b\x08\x7b\x1a\xd6\xe4\x2c\xbc\x38\x99\x9d\xc4\x67\x82\x75\xd6\x33\xae\x43\x1a\xf3\x30\xd4\xe3\x3a\x34\x5a\xda\xa0\x46\xb7\xd2\x6e\x5c\x8c\xa2\x35\x9a\x5a\xc9\x9c\xe6\xcd\x56\x92\x9c\x87\xa3\x2a\xe9\x67\x6a\xd9\xd7\x44\xac\x9d\x1c\x4b\xa0\x83\x35\x8a\xf9\x57\xac\xda\xfa\x5e\xae\x0b\xa3\x73\x29\xce\x39\x48\xce\x54\x89\x24\xc3\x6e\x7d\x95\x2e\xd9\xcb\xdf\xd5\x38\x33\xcd\x92\x5b\x08\xe3\xbd\xcd\x25\xe6\x40\x31\x1a\x74\x60\x45\x56\xc4\x5b\x2c\x54\x8d\x7a\x5a\xaa\x7f\xca\xa2\x10\x53\xa5\xd7\x33\xac\xce\x7f\x79\xc7\x6c\x3a\xfb\x1b\x2e\x67\x64\x5a\x67\x3f\x52\xd4\x6b\x3e\xa8\xd5\x07\xfe\xf9\xf3\xab\x9f\x5f\x7e\x60\x47\x73\xd4\xac\x22\x2d\xef\x33\xbd\xe9\xd4\x27\xfb\x5d\xba\xb2\xcd\xeb\x4d\x3d\x16\xf4\x4f\xff\x43\xec\xbc\x88\x4f\x87\xf9\xe2\x6f\x5a\xd4\xe4\x4b\x3b\xfe\x57\x1a\xca\xa6\xb0\xb2\x2e\xfc\xb2\xb9\x44\xc5\x28\x1e\x30\x7d\x26\x78\x56\x81\xd0\x4b\x69\xb5\xd0\xbb\x73\x23\xff\x89\x39\x87\x42\x3e\xfc\xdf\x41\xd5\x94\x4b\x24\xe7\xce\xf3\x90\x24\x2d\x79\x90\x8a\xfc\x75\x0e\xef\xb9\xed\xaf\x43\x24\xfc\xd0\x6b\x33\xa8\x0f\xb9\x09\x2c\x7a\x83\x1d\x89\x30\xfc\xfc\xfe\xad\x01\x46\x6b\x04\xfd\xe8\xe3\xc2\x0b\xd7\xf8\x41\xd1\x85\xeb\xf2\xd8\xe0\xc2\xf5\x1e\x19\x5b\x44\x46\x81\xde\xdf\x67\x08\x2d\x86\x34\x5c\x21\x33\xac\xc8\x65\xcc\x32\xa5\x59\xb1\x59\x15\xe5\xdf\xd4\xf9\x1d\x8b\xbc\x6f\x65\xda\x75\xbc\x0a\x49\xa7\x4e\x84\xe1\x7d\x85\xe0\x5b\xa9\x15\xe9\xcd\xd7\x97\x57\xe4\x38\x78\x18\xf9\x51\x7d\xf9\x93\x47\xe9\xb0\x93\x4e\x78\xbd\x8a\x7e\xdb\x7d\x4a\xe3\x43\xe2\xdf\xdd\xeb\xb8\x77\x41\x12\xfb\xc7\x1f\x63\x65\x20\xe0\xfd\x85\x84\x20\x0c\x3f\x4e\x0a\x7c\xeb\x07\x89\x81\xef\xf3\x58\x39\xf0\xdd\x47\x0a\xc2\x3e\x17\xfc\x06\x92\x10\xe3\x25\x72\xd0\x98\xe8\xe4\xe1\x5a\x2c\x81\x53\xb3\x80\x77\x16\x35\x11\xd7\x48\xdb\x1a\x7a\x9f\x94\x4f\xf8\x7e\xb9\x4b\x83\x1d\xe2\xf5\x1b\x84\x69\x8c\x6b\x7e\x2c\x54\x46\xd0\x55\x88\x93\x1a\x83\xda\x40\x1a\x03\x71\x12\x4e\xcb\xb5\xa4\xd1\x38\x11\xe6\x73\xc0\x24\x3d\x9c\xa8\xae\xb5\xfa\x3b\xf5\xad\x29\x34\xe2\xe0\x38\x98\x70\xe7\x6f\x52\xc3\x4c\x15\x05\xb2\x2b\xda\x22\x8b\xeb\x28\xcf\xdb\xed\x76\x5a\xee\x38\x7b\xef\xa1\xb9\xcc\xff\x2d\x6a\xa2\xfb\xb9\x5a\xf1\xb7\x16\xca\x31\x51\x7d\xe9\xe9\x43\xe4\x7b\x74\x4c\xfd\x01\x46\x44\xd5\x8b\x7b\xe3\xdf\xae\x20\xa6\x58\x7d\x21\x61\x4c\x51\x18\x27\x90\x49\x8f\x07\x09\x65\xd2\xef\xb1\x82\x99\x80\x18\x29\x9c\xc3\xeb\xfe\xd9\x05\xd4\x31\xf9\x4a\x56\x18\x62\xf6\xb2\x56\x46\x2c\x29\xcc\x55\x3b\x51\xd8\x5d\xbb\xf3\xc5\x8d\xd7\xf2\x16\x0d\x94\x42\xdf\xa0\xad\x0b\x91\xa1\x01\xd1\x8a\x59\x53\x91\x3e\xcf\xd3\xd4\x9a\x02\xd3\xd4\xbc\xf9\x46\xe2\xe3\x80\x4a\x34\x47\x6d\xd4\x5b\x3f\x7c\xcf\xa1\x0b\xc9\xbb\xce\xfe\x1e\xbc\xc5\x0c\xe5\x6d\x4c\x30\x20\x2c\xb1\xc2\x95\xcc\xa4\xd0\xbb\x90\x80\xf7\xf3\xe9\x66\x2b\x04\x73\x46\x30\xa9\x99\x46\x8b\x6e\x1b\x2c\x74\x0a\x80\x39\x44\x09\xbf\xa6\x6b\xb4\xb4\xae\xa7\x67\xbd\x20\x33\x53\x65\x89\x55\xee\x12\x32\xe7\xf0\x0b\x2b\x21\x9f\xce\xe7\x1d\x32\xd2\x84\x15\x6e\x13\xfd\x03\x97\x85\xda\xba\x59\x74\x80\xe9\xee\x94\xa4\x81\xc6\x90\xf3\x70\xbd\x46\xeb\x69\x13\x66\xfd\xa6\x59\x16\x32\x7b\x23\xec\xe6\xf4\xec\x7a\xc2\xfa\xb0\x52\xb6\x0b\xce\x65\x86\x90\x16\x5b\x34\x85\x4d\x46\x8d\x93\x72\x4a\x97\x37\x66\x44\x51\xa8\xad\xd7\xa1\x56\x41\x53\xe7\x84\x7a\x07\x20\x93\x4c\xd4\x62\x29\x0b\x69\x39\xf1\xcd\xb1\x50\x63\x1b\xcd\xab\xde\xb0\xd6\xe7\xcd\x99\xb5\x5f\xb3\xb6\xf9\x41\x45\x16\x90\x99\xc3\xf3\xd8\xf8\xfb\xaf\x3f\x76\x56\x7b\x1a\xe6\xfd\xe9\x8f\x5d\xde\xf8\xd9\x85\x0d\xe4\x5d\x84\x6c\x6c\x26\x8a\xac\x29\x08\x79\xc2\x4e\x94\xaa\x71\x4e\x93\x11\x05\xc2\xad\x28\x1a\x04\xab\x45\x65\x56\xa8\xb5\xeb\xd1\x5d\x04\xcf\x84\x2d\x8d\x5e\x2b\x8b\x70\x0e\xaf\x6c\xb2\x4b\xb3\x44\xbb\x45\xac\xe0\x62\x7a\xc1\xc4\x7f\x3a\xbd\xe8\x82\x79\x79\x47\x5d\x1c\x47\x25\x23\x4b\x03\x77\xdc\xa1\x6c\x11\x97\x06\x2e\xa6\xff\xf1\x1d\x35\xad\x52\xb6\xed\x02\x74\xfd\xb7\x01\x01\xee\xf1\xff\xe0\x6e\xba\x2f\x2a\xa2\x28\x76\x50\xa3\xce\xb0\xb2\x64\xd6\xd6\x98\x64\xba\xdd\xde\x90\x45\x5d\x1a\x22\xca\x52\x18\x69\xa0\x56\xb2\xb2\x9d\xa8\x92\x1a\x19\x55\xc8\x9c\x16\x7a\x29\x88\xb4\xa6\x14\xda\xc6\x8d\x5b\x03\xdb\x0d\x45\xdb\x99\xc8\x59\x9f\xab\xd5\x8a\x38\xe7\xfa\x97\x4b\x79\xf7\xdd\xb7\xd7\x7d\xc6\x11\x16\x44\xa1\x51\xe4\xbb\xa0\x1b\x9c\xf2\x49\xc7\x67\xfe\xc9\x84\x21\xea\x66\x82\x7e\x48\x6b\xba\x80\x28\x6c\xf6\xde\x80\xd0\x08\xe4\x4c\x6a\x2c\x76\x90\x23\xcd\x48\x56\xd2\x58\x9f\xe5\x5f\x53\x88\x97\xb4\xae\xf2\xa8\x94\xba\x42\x52\x13\x07\xfc\x67\x40\x41\xad\xa0\xd6\x98\x49\x13\xad\xfd\x10\xcb\x66\x8d\x9d\x83\x9b\x69\x97\x1d\xff\x27\x98\xaa\xce\x8e\x57\xea\xd9\x38\x19\xa2\xc9\xd1\x50\x62\x17\x32\x46\x7e\xcd\x27\x7b\x02\xa7\xb1\x70\x73\xd8\xc8\x3a\xb2\x1d\x7d\xb8\xde\x8a\xa2\x40\x7b\x1d\xf6\x84\x49\xd9\x4e\xc0\x05\xb9\x76\x43\x70\xb1\x30\xb8\xbf\x0e\xec\x14\x6d\x2b\xd4\x50\xca\xf5\xc6\xc2\x56\x54\x96\x75\x76\x8d\x99\x5c\xed\x0e\xcf\xfa\xde\x7d\xd1\xd6\xf3\x78\xa0\x3c\x4f\x52\x6a\x4e\x86\x06\xe9\xdb\xce\x5a\x0f\x39\xb0\x59\x63\xe1\x8f\x0b\x16\xc8\xaf\xbf\xe6\x5f\xdf\x2f\x58\x2c\xe7\x70\xf2\xbc\xb1\x5e\x7e\x5a\x09\x96\x15\xbd\x92\x39\x68\x51\xad\x11\xe4\x14\xe1\xfd\xc5\xe4\xe9\xaf\x27\x07\x0c\x2c\x04\xbf\x29\x6a\xe9\x45\xd4\x11\x03\xf9\xcf\xc6\xc2\x82\xb0\xd8\xff\x74\x7c\x7f\xf2\x01\xd9\x92\x60\x32\x5d\x61\x47\xec\xf0\x73\x6a\xac\x89\xf3\xfe\xd1\xa0\xde\x39\x9b\x72\xfd\x36\x18\xe4\xeb\x60\x78\x57\x5a\x95\xc4\x3e\x89\xf7\x4c\x4c\xc5\x22\x76\x57\x63\x66\x9d\x9e\xac\xc5\xae\xb5\xe6\x5e\x2b\xb8\x84\x18\x45\x48\xcc\x3e\xc1\x59\x1f\x69\xeb\x09\x4e\x3f\x7d\xa3\xb5\xd8\x79\x4e\xd5\x22\xbb\x71\x7a\x42\x56\xb9\xbc\x95\x79\x23\x8a\x16\x83\x3e\xa3\x12\x75\xa3\x7c\xbe\xaa\x56\xca\xcc\xe1\xbd\x27\xd0\xaf\xf7\x6c\x18\x79\x7f\x79\xa0\x53\x9f\xf3\xc8\x87\x22\x9e\x71\xc6\x45\x58\x30\x0d\xa7\x01\x45\x51\x30\xc7\xb5\x4a\x3d\xba\x00\x64\x95\x97\x08\x6b\xf6\x04\xfc\xce\xce\xd3\xe9\x45\x07\xec\xad\x20\x2f\xdb\x8a\xe2\x39\x73\xcd\x45\xef\x33\x2d\x78\x30\x09\xb2\x8a\x78\x0e\xc8\x40\x02\x24\x3e\xfe\xff\xd0\x77\xda\xe7\xc6\x2e\x6f\x0b\x63\x50\xdb\xd3\xd8\xcf\x49\xcf\x04\x4a\x34\x46\xac\x71\x0e\x27\xef\xdc\x64\xe3\xf8\xe3\x67\x7b\x72\xd6\x27\xe3\x33\x63\xe4\xda\xe9\xb1\x00\x6f\x50\x88\xdc\x48\x8b\xfd\x46\xbd\x44\xed\x5b\xe7\xf4\xa6\xf0\x38\xeb\x37\x98\x29\xed\xed\xa8\x0b\xe6\xb8\x24\x83\xef\x6a\x3b\x30\xe1\x75\xc7\xb4\xc7\xf3\xae\x31\x9d\x1f\x3d\x36\x89\xe6\xf4\x2c\x61\xa9\x7b\x36\x23\x07\xe6\x08\xf7\x45\x64\xad\x08\x7d\xa1\x78\xec\x6d\x8f\x3e\xc7\xa2\xb1\x96\x22\x0f\x89\xc5\x62\xaf\xc7\x46\x62\x11\xc0\xc8\x38\x2c\x55\x4d\x7d\x09\xfb\x2c\xb5\x08\xce\x06\xbb\x4d\x46\xd6\x22\xd1\x28\xb1\x0f\xcb\xf2\xce\x96\x85\x98\xb1\xab\xee\x62\xa2\x84\xcb\xe2\x5a\x10\xec\xc2\xe3\x2d\x56\xb6\x61\xf7\x2f\x85\x25\xa2\x37\x6e\xb6\xd2\x66\x9b\xa5\xa2\xd0\x2e\xd8\xae\x49\x84\xbb\x71\x8c\x10\xea\xd6\x96\x8d\x07\xcb\xfb\x96\x1d\xe4\x22\x81\xe8\x57\xa5\x7a\x35\x72\xfd\x2d\xb2\x36\x56\x89\xb1\x5a\x40\x88\xc2\xc3\xd4\x86\x0e\x31\xcf\xbe\x4c\x0d\x46\x41\xf3\x74\x9c\x8f\xfd\x75\x98\xd5\xfc\x71\xe6\x63\xc9\xcb\xab\xb7\xe9\xb0\x47\xd2\xb9\xbe\x84\xcc\x6d\xe4\x26\xc5\x90\x3e\x9f\xf5\xfa\xf2\x6a\xba\xb7\x38\x21\x1a\xe1\x50\x53\x0b\xe9\x7c\xcb\xc4\x8c\xdd\xe0\x6e\xe6\x7c\x92\x5a\x48\x6d\x40\x14\xaa\x5a\xbb\x98\xd3\xa8\xb2\x95\x3b\x4e\xfb\xde\xd1\xb2\xf2\x56\x06\x8f\x2b\x96\xaa\x71\x4c\xc4\xa0\x8f\xd9\xda\x2b\x6a\x94\xd0\x64\xa0\x3a\x91\xe1\x4c\xe1\x27\x79\x83\xf0\xa3\xc8\x6e\xd6\x5a\x35\x55\x3e\x81\x97\x3b\x34\x13\xf8\x8b\x90\xba\x57\x3a\x36\xb6\x7c\x90\x47\x6a\xaa\x1c\x75\xc1\xbe\xae\x9b\x72\x3a\xea\x24\x28\x1e\x1b\x5e\x33\xa1\x8d\x2b\xdf\xe3\x26\x50\x6b\x75\x2b\x73\x0c\xc4\x08\xda\x8a\x81\x1d\xc6\x89\x3f\xcf\xe1\x59\xb5\x73\x25\xb4\x1d\xbc\x7c\xad\x1c\x69\x88\x74\xbd\xcc\x46\x6d\x79\x01\xe2\x58\x8e\xd8\x5b\xe7\x3a\x4b\xe3\xc8\x46\xee\x91\x9b\x4a\x64\x94\x14\x38\xf1\xb9\xac\x8c\x15\x55\x86\x13\xd8\xa9\x06\x32\x16\x71\x13\xb0\xa2\xa1\x04\x34\x95\xbc\x03\x2b\x4b\x34\x56\x94\xb5\x0b\xe3\xbd\x1b\xde\xc1\x4f\x18\x38\x79\x21\x2c\x9e\xf0\xc4\xb1\x28\xd2\xb1\xea\x42\xd8\x95\xa2\x78\x8e\x82\x5f\x55\x99\xa6\xf4\x15\x21\x8e\x76\x5c\xab\xcb\x2e\x4b\xc8\x12\x08\xbf\x07\x76\xd8\xd3\x6f\xc7\x1e\x28\x0a\x20\x73\x2b\x34\x05\x86\xe4\x59\x8a\xc2\xa8\xa8\x1d\x5c\x26\xb6\xd8\x79\xc9\x10\xd6\x6a\xb9\x6c\x6c\x67\x67\xbe\xcb\x1c\x4e\x5a\xa2\x49\x09\x91\x1f\xa3\x59\x14\x2d\x04\xc3\x95\x13\x7e\x8a\xfe\x5d\x60\x83\xd7\x97\x57\xbf\x37\xa0\x19\xa7\xc3\xdc\xe0\xbe\xcf\x3d\xee\x83\x45\x0e\x9d\x0a\xc6\x3d\xf6\x99\x0c\xd2\x65\xd2\x07\xfc\xf0\x8a\x45\xc7\x11\x0b\x37\xe0\x40\xc0\x90\x70\xc2\x22\xc5\x61\x20\x36\x71\xeb\xb2\xf0\x38\x8d\x8c\x28\x58\xdd\xb1\x9a\x0c\x9e\x4f\xd0\x58\xc7\xf5\x9b\xef\xe8\x3b\xf0\x6e\xe5\x08\x15\x17\xc1\xa5\x92\x36\xa0\xe2\x50\x64\x1b\xaf\x9b\xee\x55\x6e\xe6\x9e\x44\xb9\x43\x6d\x0e\xef\xb9\xe5\x81\x2d\xdc\x5e\xa3\xc1\x35\xf4\x73\x5c\xf8\xc6\x03\x46\x9f\xfe\xba\xc1\x4c\x9e\x9b\xd6\x80\x38\x3d\xec\x99\xd6\xe3\x4d\x48\x74\xba\x74\xbd\x54\xe7\xb6\x71\xdb\x39\xab\x52\x27\xd3\x7e\xee\x96\x25\x4f\xe4\x39\xe6\x47\x5d\x53\xb2\xa0\x22\xcf\x19\x14\x4d\x78\xee\xa0\xde\x33\xd3\x29\xb1\x48\x95\x9f\xda\x7b\xea\x3b\xba\x1e\x69\x32\xa7\x2f\xe5\x93\x7a\x14\xc6\x39\xa4\xae\xf1\x83\xbc\x51\xd7\xe5\xb1\xae\xa8\xeb\x3d\xd2\x0f\xdd\xe3\xec\xf0\xf7\x19\x9c\x50\xbf\x6e\xb1\xc6\xca\x2a\x40\x61\x64\xc1\x71\xd0\x2d\x6a\xcb\xb5\x68\xfc\x4d\xe8\x1d\xaf\x84\xe3\x09\xb8\x54\x9a\xd3\xfa\x89\x83\x12\x36\xb6\x8c\xdf\x5c\x50\xac\xbe\x59\x5f\xa3\xe4\x82\xc6\x50\x10\x1f\x56\x89\xb5\x82\xb7\xf0\x57\xce\x09\x88\xf0\xd8\x74\x95\x68\x37\x2a\x96\xc5\x9b\x66\xb5\x92\x8e\x21\xd6\xf2\x96\x7d\xd4\x92\xed\x0b\x47\x6e\x6a\xe5\x33\x39\x1e\xc5\x43\x8c\x46\xf3\x71\x42\xd4\x9d\xd9\x12\xc3\xa4\x9d\x4a\xbb\x6a\xc5\x3b\xe9\x8d\x77\x7c\xe4\x24\x7f\x2d\x4a\x34\xf3\x4e\x25\xb6\x2f\xda\x72\xd8\x78\xfb\x1d\xf2\x7a\xd7\x34\xd6\x75\x04\x16\xfe\x6e\x70\xe7\xa9\x25\xb4\xb3\x76\x5b\x51\xf9\xf1\x97\x98\x91\x56\xbc\x76\x78\x5c\x0f\xfa\xd4\xec\x40\x0b\xea\xd0\xd7\x23\x87\xd8\x9d\xf0\xb8\x52\x9e\xe3\x1d\x29\x3e\x3a\xc4\x13\x13\xf7\x69\xd2\x9f\xe7\x7b\xd7\xe6\xd7\x1f\xce\xe6\xfb\x0c\x39\x9b\xc1\xf3\xb8\xfa\x2e\xa9\x68\x7c\x56\x31\x4c\x29\x9a\x14\xef\xd4\xb9\x4d\x03\xa9\x5b\x27\xda\x9f\xe5\xc9\xa7\x3d\xaf\x71\xd7\xcb\x4f\x6e\x44\x95\x17\xe8\x2c\x06\x13\x99\x02\x1d\x4e\x78\xda\xb6\xf1\xdf\x1b\x93\x8c\xcd\x7c\x12\xe0\x73\xa1\x73\x51\x4c\x53\xc1\xed\x4c\x16\xbe\x5a\x90\xa8\xf4\x04\x8e\x5c\xb9\x1b\x42\xbb\xd3\xf6\xab\x01\xb1\x24\xa2\x4e\x35\x96\xea\x16\x4f\x6f\x70\x37\x87\x9b\x7e\x55\x5d\xfb\x14\x1f\x07\x2c\x14\x2c\xe0\xfd\xaf\x4f\xf6\xc6\x67\xf0\xcc\x37\xdd\xa1\x23\x04\x58\xb8\x15\xf2\x6e\xcc\x4d\xf4\x60\xa8\xe7\xfb\x9b\x5f\xbf\xea\x39\x30\x95\x2c\x5a\xe7\xa5\x92\x45\x17\xdb\x9e\x0d\x60\x5b\x31\x34\x81\xc0\x94\x8e\xb1\x5c\xaf\xb3\xbe\xba\x89\x79\xf1\x98\xc1\xdc\xd3\x1a\xd2\x98\x06\xdb\xc4\xa6\x3f\x98\x15\x21\x70\x60\xe4\x36\x53\x4a\x3e\xea\x66\x64\x29\x0b\xa1\x93\x93\x69\x04\x16\xef\x44\x49\xdd\x45\x05\xff\x4b\x8a\xe1\xe9\xc5\x05\x39\xdd\x6e\xa3\x2b\x02\x93\x15\x39\xcc\x6e\xcb\xce\xf9\x32\xab\xc6\x9d\x0f\x73\x39\x75\xb7\x5f\x90\xee\x78\xb6\x0e\xd0\x33\x57\x3d\xe0\xd8\x6d\x49\xae\x8d\xe6\xc0\x25\x62\x8e\xb9\xe4\x69\x4d\x60\xbb\x91\x19\xd7\x16\x6f\x37\x5c\x01\x1e\x3e\x1d\xc2\xc3\x91\x92\x38\xd5\x38\xed\xe6\xab\xd8\xc0\x55\xb1\xb1\x7e\x39\x16\xeb\xbd\x74\x43\x1c\x3b\x8d\x96\x62\x12\xda\x5c\xb6\xf4\x9b\x38\x2d\x9c\x85\xbc\xc4\x3b\xb4\x13\x78\x53\x88\xdd\x04\xde\xa1\x96\x68\xba\xfb\x14\xbe\xb2\xce\x9d\x74\xd8\x8a\x5d\x52\x58\xe1\x40\x64\x85\x30\x86\xa2\x1a\xd2\x1f\x81\x40\xa3\x62\xc9\x1f\xf6\xe7\xe1\xfb\x27\x85\x7c\x07\x0e\x5b\xf1\x8c\x44\x05\x27\xdf\x7c\x1b\x78\xe1\xf4\x77\xdf\x7c\x3b\x7b\x7a\x71\x71\x76\xc2\x15\x29\x2e\xf6\xf4\x80\xa4\x81\x6f\xbe\xbd\x27\xc2\xe5\x56\x73\xf8\xe5\x55\x65\xfb\xfb\x3e\x84\x56\x29\xee\x06\x51\xa3\x40\xcc\x6f\x2f\x7b\xa6\x9e\xf6\xfa\xf6\x4f\x81\x85\x84\x8b\x8f\x7a\x5d\xd2\xa5\x90\xa5\xb4\x98\x9f\xfb\x21\x30\x1f\x86\x36\x62\xca\x84\xa8\x34\xf4\x6d\xb0\x2b\x57\xea\xb0\xb8\x35\x95\x1f\x34\xcc\xcb\xf5\x6d\xd3\x55\x14\xce\x5a\x45\xba\x63\xdc\x99\xb2\x52\xdc\x05\xfa\x1d\x8d\xbf\x7e\x98\xf4\x28\x3e\xe9\x74\x1f\x70\xa0\x08\xb7\x41\x15\x0e\x6d\x7a\xdb\x2f\xcc\xf7\x0b\x6a\xfd\x55\x9a\xdd\xbe\x6a\x19\x21\x13\xd5\x50\x22\xdb\xfa\x45\x76\xad\xbe\x3a\x39\xa4\xdd\x61\x54\xd0\xe7\xc7\x5a\xf4\x63\xf1\xd8\x80\x86\x62\x34\x47\x46\x71\x9d\x7d\xa1\xa0\x06\x46\xd5\xd1\xfa\xc6\xff\x42\x25\xed\x9e\x48\x77\x76\x1b\x3b\xfa\x52\x04\x8d\x79\x90\x4b\x48\x2b\xfe\x24\x8d\x9d\xc3\x7b\x8f\xd9\xa1\xba\xdb\xfd\x86\xc3\xc5\xb7\xbe\x1d\x2c\x62\x97\xb1\x11\x4d\x24\xcd\x97\x3a\xe5\x17\x11\x18\x59\xf0\xe4\x9b\x3f\xac\xda\xc9\x77\x7a\x74\xa9\x93\xef\x3f\xb6\xce\xa9\x65\xb7\xbe\x94\x7e\xae\x22\xa7\x98\x94\x63\xbf\x3c\x18\xa3\x73\x57\xf6\x94\x83\x41\x2d\x45\x11\xf8\xd7\xe5\xc8\xc3\xfe\x25\x71\x6b\x04\xf6\xc6\x75\x34\xb0\x11\xb7\x98\x1c\x8b\x67\x40\x7e\x16\xec\x36\xb0\x27\xdf\x83\x1b\xf5\x64\x04\xf7\x8e\x7c\xd7\x52\xec\x62\x69\x0e\xef\xb9\x6a\x5c\x37\xe4\xc9\xbc\x7a\xe1\x12\x80\x69\xa3\xe4\x2c\x7e\x1b\x70\x39\x63\x1a\x0e\x81\xb9\x73\x3e\x53\x77\x1a\xa5\x83\x80\x34\x9d\xed\xdb\x25\x42\x53\xc9\x7f\x34\x5c\x14\xe3\x0f\x0c\xb2\xf5\x66\xb3\xcd\xa8\x90\xda\x67\x0f\x5d\xd8\x40\xb4\x63\xca\xe3\x9d\x1b\xf2\x70\xfe\xe5\x90\xdd\x4c\x25\xb9\xdb\x66\x38\x83\x76\x40\x5f\x1e\x11\x60\x8f\xde\x97\x12\x5f\x3f\xfc\x38\xe1\x75\x8d\x1f\x24\xba\xae\xcb\x63\x05\xd7\xf5\x1e\x29\xb6\x7b\x0b\xfd\xb9\x85\xb6\x2d\x1d\xf6\x69\xcc\xd4\x3d\xf6\x42\xea\x12\x69\x49\x76\x93\x7a\x73\x81\x96\x0b\xa6\x43\xd7\x0a\x31\x37\x2e\x6a\xbc\xc5\x90\x85\x30\x99\xd2\x1c\x3b\xa4\x25\x18\xcb\xc6\x82\x74\x27\xe8\x23\x40\xee\xb4\x54\x6d\x9e\xf2\x10\xf3\xfb\x3c\xf8\xc7\x3d\x67\xd0\x0f\xe5\x2b\x0a\x5d\x2b\x4e\xc4\x1f\xc9\xbc\x73\xbf\x50\x0d\x33\xe0\xfb\x96\xe2\x4e\x96\x4d\xd9\x6e\xa3\x70\x87\x23\x0e\xd7\x21\x60\x03\xd7\x39\xa4\xa8\xba\xa3\x6d\x47\x4e\x37\xc6\x10\xe1\x27\x5c\x63\x95\x0b\xbd\x9b\xc0\xcb\x5a\x66\x13\xa2\x0d\x4e\xe0\x97\x2a\x53\x65\x49\xae\xe3\x73\xfe\xbf\x1b\x2b\xf8\xd3\x73\xdd\xc4\xf7\x88\xba\xa3\x41\xef\xb1\x4b\xbb\x49\x67\xf2\x83\x85\x45\x43\x4e\xa4\x5b\xb8\x85\x73\x23\xbf\xfe\xba\x43\xa3\xc5\x21\xe7\xb2\x16\x95\xcc\x4e\x4f\x9e\x05\x7e\x88\xdc\x67\xc2\x92\x76\xef\x27\x51\x9a\xb9\x6b\xcf\x83\xdc\xd7\x7a\x1e\x9d\xde\x32\xc3\x61\x1f\x11\xfe\x85\x32\xa3\x5e\x79\x81\x9b\xcb\x97\x4c\xe6\x7a\x14\x46\x56\x17\x70\xe3\x87\x95\x16\xb8\x1d\x9b\xc7\xd6\x15\x70\xef\xb1\x45\x05\x7d\x4d\x11\xfe\x3e\x83\xf6\x7c\x7d\x79\xc5\x0a\x74\xab\x45\x6d\x38\xe1\xf6\x9c\x2f\x48\xe1\x2b\x75\xdc\xa6\xcb\xb5\xcc\x5d\xa1\xe0\x75\xd3\xd0\xa3\xcb\xc6\xb9\x1d\xc7\xb0\x9b\x13\xe1\x85\x34\xab\xe0\xda\xf0\x02\x2d\x42\x2d\x33\xae\xf2\x8d\x87\x8f\xfc\xfd\x39\xec\x35\x0c\x5f\x9e\x13\xc1\x8d\xba\x45\x27\xcc\xe1\xb0\x1f\x21\xf3\xe8\x43\x1c\x6a\x42\x73\x3b\xda\xc8\xe7\xc0\xe6\xdd\xab\x87\xa6\xe1\xb2\x8b\x83\xfd\xb0\x2d\xcf\xef\xf7\x4d\x8f\x0b\x1c\xec\xdf\x66\xbc\x5e\x08\x2b\xe6\x34\xe3\xe7\x9d\x57\xa3\xba\x06\xe4\xbb\xbd\x8f\xe1\x1e\x2b\x36\xd2\x72\x9a\x83\xad\x43\x3e\xd2\xef\x75\x1c\xbd\xf8\x45\xe6\x10\x83\xf4\xce\x07\x5a\x8f\x03\x9f\xfc\x2a\xc0\xa1\x65\xe8\xb6\x4e\x68\xbf\xd7\x23\x25\x7e\xb7\x57\x97\xe2\x30\x44\xf2\x83\x1d\x22\x7a\x83\x84\xee\x76\x6b\xeb\x61\x52\xf2\xf6\x6e\xb8\xe9\xd1\x34\xbc\x1f\x0e\x58\x73\x3e\x2b\xb7\xff\x81\x09\xba\x60\xba\x0e\x68\x7c\x8f\x73\xdc\x23\xde\x6f\x92\xd2\x71\x91\x52\x75\xbf\x69\x8f\x78\x8b\x1e\x35\xef\xed\x10\x11\xd9\x7b\xb7\xdf\xad\x25\xde\x62\xa0\xb4\x13\xc6\x6d\xbe\x1e\x34\x62\xfe\xac\x17\x33\xee\x21\x9b\x45\x3a\xe3\xca\xa7\x29\x64\xfe\x9b\x58\xb4\xa0\xdd\xc6\x59\x32\xdf\xfa\xb4\x55\x66\x93\x07\x18\xb5\x7d\x4d\xca\x51\xd8\xca\xfe\x75\x8c\x51\xf3\xbd\xc9\xaa\xa5\x46\x31\x74\x1f\xcc\xaf\x05\xcb\xe4\xda\x7c\x05\xc2\x7c\x15\xb0\x48\xd6\xa9\x6f\xc8\xc2\x2c\xf7\x55\x89\xcc\xf7\xd5\xc8\xbc\x8b\x37\xbd\x1a\x54\x28\x7d\xed\x90\x5c\x7d\x94\x02\x38\x1b\xaf\x5f\x7a\xc7\xc8\xee\x81\xb2\xa7\x6f\x98\x73\xdd\x82\x76\xf5\xce\x48\x28\x51\x09\x0d\x03\x3a\x3e\xaf\x54\x33\x05\x18\x6d\x15\xe6\x3d\x1d\xbd\xb8\xb5\xbd\xfc\xfe\x4e\xa7\x4b\xab\xc4\x8e\xc4\x73\xae\x82\xbb\x0d\xe6\xfc\x25\x28\x7c\x95\x8e\xbf\xd6\xd0\x6a\x89\xb7\x38\x5c\x6e\x72\xdf\xa1\x50\xe7\x64\x37\x35\x88\xde\x59\x4d\x97\xc2\xae\xb5\x22\x6d\x10\xe1\xd1\x90\x62\xed\x06\x75\x25\x81\xed\x11\xa5\x31\x47\xd4\xf6\x56\xb2\x17\xfb\xb9\xdb\x64\xaa\x38\xce\x96\xef\x81\x60\x7f\xc8\x9f\xd8\xd6\xe1\xc4\x58\x4c\xca\xb8\x1b\x85\x0e\x6f\x3c\x78\x58\x6f\xfc\xa5\x2b\xf1\x47\xef\x1e\x1b\x37\x1b\x2e\x09\x75\x1b\x4f\x65\x63\x38\xe3\x5a\xc8\xea\xc6\x0d\xe6\x97\x63\x60\xe2\x71\xab\x22\x64\xbf\x20\x6e\x51\x65\x45\xc3\x47\xd8\xe3\xa1\x40\x9e\x48\x38\xed\xe7\xb7\xca\xbc\xc4\x38\x97\xb3\xfd\x78\x70\x4e\x75\xac\xd5\x4c\xeb\x36\xf7\x43\xd4\xc1\x13\x7a\xc9\x22\x87\xfb\xac\xdc\xcc\xf2\xa0\x93\x1d\xf8\x0e\xb4\x4a\xf9\xb3\x8f\x58\x59\x69\xc3\x85\x9f\x78\x27\x8d\x9d\x80\xb4\x50\x29\x20\x4f\x19\x75\x1b\xbd\x2d\x5d\x59\xa2\x96\x21\x83\x96\x64\x09\xe3\x1c\x8f\x4c\xb1\xe5\x96\x39\x70\xcd\x56\x77\x8a\x34\xab\x5e\x0d\xb0\x5f\x2e\x9f\x3b\x17\x2b\xa5\x19\x57\xb7\xe7\x53\xb7\xab\x7c\x64\xe0\x9f\x18\x8c\xdb\xe9\xdd\x1f\xf8\x32\x16\x7e\xb8\xa3\x59\x85\xda\x1a\x77\x5c\xd1\x27\x03\x44\x05\x58\xd6\x76\xd7\x97\xaa\x40\x70\x9a\x7f\xe0\x61\x66\xe0\x0e\xf8\xc0\x4a\xf7\x1c\xa1\xe2\x9d\x95\x97\x34\x44\x4a\xa2\x55\x53\x9d\x9e\xcd\xe1\x4f\x1f\xfb\xf7\xb9\x4e\xdb\x56\xc7\x6f\x22\x3c\x24\x31\x5d\x1d\x37\xcc\x83\x43\x6d\xfa\x8b\x38\xd4\xa6\x4f\xef\x9e\x52\x1f\x9a\x6e\x58\x84\xb1\xd3\x8e\xea\x76\xd4\x81\xa8\x3e\x5a\x53\x69\xde\xb9\x9b\x6a\x4e\xd5\xca\xe1\xf8\xfd\xd7\xf7\x0e\x48\x4e\xc0\x1c\x4e\xbc\x66\x61\x09\x0c\x3a\x45\x40\xb8\xf5\x46\xad\xe0\x1e\x18\xad\x9c\x4c\x8f\x1e\xac\x4a\x56\x6d\x91\x3c\xef\x37\x6c\x17\x6e\xd1\x3e\x1e\x6a\xd6\xe2\xb2\xe8\xbf\x38\xd4\xa5\xa5\xd9\xa2\xff\x62\xc0\xed\x1d\x5a\xd9\xc5\xbd\xeb\x3d\xd6\x79\xdd\x37\x36\x9c\x87\xd9\x86\xf3\x51\x5c\x9d\x1f\x2a\x37\x2b\x5e\xa0\x3c\x96\x5a\xfc\x7b\x32\x34\xfb\x28\x8e\x76\x71\x7b\x1e\xd1\x43\xf2\x36\xfb\x71\xdc\x23\x53\x38\x7b\x80\x46\x66\x73\xee\x73\x03\xc2\xdf\xe7\x4f\x8b\x1f\x70\xa3\x7c\xd5\x3a\x9f\x9c\x0d\x8a\xf7\xf7\xc9\x65\x95\xed\xf5\x15\xa3\xdc\x29\x97\xfa\xa9\x20\x5c\x60\xc1\x06\x3e\x42\xe3\x1b\x76\x65\x66\x82\x2d\xde\x33\x0f\xde\xd3\x59\x22\x59\x53\x02\xf8\x40\x9f\x6a\xef\x1a\xd0\xd9\x0c\x5e\x8b\x72\xcf\x4c\x32\xfa\xdb\x0d\x56\xc1\xf3\x77\x15\x77\x7e\xf8\xfe\x9d\x1d\xfd\xa1\xef\x3d\xb2\xf0\x22\x49\x9d\x0e\x8d\x3a\x44\xa4\xe0\x3f\x8d\x19\xf8\xc8\x05\xc3\xf1\x22\x08\x77\x65\x00\xfb\x1d\xfe\x2a\x15\x1e\x8a\x0f\xd8\xa7\x7c\x10\x8e\x83\x8c\x1c\x7e\x5c\x22\xab\x83\xd1\xbb\x7f\x34\x42\xa3\xaf\x01\x70\xf7\x48\x76\xce\xc8\x8c\x1e\xdb\x30\xa0\x57\x25\xd7\x5c\x74\xc7\xe6\x4b\x9a\x3a\xa3\xfe\x28\xaa\x0a\x75\x67\xd4\x78\x33\x42\x3b\xd8\xa4\xef\x52\xf3\xee\x8d\xe0\xa2\x29\xa8\x50\x68\x78\xfa\xcd\xc5\xc5\xdd\x77\x7f\xb8\x38\x8c\xd6\x92\x47\x1a\x89\xd6\x3b\x95\x49\xbf\x38\xc6\x91\x81\xab\xd4\xbb\x58\xfd\xde\x80\x71\xed\x36\xaa\xc4\x5a\xac\xb1\x53\xa8\x03\x6f\x94\xbf\x7e\x95\x2b\xfa\x4a\xc1\x05\x3f\x27\x7c\x66\x64\xad\x45\x79\x32\x81\x13\xbb\x95\xd6\xa2\xa6\xc7\x5c\x9a\x4c\xe9\xfc\xe4\xc8\x21\x1c\x37\xa2\x49\x2a\x3b\x0f\x2e\xef\x6f\x7a\x9d\xf3\x38\x0e\xeb\xf6\x39\xc6\x19\xdd\xd6\xc7\x16\xac\x07\xfb\x21\x74\x09\x9d\x7e\xd3\x9b\xa7\x1f\x90\x88\x4b\x08\x03\x8b\x94\x4c\xfb\x4d\x13\xaa\xc0\x22\xa5\xd1\x00\x54\x47\x12\x82\xe8\x9e\x1e\xe7\x94\xa4\x77\x60\x0f\xfb\x25\xde\x2d\x89\xd0\xbe\xa0\x7f\xf2\x28\xdf\xe4\x11\xf7\x66\x0f\xa6\x8c\x3f\x8b\x87\xf2\xa0\x1b\xb5\x8f\xd8\xd5\xf0\xf7\x78\x3f\xe5\xd3\x93\xff\x0b\x00\x00\xff\xff\xab\xc6\xb5\xf8\x95\x63\x00\x00" func utilityMetadataviewsCdcBytes() ([]byte, error) { return bindataRead( @@ -173,11 +195,11 @@ func utilityMetadataviewsCdc() (*asset, error) { } info := bindataFileInfo{name: "utility/MetadataViews.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x38, 0x2b, 0x54, 0xa2, 0x25, 0xff, 0xbe, 0xa5, 0x57, 0x85, 0x51, 0xed, 0x64, 0x39, 0x67, 0x79, 0xc1, 0x4b, 0x1e, 0x56, 0x8, 0x4b, 0x57, 0x6a, 0x72, 0xd2, 0x2a, 0x7b, 0xe6, 0x12, 0x58, 0x71}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x10, 0x6d, 0x67, 0x22, 0x2e, 0x22, 0x41, 0x93, 0x6b, 0xed, 0xd6, 0x12, 0x5d, 0x31, 0x50, 0x78, 0x22, 0xd3, 0x14, 0x70, 0x8a, 0x22, 0x4a, 0xfd, 0x1c, 0x65, 0x29, 0xc4, 0xe1, 0x33, 0x18, 0xf6}} return a, nil } -var _utilityNonfungibletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x57\x41\x8f\xdb\xba\x11\xbe\xeb\x57\xcc\xcb\x03\x9a\xdd\xc0\xb1\x7b\x28\x7a\x30\x10\x34\xed\xdb\xb7\x80\x2f\xdb\x87\xad\x8b\x1e\x82\x00\xa6\xc5\x91\x4d\x2c\x45\x2a\x24\x65\xc7\x0d\xf6\xbf\x17\x33\x24\x25\xca\xf6\x26\x9b\x5b\x73\x89\x57\x22\x67\xbe\xf9\xe6\x9b\x8f\xd4\xe2\xdd\xbb\xaa\xfa\xf5\x57\x58\xef\x11\xee\xb5\x3d\xc2\x83\x35\xef\xef\x7b\xb3\x53\x5b\x8d\xb0\xb6\x4f\x68\xc0\x07\x61\xa4\x70\x92\x17\x6e\x1e\xac\xc9\xef\xf9\xf5\x06\x6a\x6b\x82\x13\x75\x00\x65\x02\xba\x46\xd4\x58\x55\x14\x6f\xf8\x13\xc2\x5e\x04\x10\x5a\x5f\x8b\x9e\x77\x7b\xa8\x6d\xaf\x25\xfd\xdd\x58\xd7\x42\xb0\xf3\x6a\xd5\x80\x80\xde\xa3\x83\xa3\x30\xc1\x43\xb0\x20\xb1\xd3\xf6\x04\x02\x0c\x1e\xe1\xe1\x7e\x3d\xec\x9f\x41\xd8\xa3\x72\x23\x9a\x23\x87\x33\x88\xb2\x0a\x16\x54\xdb\x69\x6c\xd1\x04\x5a\x06\xe7\x45\x8c\x58\xe7\x8c\xfd\x32\xce\x5e\x1c\x90\xf2\x37\x56\x13\x4d\x54\x0c\x05\x72\xbd\x46\x0f\xc2\x48\x30\xa2\x55\x66\x57\x71\xa9\x61\x52\xbd\xef\xb0\x56\x8d\x42\x3f\x4f\x0c\xde\xaf\x37\xe0\xd0\xdb\xde\x65\xaa\x6a\xeb\x70\x78\x04\xe1\xd4\x25\xce\x1c\x76\x0e\x3d\x52\xed\xc2\x70\xb9\xca\x70\x74\xdf\x0a\x17\x06\x8c\x29\xf0\x6f\x56\x6b\xac\x83\xb2\x66\x03\x8f\x93\xf8\x63\x68\x8a\xea\x83\x75\x84\x9a\xa9\x7d\xeb\x13\x8d\x79\xef\xbc\x5a\x51\x2b\x6b\xdd\x4b\x5e\xd4\xe0\x11\x9a\xde\xf0\x3b\x6e\x81\x60\x06\x08\x85\x3d\x1a\x74\xf4\x08\x85\x57\xfa\x54\xb5\x96\x49\x7a\x42\xe3\x09\x28\xd1\x62\xfb\x00\xb6\xe1\xd5\x65\x0a\xc6\xfb\x87\xb3\x07\x25\xd1\x6d\x78\xe5\xe6\x11\x6b\x54\x07\xfa\x73\x80\x3b\x90\xe8\xb9\x0e\x5f\x3e\x01\x89\xb5\x16\x0e\x0b\x70\x47\x15\xf6\xe0\x6d\x8b\xd0\x39\xe4\xa0\x9d\xf5\x4c\x93\x54\xbc\xa2\x4a\xac\x7e\xe9\x95\x43\x06\x35\x72\x56\x74\xb7\x46\x17\x84\x32\xa9\xa7\x1c\x68\x8b\x7b\x71\x50\xd6\x0d\xd3\xe0\xa3\x52\x4e\x40\x10\x3c\x76\xc2\x89\x80\xb0\xc5\x5a\xf4\x04\x33\xc0\x4e\x1d\xd0\x73\x0e\x56\x30\xfd\x10\x5b\xa5\x55\x38\x51\x26\xbf\xa7\x7d\x02\x1c\x36\xe8\xd0\xd4\x48\x22\x8d\x0a\x2e\x21\x11\x5c\x6b\xf4\x09\xf0\x6b\x67\x7d\x8a\xd7\x28\xd4\x32\xaa\x6e\xac\x5d\x19\xb0\x06\xc1\x3a\x68\xad\xc3\x2a\x71\x3e\xd2\x35\x87\x15\xcd\xa0\xb7\x09\x18\x81\xf2\xe7\xa8\x5a\xf1\x84\x50\xf7\x3e\xd8\x76\x68\x42\x22\x6d\x32\x40\xd3\x46\xd0\x58\x5a\x38\x08\xa7\x6c\x4f\x21\x95\xd9\xa5\x5e\x50\xf8\xa8\x87\x79\x55\xfd\xe3\x04\xbd\x27\x3e\x87\xc8\x5c\xc2\x18\x68\x96\x40\xd9\x86\x25\x39\xd5\xb8\x87\x5a\x18\xf0\x68\x64\x45\xbb\x5c\x14\x4b\x56\x5b\x87\xe8\xde\x07\xfb\x9e\xfe\x9f\x71\x6e\x12\x1e\xb5\xcc\xec\x08\x1f\x27\xe1\x69\x26\x58\x02\x6a\xa4\xa8\x1a\x34\xca\x1d\xba\xea\x62\x9c\xd6\x96\x53\xe5\xa9\x23\xd5\x1b\x1b\xf6\xe8\x18\xe2\x6c\xb0\x25\xf6\x06\x4f\xdc\x9c\x38\xb4\x74\x22\x8e\xc6\xc3\xfd\xba\x6a\x9c\x6d\x2f\x7a\xca\x3e\x65\xa0\xce\x0e\x22\xb1\xb3\x5e\x85\xa1\x93\x60\xcd\x24\xd7\x5b\x5f\x4d\x35\x5a\x5b\xea\x44\x88\xf2\x0d\x4e\x18\xdf\xa0\x9b\x57\xd5\xbb\x45\x55\x2d\x16\xec\xe4\x2d\x89\xb7\x34\xc7\xc2\xdf\xe0\x9f\x1c\xba\x7c\x4b\xcd\xd2\x9a\x36\xab\xb6\xb3\x2e\xc4\xb6\x14\xfd\x56\xbe\xf0\xf6\xc5\xa2\xea\xfa\xed\x95\xd0\x97\xae\xfa\xad\xaa\x00\x00\x12\xaa\x60\x83\xd0\x60\xfa\x76\x8b\x8e\x3d\x21\xb6\x8e\x95\xaa\x7c\x74\x3d\x65\x00\xbf\x2a\x1f\x78\x22\x68\x2f\xa5\x3a\x08\x17\x37\xff\xab\xef\x3a\x7d\x5a\xc2\xbf\x57\x26\xfc\xf5\x2f\x43\xf0\xdf\x0f\x11\xa6\x08\x80\xad\x0a\x01\x25\x1c\x89\xe3\xd4\x87\x02\x2a\xd5\xa1\x82\x12\x5a\xfd\x17\x65\xda\x3e\xa4\x41\x0e\xf3\x5b\x5a\xbc\x1a\x17\xde\xdc\x5e\x4b\xa5\xfc\x34\x9b\x88\x05\xd1\xf3\xac\x04\x33\xcb\xfb\x94\x91\xaa\x16\x81\xd5\x38\x18\xe7\x85\x2f\xa6\xc0\x01\x8e\xa2\x08\x02\xa4\xa3\x79\x89\x76\xb1\x80\xd5\xc5\x5e\xe5\xc1\xd8\x10\x7d\x17\x44\x5d\xdb\xde\x84\xb7\x9e\xcd\x5e\xec\x70\x06\x1b\x0a\xb3\xe1\x56\xc3\x16\x61\x63\x94\xde\xcc\xaf\x73\xf0\x9f\x94\xfa\x46\xc9\x4c\xf6\x8c\x51\x2c\xe1\xef\x52\x3a\xf4\xfe\x6f\x57\x29\x79\x89\x8f\xa4\x71\x94\x3c\x48\x93\x83\xe0\xac\xaa\x90\x99\x4a\x56\xf7\x1a\xa2\xca\xe8\x2f\x14\x74\x17\x97\x4c\xea\x09\xf6\x5a\x35\xab\xe9\xa5\x25\x49\xc8\x0f\xe7\xff\x78\x3d\x39\xcf\x74\x79\x68\xc1\x8a\xd4\xf7\x8d\x57\x14\x73\xd0\x1b\xf5\xa5\x47\x58\xdd\x25\xd2\x44\xbd\x67\x99\xee\x85\x1f\x96\x52\x40\x8d\x01\x46\xc0\xfc\xea\x79\xc0\xf9\x18\xcf\xb0\x76\xe0\x9e\xfc\x24\x81\x23\x95\x5d\x33\x50\xaa\x21\xef\xe7\xab\x54\xa3\x4c\x3c\x83\x12\x72\x32\x25\x94\xd1\xf1\x28\x66\x8a\xc7\x0e\x4f\xb5\x5c\xd6\xfa\x70\xbf\x5e\x9e\x97\xf9\x43\xec\x05\xc7\x16\x5a\x94\x8a\x4e\xce\x2c\x77\x0f\xd9\x36\x0b\xd3\x7c\x05\xd7\xf9\x32\x31\xe5\x7b\xf0\x64\x87\x74\x39\x19\xae\x51\x43\x8e\x42\x53\xe4\x7a\x71\x91\x0a\x10\x4f\xe3\xc8\x88\x9b\x94\xd6\xf4\x66\x08\x7b\x93\x7f\xac\xee\x72\xad\xb7\x4b\xf8\x38\xe5\x83\x37\xd2\x3d\x64\xfa\x88\xfe\x39\xf4\xbd\x0e\x73\x25\xe1\xc3\x07\x28\x63\xbd\x21\xa1\xac\xee\xb2\xf2\x47\x2f\x88\x33\xd5\xf6\x3e\xd0\x10\xf3\x55\x50\xb4\x08\x22\x8e\x0b\xdd\x6c\xd0\xd3\x28\xac\xee\xde\x4c\xb2\x3d\x57\xd3\x5f\x3f\xe8\x46\x9a\x29\x9f\x79\xf8\xa9\x56\xe4\x8b\x5c\xf6\xff\x94\x28\x9f\x74\x41\x3c\x8d\x8d\x10\xfc\x4b\xb8\x5d\xcf\x52\xa6\x1e\x08\x29\xcb\x16\x9c\xa5\x2e\xd2\x97\x1d\x49\xc1\x6f\x98\x9f\xd8\x82\xdb\x97\x0b\xe5\x81\x19\x5c\x32\x1d\xe3\xb5\x6d\x5b\xbe\x6b\xe5\x0d\x5d\xbf\xd5\xca\xef\xa1\xb1\x6e\xf8\xb8\x98\x60\x79\xa1\xfe\x11\xf1\x1f\x14\xa1\x3e\x9b\x8d\xef\xc2\x2d\x17\xed\x30\xac\xee\xfc\xcd\xed\x12\x3e\x45\x6d\x7d\xbe\x58\xb2\xb5\xce\xd9\xe3\xc3\xfd\xba\xb0\xb6\xdb\x25\xfc\x29\x0f\xeb\x75\xc3\x48\x05\xd1\x7c\xd7\x8e\xae\x12\x93\x4f\x8f\xc2\x22\xb6\x98\x6f\xd9\x32\x7f\x79\x0c\xf7\x02\x72\x99\xec\x2d\x2f\x8a\x62\xa4\x62\x39\x4c\xe8\x6c\x10\xc8\xec\x1a\x55\xa5\x64\xee\x14\xbf\x13\x8e\x6f\xa7\x7b\xab\xe5\xe8\xc8\x09\xcf\x15\x79\xe4\x3b\x03\x1d\x1e\x92\xd6\x2e\xe1\xe3\xb7\xc8\xcd\x92\xf6\x3e\x57\xff\x17\x16\xf1\xbd\xe1\x88\xb3\x71\x39\x0c\x23\x16\x0f\x72\x20\xa7\x0c\x34\x6c\x0a\xd1\x41\xd2\x46\x25\x41\x38\x27\x4e\xaf\x53\x62\x19\x30\xaa\x10\x1c\x86\xde\x99\x34\xad\x4e\x9c\xb2\x35\xd1\xbb\x38\x4f\x0e\x73\x4f\xea\xeb\x3d\x79\x41\xd3\x65\xb2\xc7\x9c\x25\x29\x1b\xe5\xf8\x85\x14\x6f\xe1\xe5\x57\xf0\x95\x3c\x8b\x05\x78\x3b\x9e\xdd\xb1\x39\xfc\xe9\xe0\x50\x48\x90\x22\x08\xa6\x88\xef\xdf\x2d\x86\xbd\x95\xe9\xc4\x51\xe1\x67\xa6\xeb\xdc\xdf\x1d\x5e\xb1\x77\x8f\xba\x99\x0f\x2a\xfc\xa4\xe4\x67\xf8\xe5\x03\x18\xa5\x97\xf0\x86\x62\x48\x8b\xf1\xd2\xc6\x77\xde\xcb\xaa\x7e\x79\xad\x87\xd7\x0e\x45\xc0\xdf\xdb\x2e\x9c\x8a\x8f\x85\xf8\x94\x5b\x86\xf4\xea\xd2\xc5\x21\x7e\x4a\x45\xce\xcf\x25\x5d\x12\x79\x62\x0a\xed\x91\xe9\xf7\x55\x49\xd2\xd5\xdc\xd4\xe0\x8f\x05\x94\xc2\x01\x2f\x4f\xc2\x74\x0a\x66\x69\xcc\x35\x9a\x5d\xd8\xd3\x91\xf8\xe7\x74\x12\xc6\x1c\xb2\x1c\xc5\x7c\x04\x72\x65\x05\x51\x99\x9a\xe7\xea\x7f\x01\x00\x00\xff\xff\x2c\x4f\xdd\x28\xdc\x12\x00\x00" +var _utilityNonfungibletokenCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x5a\x4f\x8f\xe3\x36\xb2\xbf\xeb\x53\xd4\xeb\x00\x6f\xba\x03\x8f\xfb\x1d\x1e\xf6\xd0\x40\x30\x99\xa4\xd3\x0b\x63\x17\x9d\x60\xe2\x49\x0e\x8b\x45\x4c\x4b\x65\x9b\x3b\x14\xa9\x21\x29\x3b\xde\x4e\x7f\xf7\x45\x15\x49\x89\x92\xe5\xfe\x93\xec\xae\x0f\xc9\x58\x16\x8b\xc5\xaa\x5f\x55\xfd\xaa\xd8\xd7\x5f\x7e\x59\x14\x5f\x7c\x01\xcb\x1d\xc2\x9d\x32\x07\xb8\x37\xfa\xed\x5d\xab\xb7\x72\xad\x10\x96\xe6\x13\x6a\x70\x5e\xe8\x4a\xd8\x8a\x5f\x5c\xdd\x1b\x9d\x7e\xe7\x9f\x57\x50\x1a\xed\xad\x28\x7d\x51\x90\x14\xa9\x3d\xda\x8d\x28\x11\xfc\x4e\x78\x10\x4a\x4d\xc9\x4c\x6b\x1c\xb8\x9d\x69\x55\x45\x0f\x36\xc6\xd6\xe0\xcd\xbc\x58\x6c\x40\x40\xeb\xd0\xc2\x41\x68\xef\xc0\x1b\xa8\xb0\x51\xe6\x08\x02\x34\x1e\xe0\xfe\x6e\xd9\x09\x98\x81\xdf\xa1\xb4\xdd\xf7\x24\x4f\xd6\x8d\xc2\x1a\xb5\x67\xa5\xfc\xb1\x41\x07\x15\x6e\xa4\xc6\x0a\x76\x68\x31\x1e\xe6\x6e\xb9\x02\x8b\xce\xb4\xb6\xcc\x54\x0f\x27\x29\x8d\xc5\xfe\x47\x12\x11\x8e\x64\xb1\xb1\xe8\x90\x34\x13\x9a\x95\x91\x9a\xb4\x00\x57\x0b\xeb\x3b\x4d\xe6\x61\x8b\x6f\x8d\x52\x58\x7a\x69\xf4\x0a\x3e\x9c\xd9\xa9\xdf\x84\xe4\x3b\x6f\x2c\xba\x68\x82\x37\x2e\x1e\x37\x49\x99\x17\x0b\x0f\x52\x97\xaa\xad\xf8\xa5\x0d\x1e\x60\xd3\x6a\xfe\x8d\x4d\x25\x14\xf9\x91\xf4\x31\x07\x8d\x96\x1e\xa1\x70\x52\x1d\x8b\xda\xec\x11\x3c\xd9\xdf\x91\xca\x42\x57\x60\x5a\x0f\x66\xc3\x6f\xe7\x5b\xb0\xe6\x3f\x58\xb3\x97\x15\xda\x15\xbf\xb9\xfa\x80\x25\xca\x3d\x7d\x3d\x35\x98\xe3\x73\xb8\xfc\x09\x54\x58\x2a\x61\x31\x53\xee\x20\xfd\x0e\x9c\xa9\x11\x1a\x8b\x2c\xb4\x31\x8e\x0d\x56\x49\x7e\xa3\x88\xf6\xfd\xdc\x4a\x8b\xac\x54\x6f\x3d\x3a\xc7\xc6\xf0\xd9\x4a\xb4\x5e\x48\x0d\x5a\xd4\x52\x6f\x59\xd0\x1a\x77\x62\x2f\x8d\xed\xc0\xea\xe6\xac\xd2\x11\x48\x05\x87\x8d\xb0\xc2\x23\xac\xb1\x14\x2d\xa9\xe9\x61\x2b\xf7\xac\xe4\x1e\x95\x69\xd0\x3a\xde\x4e\xac\xa5\x92\xfe\x18\x10\x47\x60\xe9\xb5\x0f\xba\x95\x42\x93\x5b\x40\xe8\x63\x86\x88\x0e\x6c\x2c\xc5\x0d\x0d\xf3\xcd\x11\x5a\x47\x7a\x26\xb3\x39\xd6\xb8\x7f\x65\xc6\x8e\x76\xe4\x07\x72\xf5\x10\x45\x8e\xb7\x74\xa8\xab\x82\x56\xd9\xe0\x84\xe4\xc5\x06\xd1\xbe\xf5\xe6\x2d\xfd\x7f\xc6\xf6\x25\x87\x92\x29\xf4\x96\x0e\xc1\x9b\x50\x54\xb0\xe9\x05\x94\x48\x52\x15\x28\xac\xb6\x68\x8b\x13\xc0\x2e\x0d\x6f\x95\x70\x4d\x68\xd2\xc6\xef\xd0\xb2\x8a\xb3\x2e\x2c\x39\xc4\x1c\x1d\xfb\xc8\xa2\x2b\x2b\x02\xe4\xee\xef\x96\xc5\xc6\x9a\x3a\x46\x65\xef\x3e\x8e\x53\x0d\x25\xe5\x03\x7a\xb1\xc2\xc6\x38\xe9\x3b\xfb\x82\xd1\x83\xbd\xde\xb8\x62\xe8\xfb\xd2\x90\x91\x7d\x80\x85\xb7\x42\xbb\x0d\xda\x79\x51\x7c\x79\x5d\x14\xb2\x6e\x8c\xf5\x70\xf1\x93\xc4\x03\xc5\x98\xda\xa3\xbd\x28\x8a\xeb\xeb\x6b\x4e\x6c\x35\x81\x25\x4f\x1a\x73\xf8\x9e\x37\xca\x9f\x11\x3c\x95\xe2\x35\x51\x1c\x7b\x29\x79\x96\xb7\x1d\xa0\x3b\xe4\x12\x0e\x7d\xe9\xfa\x24\x78\x7d\x7d\x5d\x88\xb2\x44\xe7\x2e\x85\x52\x57\x7d\x62\xea\x13\xe3\x38\x85\xde\x40\xae\x38\x3c\x14\x05\x00\x00\x69\xf2\x5e\x03\x6a\x2f\x7d\xd4\x61\x63\x6c\x08\x6f\x76\xef\x0e\x3b\xdb\x0b\xc5\x51\x1c\x40\xc1\xf6\x17\xf0\x93\x68\x95\x67\x49\xb9\x3a\xb9\xb8\x9f\xe3\xea\x97\xed\xd7\x36\x95\xf0\x11\xbc\xe1\xdf\x80\x7b\xc6\x3c\xbf\xc6\x16\x7e\x72\xbb\x8f\xbc\xa8\xdf\x6c\xbc\x53\x4c\x57\x14\x50\x5b\xcb\x89\x3f\x29\xc8\x7b\xc6\xe5\x4f\xed\xf0\x3d\x49\xe8\x37\xf8\x6e\x1f\x1c\x27\xfc\x69\xbd\xc1\x5a\x7a\x38\x10\x24\xc9\x8e\x35\x7a\x51\x09\x2f\xc8\x8a\x29\xa7\xbb\x78\xca\xaa\x93\xb7\x08\xf1\x6f\xb4\x3a\xc2\x1a\x59\x84\xc7\x0a\xd6\x47\x86\x75\xf2\xc9\x8a\x9e\xdf\xdf\x2d\x83\xbe\xd5\xaa\x83\x78\x27\x27\x04\xa3\x86\x15\xbf\x22\xd6\x0a\x57\xe9\x18\x14\xe1\x1b\xb4\xa8\xa9\x18\x98\x14\x52\xe1\x0c\x07\x71\xaa\x12\xc1\x3b\xb7\x40\x63\xa3\x4f\x5c\x23\xea\x9a\xb2\x0a\xa3\xa1\xd7\x4f\xc6\x27\x7d\xa4\xb9\x37\x59\xea\x77\x9d\xe4\x94\x2a\xf9\xb4\xa5\xa9\x02\xd8\xa8\x6c\x64\xaf\x83\x89\x0e\xdb\x09\xda\x12\x4b\x29\x54\x7f\x94\xe0\xa6\x4e\x62\x3c\x4f\xb6\x19\xd9\x7d\x67\xaa\x10\x7a\x64\x52\xb2\x05\xbd\xb7\xc5\x10\x70\xa7\x56\xe9\xa4\x0d\x4d\xc0\x9e\xae\xc5\x27\x74\x94\xdb\x9d\x09\x5a\xf9\x9d\xb4\xd5\xdb\x46\x58\x7f\x04\xa9\x2b\xfc\x95\x0c\x42\x2e\xac\x8d\x96\x9e\x75\x4f\x20\xee\xc4\x11\xd4\x3e\xb7\x68\x8f\xfc\x63\xb4\x77\x0f\x90\x94\xdc\x02\x5a\x87\xb6\x9b\x27\x21\xa7\x20\xdd\xf7\x01\x50\x5d\x52\xe1\xb8\x81\x1f\xbd\x95\x7a\x3b\x03\x59\xdd\xc0\xc7\x85\xf6\x7f\xfa\xff\x19\xb4\x6d\xfe\x8d\xb7\xb8\x81\xf7\x55\x65\xd1\xb9\x77\x57\xb9\xd8\x04\xe8\x2b\xd8\xcb\xc0\x00\x60\x88\xbb\xcb\x5f\x40\x6f\xfc\x07\xdc\xdc\x80\x68\xfd\xee\x32\x3c\x86\xdf\x42\x90\x5c\xc1\xff\x3e\x8c\xd3\xd0\xfc\xfe\x6e\xf9\x18\x36\x79\xe0\xff\xd2\x87\xe3\x64\xa8\x78\x10\x3b\xdf\xa2\x5f\x1e\x1b\xbc\xbc\x9a\xcb\x8a\xfc\xb4\x91\x54\x21\x48\xff\xf8\x82\xac\xd2\x81\xe2\x03\xfa\xd2\x9d\x2a\x3e\xe3\x6f\xef\xe6\x22\x9c\x31\xec\xfe\x58\x4c\xc6\xb0\x74\x5d\xc8\x71\xe0\x8a\x90\xf0\xe8\x79\xca\x83\x7a\xd6\x2d\x94\xba\x92\xa5\xf0\x29\x2a\x49\x75\xd2\x2e\xa8\x34\xcb\xf8\xd1\x09\xfd\x89\xbb\x85\x80\xeb\x24\xb3\xe7\x67\x03\x98\xd0\xb2\x8f\x1f\x17\xb7\x49\x44\xcf\x8b\x26\xd7\x42\xeb\x5a\xa1\xd4\x71\x10\x41\x43\xcc\x70\x96\x39\xd1\x47\x3a\xd0\xc6\x07\xca\x46\xfe\x37\xad\xf6\x6f\x1c\xf3\x44\xb1\xc5\x19\xac\x48\xfc\xaa\x0b\xa2\x95\x96\x6a\xf5\x1c\x16\x53\x6a\xd5\x2f\x46\x23\x6d\xd2\x83\x71\x06\x4d\xa4\x87\x64\x81\xf4\xd6\xd5\xa4\xe3\xce\x79\x2d\x72\x00\xac\x98\x68\x4c\x19\x05\x16\xc1\x8b\xe8\xfe\x90\x13\xf3\x8d\x9e\x76\x61\x6e\xf5\xd3\xb5\xff\x36\x5f\xcd\x5e\xe7\xac\xdb\xa4\xc3\x8b\x9d\xe5\x4d\xee\xaa\x5e\xbf\x33\xce\x5a\x84\x7e\xa2\xe2\x3a\xbc\x16\xe5\xa7\x03\x51\xe8\xb7\xc4\xb9\x84\x97\x81\x14\x9f\xe8\x76\xda\x06\xc0\xe2\xfe\x6e\x79\xc3\x15\xeb\xe1\x31\x97\x3e\x68\x09\x63\x51\x73\x50\xb7\x81\xfd\xc7\xc6\xef\xac\x11\x26\x36\xe2\x7d\x72\xd6\x34\x1f\xd3\xa7\xb4\x79\xab\xe5\xe7\x16\x61\x71\xcb\x67\x4b\x1c\x35\xbd\x91\x6f\xa3\xd0\x67\x16\x1d\x4a\x99\x4e\x43\xa2\xf5\xa6\x16\x5e\x96\x1c\xd6\xb8\xe7\xaa\x21\x6b\x04\x91\xe9\x4c\x10\x72\xde\x9a\x63\x2c\xdb\x79\xdd\xe2\x16\x42\xb2\x01\x44\x82\x8f\x4c\xbe\x90\x23\x6e\x12\xb0\xe0\x0c\x21\x33\xc2\x4c\x23\xd2\x9b\x82\x3b\x51\x61\xb7\x2d\x77\xbc\x53\x87\x0b\x8b\x53\x03\x7a\x9b\x34\xba\xec\x0f\x0c\x5f\x81\x43\x95\xa7\xed\xe1\x73\x7a\x76\x35\xb4\x4a\x69\x51\x78\xfc\xae\x6e\xfc\x31\x23\xeb\xe1\x29\xab\x84\xf4\xd3\xa0\x89\x8b\x16\x4c\x85\x9e\x7b\xdd\x13\xaf\xa4\xe8\xb4\xe8\x5b\xab\xb9\xa4\x27\xf2\x20\x94\x42\x9b\x15\x78\x3c\x06\x4e\x76\x60\xd6\xe6\x06\x22\xbe\x0e\xeb\xe1\x7d\xaf\xca\x38\x41\x70\x73\x15\x75\x90\xee\x2c\x34\xa8\xbc\x4e\x1e\xf6\xf2\xea\x06\xbe\x7e\xe8\xbf\x3f\x66\xa5\x93\x3e\xdc\xe0\x0e\x1f\xd1\xc7\xa2\x6b\x95\xa7\x12\xfa\x57\xd4\x5b\xbf\xbb\xbc\x82\xaf\xbe\x82\xff\xbb\x81\x0b\x1e\x3c\xf0\x4e\x55\xae\x2c\x87\x0a\x73\xce\xc6\x1f\xff\xe7\x62\x20\xf0\xb1\xe8\xff\x35\x38\xff\x9f\xd1\x3b\x48\x0d\x17\x47\x5c\x62\x45\x61\xa8\x50\x49\x8b\xa5\x57\x47\xb2\xde\x39\xcb\x55\x92\x15\x10\xf6\xc8\xdc\x58\x29\x70\xed\xfa\xfe\x6e\xf9\x23\x7c\xc2\x63\x20\xbf\x04\xe2\x49\xab\x75\xcc\x64\x8b\xfe\xfd\x5e\x48\x45\x5e\xff\x31\x2c\x27\xc3\x3d\x2c\x39\x9b\x05\x98\x8d\x2d\x17\x35\x78\x78\xea\x74\x1c\x67\x19\x5d\x4e\x6d\xeb\xe0\x94\x27\x87\xfb\xc6\x10\xfd\x8e\xc1\xe2\x78\x40\x60\x1a\x3e\xa4\x1a\xce\x4f\x62\x0b\x5c\xee\x8c\x71\x38\x10\xb1\x33\x07\x02\x65\xc2\xa7\x6b\xd7\xc1\xbe\x15\x36\xa8\x2b\xe2\x1c\x46\xc3\x81\xe7\x5f\x83\x7d\x62\xcd\x1c\x26\x82\x3b\x63\x01\x7f\x15\xd4\x69\xce\x40\x6e\x60\x45\x06\x5d\x31\xa5\x16\xb0\x17\xaa\xc5\x19\xac\x5b\x0f\x2b\x59\xad\xa0\x32\xe8\xf4\x9b\x30\xf6\x62\x05\x87\x01\x29\x74\x54\x17\x0e\x3b\x59\xee\x82\x01\x36\xd1\x22\x3c\xaf\x30\xc9\xb2\x92\x6b\x97\xe5\x0c\x25\xe0\xa2\xc2\x0d\x35\x8c\x17\x03\x79\x8b\x0d\xac\x83\xb5\x62\xa5\x8a\x6d\x7c\x0f\x26\x6e\x0f\x42\x04\x09\x70\x52\x6f\x55\x50\x8b\x34\xf9\x07\x81\x36\xec\x36\x90\x4a\x0b\xe7\xb0\x24\x07\xed\x50\x35\x2e\x46\xb5\x83\xc3\xce\xd0\x56\xfa\x8d\x07\xd7\x5a\x0c\x16\xf4\x69\x8a\xa3\x8c\xf9\x44\xa6\xa5\x3c\x9e\xcb\x1b\x22\xb7\x11\x56\xd4\x10\xea\x24\x05\x13\x61\x2c\x55\xf7\x0a\x9d\xb4\x58\x9d\xe4\x9a\xb8\x88\x72\x1e\x8f\x30\xab\xb4\x20\x22\x60\x6d\xac\x35\x87\xf3\x7b\x76\xd1\xe2\xbc\x6d\x4b\xdf\xf2\xdc\x30\x0e\x09\x13\x01\xb5\xf8\xb9\x45\x47\x61\x4d\x61\x31\x3f\x9b\x66\xb6\xe8\x43\x88\xc4\x5a\xbf\x8c\x9c\xa7\xab\xda\x70\x73\x8e\xbb\xbf\x9b\x0e\x21\x2d\x55\x31\xcc\x15\xd3\xb5\xd9\x40\x8d\x95\xa4\x26\xa1\x1f\x2b\x74\xd3\x84\x54\xcf\x72\x16\xdb\xa7\xbd\xd7\x94\xee\x34\x56\x1c\x16\x6a\xf8\x19\x63\x4f\x9e\x7a\xfe\x34\x5c\x48\x0d\x57\xe2\x9b\x99\xa8\xd4\xa3\x12\x87\xa0\x3c\xa5\xb7\xdd\xf2\x5c\x74\x94\x14\x91\x25\x78\x58\xb3\x09\x33\x39\x6f\x62\x65\x54\xd2\x79\xa4\x8e\x2e\xfd\xae\xa2\xc0\x34\xa8\x8a\x6d\xe2\xc0\xf1\x9d\xae\x16\x6b\xb3\xc7\x6e\x1e\xdc\xe9\x9c\x65\x70\xaa\x67\xe1\xa5\x71\x35\x1b\x46\x9c\xe7\x10\xe7\xea\xce\x0d\xf5\xe6\x48\xbc\x99\xbb\x75\x5a\xb2\xb8\xa5\x78\x0d\x94\xd5\xd2\x5b\x53\x40\x4e\x7a\x11\xd7\x9b\x04\x74\xa7\xf8\x84\xa6\x63\x64\x76\x43\x98\xae\x75\x24\x98\x26\x09\x97\xf9\x5e\x11\xa1\x54\x12\x09\x8f\xaf\xaa\x85\xb2\xa2\x12\x98\x4b\xe3\x5a\xd8\x53\xf3\xbe\x9b\x0a\x0d\x44\x2a\x89\x3c\x79\x17\x44\xba\xdc\x28\xd0\x16\xb7\x17\x27\xbb\x31\xc6\xc6\xcd\x4f\x5f\x8e\xcf\x74\xb4\x9d\x8e\x89\x1a\xc5\x07\xa1\x0d\x09\x9d\x11\x93\xa4\x61\x3b\x3b\x6e\x92\x32\x1e\x95\xeb\xf4\xf8\xca\xf0\x8c\x90\x74\x09\x46\xbf\x2f\x0e\xd3\x3c\x7f\x4c\x98\x13\xe0\x3d\x4f\x53\x22\xa2\x87\x0c\x93\xc1\x2c\xaa\x2a\xc7\xf2\xb7\xa7\x00\xca\xf3\x71\x98\x73\x2e\x7b\x08\xc6\x6d\xce\xe6\xc1\xf8\xfb\x65\x5c\x19\x10\x35\xe2\x9f\x9c\x2b\x9b\xc6\x58\x8f\xd5\xfd\xdd\x72\xc9\xb7\x3c\xa9\x28\x0b\x8e\xe9\x34\x55\x0f\x37\x40\x3d\x33\xb0\xe9\xf4\xb4\x6f\xe3\x5f\x46\x7f\x82\x90\x5a\x34\x4d\xe8\x59\xd7\xc6\x28\x14\x7c\x9b\xd2\x0d\x1b\xb8\xac\xca\xa1\xbc\x1e\xea\xa5\xa4\x2e\x01\x5c\xd0\x9a\xec\xf7\x2c\x73\x3a\x39\x61\x46\x9d\xbe\x31\x46\x8d\x68\xd1\x87\x78\xfc\x94\x34\x42\x96\x60\x17\x6d\xe5\x1e\x75\xec\x39\x5c\x3c\x78\xa4\x70\xd3\x19\x80\x47\xc2\x93\x9c\x39\x2c\xee\xaf\x41\xe2\x54\x35\xab\xf8\xe0\x6d\x8b\x24\x3b\x12\x8b\xf3\x55\xfa\xbd\xee\x3c\x74\xc6\x0b\xd1\xce\x13\x66\xee\xfd\x48\x5a\x45\xfb\x8e\x6b\xfd\x0b\x18\xaa\x74\x63\x33\x67\xe5\xf7\x2a\x18\x7a\x1c\x9b\x7f\x21\x0b\x3c\xd1\x30\x83\x45\xe1\xd2\x48\xf5\x99\x60\xec\xa3\xe7\x87\x76\xad\x64\x99\xe5\xc9\x17\x06\xc6\x73\x30\x4a\x8d\xc6\x0d\xe5\x94\x67\xdf\x5e\xdc\x32\xcc\xfe\x16\x32\xfa\xdf\x9f\x7e\x3f\xd0\x23\xa2\x2c\xbf\xe4\x44\x85\x79\x0a\xd1\x92\xb1\xe1\x3e\x84\x0b\xbe\x6e\xf0\x1f\xd0\xa7\x4b\x8b\x7e\x74\xe1\x9a\xcf\x8e\xd7\x98\xae\x14\xbb\xd6\xb8\xbb\x9d\x21\x44\x74\x37\x30\xaf\xc8\x81\xbd\xd9\x6f\x3a\x5e\x32\xeb\x32\xe3\xec\xc4\x2d\xb3\xe9\x99\x43\xd6\xe0\x3e\x9d\x4c\xcf\xe5\xd2\x78\xe5\x2b\x7d\x3a\xd9\x99\x60\x7c\x2e\x9b\xd2\xd1\xc6\x53\xf6\x57\x00\x69\x72\x20\x3c\xae\xe2\x16\x27\x8a\x78\x46\xe0\xf2\xdb\xbd\xc0\xad\xe2\x99\x06\x57\xe1\xfd\x0d\xf8\x84\xa8\xc4\xeb\xce\xaf\xe2\x04\xa6\x6a\x62\x14\x42\x1d\xc4\x31\x94\xfe\x8d\xa4\x1e\xae\x42\xe7\xa5\x16\x83\xb3\x67\xc2\xfb\x8b\x32\xb2\x7c\xa7\x69\x2d\x9d\xe3\x3b\x89\x70\x61\xd2\x3a\x6f\xea\x2e\xbb\x10\x25\xa4\xfc\xb6\xc6\x9e\x3b\x4e\xc9\x26\x89\x3b\x61\xab\xd0\x66\x11\xa6\x65\x98\x73\x8c\x48\xe6\x34\x2d\x19\x8f\xf9\x58\xcd\x27\x58\x49\xf8\xbd\x27\x25\xe1\x7b\x1c\x8d\x9a\x33\x8c\x64\x3c\x0b\x7c\x01\x27\x39\x1d\x2a\xf0\x5d\x79\x6d\x5a\x9d\xea\x6b\x98\x70\xf6\x91\x79\x0e\xbf\x29\xa5\x6b\x76\xe5\x96\xd9\xfc\x60\x4e\xef\xe4\x3f\xf1\x74\x18\xfb\xca\xec\x36\x6a\xf7\x29\x3b\xb9\x33\xb3\x82\x17\xa9\xbd\xe8\xc9\x33\xdf\xdd\xb1\xa2\x4c\xce\x25\xd3\xcc\x6c\xea\x3b\x94\x32\x1b\xf5\xbd\xfd\xdf\x13\xa4\x8a\x19\x0d\xc2\xcd\x35\xc3\x87\xe4\x34\x42\xcb\x72\xfe\x5c\x8f\x9b\xda\xd5\x54\xe9\xf4\xc6\x13\xd3\x3f\x51\x22\xeb\xf9\x93\x0d\x4a\xa4\xc4\x3b\x3f\xe7\x9b\x6e\x1c\x32\x75\x19\xf9\xfb\x6b\xc1\x4b\x7a\xd6\x33\x4d\xc2\x65\x20\xdc\xd4\x22\x68\xa9\xae\xe0\xb7\xdf\xd2\xa3\x77\xb1\x73\x90\xd5\xd5\x0d\x9c\xac\xa3\xcf\xc5\xb7\x42\x93\x55\x83\x6a\xec\xc5\xee\x5c\xc1\x82\xf9\x15\x0e\xd9\x60\x70\x0d\xdb\xb5\x63\xb5\xf0\xe5\x2e\x35\x61\xdd\x8d\x6c\x87\x83\x17\x0e\xe5\x5e\x3f\x33\x8d\xaa\x71\x8f\x73\x42\x92\x9e\x1a\x93\xbe\x62\x18\x7a\x76\x8f\xff\xce\x14\x34\x24\x38\x72\x23\xa7\xa3\xee\xc9\xf9\x81\x68\xe7\x95\x9d\xd8\xe3\x50\xf7\xd0\x08\xf2\xdf\x64\xa4\xd7\x4f\xfb\xc0\xff\xd8\x04\x16\x86\x5c\xe7\xf5\xee\x4e\x8c\xa8\x4f\x30\x03\x0a\xfb\x07\x67\xe3\x59\xfe\xd0\x1b\xbf\xec\xc6\x64\x79\x12\x19\x0d\x0a\x07\x17\xfe\x5d\xda\x18\xa5\x0c\x61\xad\x38\xa6\x66\x6b\x99\x37\x5b\x67\x68\x5a\xfc\x0b\x9a\x78\x69\xfe\x32\x98\xf5\x1a\x07\x56\x3e\x41\x59\xa6\x41\x38\x01\xc0\x1e\x00\xcc\x75\xe7\x8a\x61\xf0\x3b\x41\x90\xdc\xfe\x58\xfc\x2b\x00\x00\xff\xff\xee\x5d\xf5\x18\x51\x29\x00\x00" func utilityNonfungibletokenCdcBytes() ([]byte, error) { return bindataRead( @@ -193,11 +215,11 @@ func utilityNonfungibletokenCdc() (*asset, error) { } info := bindataFileInfo{name: "utility/NonFungibleToken.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xea, 0x5d, 0x9e, 0xec, 0x8a, 0x6f, 0x3f, 0x81, 0xc, 0xe, 0x8, 0x81, 0x10, 0x25, 0x43, 0xea, 0x15, 0xd, 0x65, 0x3c, 0x48, 0xda, 0x58, 0x24, 0x6f, 0x18, 0x72, 0x7f, 0x6d, 0x9e, 0x26, 0xd8}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xde, 0x45, 0x41, 0xe6, 0x8c, 0xc7, 0xc4, 0xf2, 0x8, 0x8f, 0x10, 0x73, 0xca, 0xee, 0x3, 0x22, 0x4b, 0xca, 0x4e, 0x9e, 0x38, 0xda, 0xd, 0x25, 0x77, 0xa5, 0xb8, 0x53, 0x62, 0x6a, 0x17, 0xf}} return a, nil } -var _utilityPrivatereceiverforwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x56\xc1\x8e\xdb\x36\x10\xbd\xeb\x2b\x26\x2e\xd0\x4a\xc1\x46\xbe\x14\x3d\x18\xeb\x6c\x83\x6d\xf7\x58\x2c\x92\xb4\xd7\x62\x44\x8d\x2d\x36\x32\x29\x90\x23\xab\x8b\x85\xff\x3d\x20\x25\x51\xa2\x64\x07\xd8\xbd\xac\x28\x71\x66\xde\x7b\x7c\x33\xf4\xf6\x7d\x92\xfc\x04\x4f\xad\x3a\xca\xa2\x26\xf8\xaa\xbf\x91\x82\x67\x23\xcf\xc8\x04\x9f\x49\x90\x3c\x93\x81\x47\xad\xd8\xa0\xe0\x24\xf9\x5a\x49\x0b\x62\x58\x82\x3c\x35\x35\x9d\x48\xb1\x05\x04\xdb\x90\x90\x58\x83\x21\xab\x5b\x23\x08\x50\x95\x60\xc6\x14\x52\x31\x99\x03\x0a\x82\xa4\xab\xb4\x25\x28\xa9\xd1\x56\x32\x1c\x5a\x25\x58\x6a\x05\xd2\x82\x56\xf5\x0b\x08\xac\x6b\x74\x60\x8a\x17\x40\x05\x58\x9e\xa4\x02\xae\x8c\x6e\x8f\x15\x20\x34\x6d\x51\x4b\x01\x02\x1b\x2c\x64\x2d\xf9\x25\x4f\x92\xf7\xdb\x24\x91\xa7\x46\x1b\x0e\x54\x7a\x26\x07\xa3\x4f\xb0\x89\xde\x6d\x92\xa4\x69\x8b\x89\xc3\x40\x76\xe4\xfa\xa4\x4d\x87\xa6\x24\x03\xaf\x49\x02\x00\xb0\xdd\xc2\x9f\x67\x52\x0c\x5c\x21\x3b\x90\x74\x92\xcc\x54\x42\x57\x91\x02\x76\x29\x2d\xa0\x09\x84\xa8\x04\xd6\xc0\x15\x01\xa3\x39\x12\x07\x09\x7c\x36\x57\x9a\x7c\xba\xa1\xee\x1f\x7d\x54\x8a\x27\xdd\x2a\xde\xc1\xdf\x4f\xf2\xff\xdf\x7e\xbd\x03\xd6\x3b\xf8\x54\x96\x86\xac\x7d\xc8\x92\x10\x5b\x13\xc3\x17\x52\x25\x99\x2f\xac\x0d\x1e\xe9\x19\xb9\xda\xc1\x6c\x11\xef\x5d\xb0\xbb\x19\xf4\x83\x98\x67\x2f\x78\x1f\x32\x3d\x4f\x65\xc2\x79\xaf\xa4\x1b\xe4\xf3\x9e\x91\xd6\x09\x66\xc8\x2b\x33\x97\xca\xeb\xd7\xc9\xba\x86\x82\xc0\x92\xe2\x3c\x8e\x25\xe0\x97\x86\x40\xaa\x52\x0a\x64\xb2\xc3\x39\xf8\xa3\x40\x30\x74\x20\x43\x4a\x90\x13\x1d\x63\xad\xfb\x14\xe1\x11\x85\x20\x6b\x53\x4b\xf5\x21\x83\x33\x1a\xb7\x59\x36\x92\x9c\xea\x8f\xc1\x4d\xf7\x3f\xbf\x46\x76\xc9\x47\x19\x2e\x1f\x23\x52\x03\x85\x6b\x85\xb6\x5b\xe7\xc2\xde\xd4\x1e\x2c\xe3\x37\x72\x60\xff\xc1\xb6\x66\xd0\xc5\x7f\x24\x18\xd0\x7a\x77\x9b\x63\xeb\x1a\xc8\x37\xcb\xa1\x17\xd0\xce\x33\x49\x1e\xed\x14\xe0\xfe\x62\x87\x4c\xad\x95\xea\xe8\xbf\x59\xd6\x86\xca\x49\x8d\x1f\xf0\x1f\x8d\x9f\xb9\xce\x1b\x69\xa4\xae\x51\x76\xf0\x7b\x4c\xdd\x57\xc9\xe0\x35\xa4\x70\x7f\xf5\xcc\xd2\x9f\xe9\x00\x7b\x70\x8a\xe6\x01\x5d\x5e\x68\x63\x74\x97\x66\xef\x92\x55\x5c\x81\x35\xba\xb3\xda\xfb\xc6\xcc\x87\x65\xbc\x6f\x96\x3b\x8f\xd1\xdd\x7f\x70\xff\xb3\x78\xbb\xeb\xc6\x5b\xbd\x34\xe4\xef\x9b\xc9\xa3\xd4\x9d\x22\xf3\x90\x63\xdf\x58\x59\xc8\x74\x99\x92\x4a\x25\x39\x7d\xab\x35\x96\x22\x35\x86\x16\x6f\x06\x6a\x0b\x8d\xe0\xdd\x1e\x94\xac\x77\xb0\x79\xd4\x6d\x5d\x82\xd2\x0c\xfd\xb7\x69\xf8\x4e\x16\xf7\xd3\xcc\x1d\xf7\x84\x69\x13\x15\xb9\x44\xab\xf8\x5c\x60\x3f\xd5\x4f\xe2\x80\x4b\x98\x74\xc2\x10\x32\xfd\x45\xdd\xd4\xcb\xfd\x2b\x67\x5f\x45\xdd\xac\xc7\x27\x58\x9d\xe4\xca\xc3\x6a\x8c\x3e\xcb\xd2\xfb\x70\x5e\x68\xf0\xa0\x9b\x15\xce\x72\xeb\x1a\x6f\x97\xdb\x59\x75\x36\x6d\x26\x81\xb9\x35\x0a\xee\x3f\xf4\x35\xe0\x6a\x85\xf0\x98\x8d\xe4\xd7\xa3\xac\x1f\xb1\xb3\xcc\x23\x78\x4b\xaa\x1c\xdc\xe6\x41\xd9\xf4\x5f\x18\xdc\x14\xe6\xf5\xdd\x30\xd5\x6e\xf7\xd3\xaa\x31\x50\x08\x67\x59\xd8\xc3\x91\xf8\x53\xbf\x48\x83\x4b\x57\xdb\x9b\x78\x42\xc3\x7e\x4c\x90\x1f\x89\xe7\x0a\xde\xba\xdc\xf2\xf0\xf4\x31\xbd\xb9\xe7\xe6\x3d\x90\xad\x9c\x3d\x19\xfa\xe1\x01\x1a\x54\x52\xa4\x6b\x47\x47\xb3\x7a\xa0\x30\xce\x3c\x32\x9b\x05\xcf\x05\xc7\xd5\x2c\xe8\x35\x8e\xa1\x5c\xf7\xb5\xef\x68\xeb\x4f\x74\x75\xf1\xdd\xf9\xd1\x79\xed\x4a\xbc\x1b\x7e\x69\x2c\x2f\xbe\xe8\xfc\x7c\x8b\xad\xee\x63\x3f\x13\xc7\x72\x8b\xcd\xb7\x2f\x64\x17\xb5\xb8\x91\x6f\x45\x4d\x68\x60\x3f\x83\xb9\x28\x35\x7a\xc2\xe2\x99\xd2\xd0\x13\x3d\xda\x34\x9b\x4d\xc5\x15\x81\xe1\x28\x2e\xc9\xe5\x7b\x00\x00\x00\xff\xff\x21\x17\xfa\x34\x20\x0a\x00\x00" +var _utilityPrivatereceiverforwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x56\x4b\x8f\xdb\x36\x10\xbe\xeb\x57\x4c\x5c\x20\x95\x02\x47\xbe\x14\x3d\x18\xeb\x6c\x82\xa4\x0b\xe4\x52\x2c\x92\x6c\xaf\xc5\x98\x1a\x5b\x6c\x68\x52\x20\x47\x56\x17\x0b\xff\xf7\x82\x14\xf5\xb6\x83\xc6\x17\x93\xd2\x3c\xbe\x79\x7c\x33\xda\xbc\x49\x92\x5f\xe0\xa1\xd6\x47\xb9\x57\x04\xdf\xcc\x77\xd2\xf0\x68\xe5\x19\x99\xe0\x0b\x09\x92\x67\xb2\xf0\xd1\x68\xb6\x28\x38\x49\xbe\x95\xd2\x81\x88\x57\x90\xa7\x4a\xd1\x89\x34\x3b\x40\x70\x15\x09\x89\x0a\x2c\x39\x53\x5b\x41\x80\xba\x00\xdb\x99\x90\x9a\xc9\x1e\x50\x10\x24\x4d\x69\x1c\x41\x41\x95\x71\x92\xe1\x50\x6b\xc1\xd2\x68\x90\x0e\x8c\x56\xcf\x20\x50\x29\xf4\x60\xf6\xcf\x80\x1a\xb0\x38\x49\x0d\x5c\x5a\x53\x1f\x4b\x40\xa8\xea\xbd\x92\x02\x04\x56\xb8\x97\x4a\xf2\x73\x9e\x24\x6f\x36\x49\x22\x4f\x95\xb1\x0c\xab\x2e\x96\x10\xca\x2a\x49\x50\x08\x72\x2e\x45\xa5\xb2\x01\x78\x8c\xb0\x0b\xf0\xc1\xd8\x06\x6d\x41\x16\x5e\x92\x04\x00\x60\xb3\x81\x3f\xce\xa4\x19\xb8\x44\xf6\xc8\xe8\x24\x99\xa9\x80\xa6\x24\x0d\xec\x4d\x3b\x40\xdb\x47\x41\x05\xb0\x01\x2e\x09\x18\xed\x91\xb8\x8f\x3b\x58\x1b\x43\xa0\x60\x36\xfa\xff\xd4\x6a\xa7\x78\x32\xb5\xe6\x2d\x3c\x3d\xc8\x7f\x7f\xff\x6d\x3d\x58\x7d\x7a\xfa\xfc\x69\x0b\x4f\x9f\x35\xfb\xc7\x07\x6b\x4e\x5b\xf8\x50\x14\x96\x9c\xbb\x5f\x03\x9b\xe9\x6d\x2c\x9d\x25\x0b\xd7\x8a\x18\xbe\x92\x2e\xc8\x7e\x65\x63\xf1\x48\x8f\xc8\xe5\x16\x46\x97\xeb\x3a\xb3\x64\xdd\x54\xfe\x1f\xba\x8f\xa1\x78\xad\xea\x70\x5e\xba\xed\x7b\x68\x51\x99\x58\x9d\xd0\x87\xd2\xf9\x7a\x58\x0a\x89\x1f\x57\x22\x94\xa7\x91\x4a\xc1\x9e\xc0\x91\xe6\x7c\xaa\x4b\xc0\xcf\x15\x81\xd4\x85\x14\xc8\xe4\x62\x99\x43\xa5\x11\x2c\x1d\xc8\x92\x16\xe4\x6b\x8a\xd3\x52\xb6\x26\xfa\x63\xc4\xec\x48\x1d\x32\x38\xa3\xf5\xc2\xb2\x92\xe4\x8b\xf9\xb1\xef\xd0\xbb\xd7\x2f\x93\xae\xcc\xbb\x74\x5c\xde\x4d\x82\x8a\x21\x5c\x73\xb4\xd9\x78\x92\xb6\x44\x09\x60\x19\xbf\x93\x07\xfb\x17\xd6\x8a\xc1\xec\xff\x21\xc1\x80\x2e\x30\xc6\x1e\x6b\x4f\xca\x40\xc0\x43\x9b\x40\x37\xb6\x24\xb9\xeb\xd6\x1e\xee\xaf\x2e\x5a\xaa\x9d\xd4\xc7\xf0\xce\xb1\xb1\x54\x0c\xd9\xf8\x41\xfc\x1d\xaf\x32\xcf\xe6\x2e\x8c\xb4\x6d\xd7\xf7\xb3\xd8\x83\x9b\x4b\x06\x2f\xbd\x11\xff\x53\x23\xce\x7c\xa1\x03\xec\xc0\xe7\x34\xef\xf1\xe5\x7b\x63\xad\x69\xd2\xec\x55\xb2\xd0\xdb\xa3\x42\x5f\xad\x5d\x20\x48\x1e\xaf\x4b\xb9\xba\x96\x45\x27\xe4\xcf\x53\x89\x91\xf7\x7c\x1a\xc1\xdd\x5b\xff\x9f\x4d\xc5\xfd\x40\xb8\x45\xe3\x88\x60\xc1\x63\xef\xb4\x63\x71\x08\xcf\x34\x9a\xec\x7d\x8e\x2d\x87\x5b\x42\x8f\x71\x2c\xdf\xb7\x86\xc6\x32\xde\x68\xd6\x43\xbb\x0c\x28\xa5\x96\x9c\xfe\x6c\x3f\xce\xeb\x52\x59\x9a\x3d\x89\xb9\x9a\x95\x05\x5e\xed\x40\x4b\xb5\x85\xd5\x47\x53\xab\x02\xb4\x61\x68\xdf\x0d\x5b\x64\xe0\x95\x4f\x41\xe8\xb1\x01\xd3\x6a\xe2\xe4\x32\xb9\x4d\x5b\x01\x76\x83\xff\x64\xaa\x70\xe9\xa7\xb7\xb0\x84\x4c\x7f\x52\x33\x0c\x90\xf6\x91\xe7\x8c\xa6\x66\x34\x58\x06\x58\x8d\xe4\x32\xc0\xaa\xac\x39\xcb\x22\x34\xff\xd8\x51\x6c\xfc\xf1\xa0\xf2\xfd\xbe\xf4\xf5\xf3\x69\xdf\xc2\xfb\xf1\xa8\x1b\x12\xcd\xb5\xd5\x70\xf7\xb6\xf5\x01\x57\x3d\xf4\xc7\xac\x4b\xc2\xed\x79\xda\xce\xff\x91\x87\x79\x30\x8e\x74\x11\xdb\x3a\x80\x74\xe9\xdf\x10\xfb\xaf\x5f\x36\xeb\x38\x62\x7f\x44\xee\x05\xfb\x50\x08\xcf\x0e\xd8\xc1\x91\xf8\x43\x7b\x49\xa3\xe5\x6c\x29\x5e\x4d\x17\x07\xec\x3a\x03\x79\xbf\xf9\x25\xb9\xd8\x7f\x77\xaf\x6f\x2d\xf4\xbc\x3f\xbd\x4b\x17\x6d\xec\x7f\x37\x15\x6f\x6e\xae\x85\x99\x0c\xee\xef\xa1\x42\x2d\x45\xba\xec\xfe\xc9\x32\x89\x41\x75\x43\x99\xec\x6a\x16\xf9\x2c\xea\xc5\x20\x6a\xf3\x9e\x4d\x74\xae\x73\x20\xb0\xdf\x85\x6a\x2f\x36\xf5\x3a\xcc\xf6\x6b\x3b\x7c\x1d\x3f\xaf\xe6\x1b\x7a\x52\xd1\x40\xc7\xc5\x87\x44\x18\xd9\x9d\xbb\x99\xf0\xed\x2f\x08\xaf\x35\xfb\x84\xb8\xa5\x35\xa0\x81\xdd\x08\xe6\xcc\x55\xd7\x25\xd1\x6a\xee\xf0\x4c\x69\xcf\x9f\x16\x75\x9a\xb5\xa3\xf6\x7a\x20\xb1\x24\x97\xe4\xf2\x5f\x00\x00\x00\xff\xff\x07\xfa\xd7\x82\x1d\x0b\x00\x00" func utilityPrivatereceiverforwarderCdcBytes() ([]byte, error) { return bindataRead( @@ -213,11 +235,11 @@ func utilityPrivatereceiverforwarderCdc() (*asset, error) { } info := bindataFileInfo{name: "utility/PrivateReceiverForwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbb, 0xc2, 0xcb, 0x85, 0x75, 0x47, 0x18, 0xf0, 0xba, 0x31, 0xca, 0xab, 0xd5, 0xa7, 0x9d, 0x8e, 0x58, 0x30, 0x99, 0x10, 0xee, 0x24, 0x4f, 0xcb, 0x58, 0x6f, 0x9, 0xa4, 0x5f, 0xa2, 0xd5, 0x12}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x23, 0x2f, 0x24, 0x60, 0x5f, 0xf6, 0x4d, 0xaa, 0xa8, 0x62, 0x34, 0x83, 0x34, 0x3f, 0x32, 0xf5, 0x6d, 0x4a, 0x70, 0x8, 0x1, 0xf, 0x11, 0x51, 0x7e, 0x34, 0xeb, 0xab, 0xff, 0x6e, 0x9, 0xf}} return a, nil } -var _utilityTokenforwardingCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x58\x4d\x6f\xe4\x44\x10\xbd\xfb\x57\xd4\x06\x89\xcc\xac\xb2\x9e\x0b\xe2\x10\x6d\xd8\x2f\x08\x9c\x10\x0a\x01\x0e\x08\xb1\x3d\xed\xf2\xb8\x37\x3d\xdd\x56\x77\x79\xbc\xa3\x68\xfe\x3b\xaa\x6e\xbb\xfd\x91\x99\x90\x45\x08\x09\x69\x73\xc9\xd8\xea\xaa\x7a\x55\xf5\xea\x95\xed\xd5\xf3\xe7\x59\xf6\x05\x5c\x37\x66\xa3\xd6\x1a\xe1\xd6\xde\xa1\x81\x6b\xeb\x5a\xe1\x0a\x65\x36\xf0\xce\x1a\x72\x42\x52\x96\xdd\x56\xca\x83\xec\x2e\xc1\x57\xb6\xf5\x50\xd9\x16\x84\x01\x21\xa5\x6d\x0c\x81\xb4\x8d\x2e\xc0\x23\x41\x53\x83\x00\xd9\x78\xb2\xdb\xe4\x3c\xfa\xbe\x41\x89\x6a\x87\x2e\x23\x0b\x42\x6b\xdb\x02\x55\xb8\x05\xb2\x50\xc6\xa8\x40\x7c\xce\xf3\x1d\x01\x85\x2a\x4b\x74\x68\x28\xc5\x68\x2b\x34\xb8\x43\xc7\x66\x7b\x70\xd1\x5b\x67\x93\x33\x4a\xdc\x83\x14\x06\xea\x66\xad\x95\xaf\x80\x18\x76\x97\x10\x3a\x70\xe8\x6d\xe3\x24\x82\xf0\x20\x12\x18\x90\xa2\x16\x6b\xa5\x15\xed\xe1\x43\xe3\x09\xb4\xba\x43\x10\xf0\xab\x68\x34\x5d\x64\xc2\x14\x1c\x0e\x3c\x1a\xf6\x51\x58\xf4\xe6\x9c\x00\x77\x68\xc0\x20\x32\x64\xb8\x33\xb6\x05\x45\xa0\xfc\x00\x3a\xcf\xb2\xdf\x2a\x34\xe3\x12\xb5\xc2\x50\xc8\x4d\x3a\x14\xc4\x31\x12\xb6\x8b\x98\x92\x14\x5a\x87\x68\xf1\xc4\x8f\xd8\xa6\x13\x59\xd9\x18\x49\xca\xb2\xc7\x02\x6a\x67\x77\xaa\x40\x0e\xda\x2a\xaa\x82\x4d\x4a\xc8\x61\x80\x20\x11\xa8\x12\x14\x3d\x73\xec\x51\xa1\x33\xaa\x50\xb9\xa1\xdc\x79\x96\x3d\x5f\x65\x99\xda\xd6\xd6\xd1\xac\x6b\xa5\xb3\x5b\x38\x9b\xdc\x3b\xcb\xb2\xba\x59\x0f\x8c\x08\x37\x47\xcc\xb9\xcf\x32\x00\x80\xd5\x0a\xbe\xdb\x71\x03\x03\x0e\xe5\x01\xb7\x8a\x08\x8b\xd0\xc8\x3e\xb8\x70\x08\x05\xd6\xd6\x2b\x8a\xd5\xe4\x5c\x48\xb8\x0d\x52\xdf\x62\x17\xbc\x71\x44\x0c\xee\xfa\xa2\x14\xdf\x46\xbb\x85\xd8\x72\x81\x2f\xe1\x97\x6b\xf5\xf1\xeb\xaf\x2e\x02\xe4\x4b\x78\x53\x14\x0e\xbd\x7f\xb5\xcc\x92\x7d\xa2\x80\x32\x84\xae\x14\x12\x87\x1e\xfc\xc4\xac\x91\x3d\xf6\x88\x7f\x05\x3f\xa0\xae\xd1\x41\xaa\x3e\xb7\xaf\x42\x79\xc7\x39\x50\x85\x2e\x50\xfe\xbd\x43\xa9\x6a\x85\x86\xde\x8f\xe8\x34\xf1\xa3\x3c\x18\x4b\xa0\x05\x71\x06\xd6\xc5\x36\x0f\xd4\x23\x15\xb3\x17\x40\xfb\x1a\xf9\xf8\x4e\x68\x55\xe4\xc9\x09\xc3\x2f\x1b\x13\xa3\x2f\x96\x97\xf0\xd6\x5a\x3d\xc5\xfa\x3d\x32\xbf\x2a\x4c\x75\x03\xe1\xbd\xda\x98\xde\x73\x42\x39\x0a\x9c\x4f\x3c\x84\x41\x67\xa8\x28\xd1\x7b\xe1\xf6\xb0\x46\x29\x1a\x8f\x81\x66\xb6\x21\x50\x74\xd1\x51\x9d\xd3\xa9\xad\xf7\x41\x3c\xc8\x82\xb6\xf6\x0e\x9a\x30\x25\x8c\xa1\xb2\xb6\x08\x5c\xf5\x88\xa0\x4a\xd6\x84\x93\x95\xb1\x25\xcf\x09\x7e\xac\x51\x06\x12\x70\x05\xac\xe3\x08\x79\x84\x54\xa1\xae\x3d\x6c\x1a\xd6\x08\xb1\x11\xca\x78\x02\x65\x4a\x65\x14\xa1\xde\x83\xac\x84\xe2\x2c\xe7\x3c\xb4\x0e\x6c\x68\x92\x32\xa1\x9a\x30\x09\xbc\x15\x5a\x49\x65\x1b\x0f\x77\xca\x14\x01\x45\x53\x17\x82\xd0\x47\xc2\x46\x49\xab\x5d\x24\x9d\x56\x9e\x94\xd9\xf8\x38\x0f\x6b\x64\xff\x5b\x51\x74\x43\xc6\x2c\x8e\x21\xac\x01\x4f\xd6\x61\xe9\xac\x21\x3f\x29\xef\x24\xfa\x6b\x87\xd4\xb8\x20\x10\xb6\x66\x6a\x09\x3d\xf4\x6d\x44\x8c\xd2\x3a\x1e\x34\xdf\x6c\xd1\x05\x8c\x5c\xdc\x79\xa2\x3d\x2b\x57\x01\x03\x8b\x0b\x53\x35\xcc\xb8\x6d\xcd\x03\x0e\x79\x51\xe2\x5b\xeb\x9c\x6d\x99\x48\x5f\xde\x4f\x86\x3b\xef\x85\xe4\xf0\x2a\x18\x1e\x8e\x8c\x4f\x1a\x9a\x4b\x38\x6e\x7b\xf1\xf8\x5c\x25\xa2\xb5\x15\x3a\x0c\x29\x8d\x35\x20\x08\x43\xab\xb4\x86\x75\x50\x5e\xca\xa7\xb6\xd8\x0d\x89\x29\x94\x1c\xfa\x15\x69\x29\xc6\xfa\xd7\xb1\x7e\x10\x91\xe8\x22\xfd\x14\x92\x79\xbe\xf0\xa8\xcb\x25\xec\x84\x1b\x46\xe4\x12\xde\x0d\x74\x1d\x47\xef\x70\x1e\xf3\xb6\x5a\x71\x35\x3a\x9d\x08\xd2\x2b\xee\xd0\xf7\xbb\x04\xec\xfa\x03\x4a\x0a\xdb\xc7\x80\x70\x9b\x66\x1b\x96\x9b\x29\x7a\x55\xf6\x63\x4f\x8a\x7a\x31\x4c\x98\xce\x7d\xe7\xa9\xf1\xa1\xe9\xbc\x96\x98\x6a\xc5\x90\xf2\x31\x58\x7d\xd7\x3b\xe4\x8b\xa8\x8e\xaf\xa7\x8d\x0b\x8e\x97\x70\x9f\xac\xf8\x4f\x8f\x34\xf8\x06\x4b\xb8\x02\xae\x54\x9e\x00\xe5\xeb\x40\xa2\x97\x27\x19\xf4\xcd\x62\xf9\x2c\x7b\xe0\x72\x2d\xb4\xe0\xf6\x5c\x85\x59\xca\xbb\xcb\xe9\xb9\x51\xd8\x7c\x0a\xfc\xe5\x0b\xfe\xbf\x9c\x1e\xe7\xcd\x72\x7a\x2f\x74\x11\xfa\xc5\x10\x92\xb0\xad\x41\xf7\x2a\x17\x71\x49\x2c\x93\xb7\xc3\xff\x49\xff\x67\xfd\xea\x24\x65\xd6\xa4\x60\xf1\x68\x8f\x4e\x25\xff\x79\xa1\x7c\x5e\x28\xff\xea\x42\x79\x12\x5f\x9f\x20\x2a\xc7\x09\xcb\x6d\x33\x1b\xbc\x19\x58\x19\xae\xfd\x54\x45\xfb\x94\xcb\xf4\x62\xd0\xe9\x6c\xf7\x50\x5d\x0c\x47\x1f\x53\xd3\x59\xac\xc5\x9f\x60\xb0\xbd\x39\xb6\x3e\xe6\xaa\x5a\x3b\x9c\xdd\xe1\xbf\xb1\xf5\x53\x4a\x00\xcf\xae\xc0\x28\x7d\x09\x67\xef\x02\xad\x78\x7a\xa2\xd9\xb1\x37\x81\xc0\x31\x4e\x72\x80\x75\x36\x81\x70\x98\x5c\x4d\x3b\x02\x57\x13\x74\xa7\xd4\xe2\x0d\x6c\x90\x68\x22\x96\xcc\xe4\xd8\xe4\xd8\x84\xb0\xda\xc3\x38\x7a\xf0\x4d\xcd\x6f\x1b\x58\xc0\x7a\x1f\x5f\xd5\xfa\xc7\x8b\x8b\x89\xdb\xb6\x52\xb2\x0a\xef\x75\xeb\xf1\x53\xc2\xb0\x03\xcf\xbb\x9b\xe7\x29\xf0\xdf\x0f\xc9\x1b\xe7\xc4\x9e\x99\x70\x7d\xdb\xc1\x89\x13\x3a\x8b\xf2\x50\x7e\x37\x48\x3f\xf7\xc0\xc3\xce\xbc\x65\x6b\x66\xfd\x3d\xff\x8a\xb2\x7c\x98\xf5\x57\x95\xf0\xec\x93\x45\xf9\x08\x47\x3a\xf0\xf7\x87\x47\x5a\xc7\x0b\x76\xc7\xc0\xfe\xf9\xc2\x9e\xbb\xf3\x93\x84\xfd\x2c\xd5\xab\x39\x9e\xd9\xf1\xdf\x7b\x34\xf9\x06\x43\xb5\x16\xcb\x3f\xe0\x0a\xc8\x35\x78\x54\x0c\xa6\xd6\xc7\xc8\xc6\x2a\xbd\x38\xfa\xa4\xf6\xb4\x51\xfb\xa4\x72\xfc\xb7\x73\xf6\x50\x7a\x0e\xe3\x87\x70\xd6\xb8\x07\x9f\x06\xba\x5b\xfc\xa0\x69\xb0\x9d\x7c\xf0\xe8\x61\xa5\x8f\x04\x27\x34\xae\x9b\x92\xa4\x6d\x0f\x62\x9c\x28\x37\x3f\x46\xa6\x70\x43\xa1\xbb\x56\xbe\x7c\xd1\x7d\xe9\x38\xea\x26\xfd\x5c\x76\x19\x1e\xb2\xbf\x02\x00\x00\xff\xff\xa0\x39\x74\x80\x93\x12\x00\x00" +var _utilityTokenforwardingCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x58\x5d\x6f\xe3\xb6\x12\x7d\xd7\xaf\x98\xcd\x05\x6e\xec\x45\xd6\x7e\xb9\xb8\x0f\xc6\xe6\xee\xe7\x4d\xbb\x2f\x45\x91\x26\xed\x43\xb1\xe8\xd2\xd4\xc8\xe2\x9a\x26\x05\x72\x64\xad\x11\xf8\xbf\x17\x43\xea\xdb\x72\x9a\x2d\xd0\x02\x05\xd6\x0f\x89\x25\x93\x33\x67\x66\xce\x9c\x11\xb5\x7c\xfe\x3c\x49\xfe\x05\x37\xa5\xd9\xa8\xb5\x46\xb8\xb3\x5b\x34\x70\x63\x5d\x25\x5c\xaa\xcc\x06\xde\x59\x43\x4e\x48\x4a\x92\xbb\x5c\x79\x90\xf5\x25\xf8\xdc\x56\x1e\x72\x5b\x81\x30\x20\xa4\xb4\xa5\x21\x90\xb6\xd4\x29\x78\x24\x28\x0b\x10\x20\x4b\x4f\x76\xd7\x1a\x8f\xb6\x6f\x51\xa2\xda\xa3\x4b\xc8\x82\xd0\xda\x56\x40\x39\xee\x80\x2c\x64\xd1\x2b\x10\xaf\xf3\x7c\x47\x40\xaa\xb2\x0c\x1d\x1a\x6a\x7d\x54\x39\x1a\xdc\xa3\xe3\x6d\x07\x70\xd1\x5a\xbd\x67\xc1\x28\xf1\x00\x52\x18\x28\xca\xb5\x56\x3e\x07\x62\xd8\x75\x40\xe8\xc0\xa1\xb7\xa5\x93\x08\xc2\x83\x68\xc1\x80\x14\x85\x58\x2b\xad\xe8\x00\x9f\x4b\x4f\xa0\xd5\x16\x41\xc0\xcf\xa2\xd4\x74\x95\x08\x93\xb2\x3b\xf0\x68\xd8\x46\x6a\xd1\x9b\x4b\x02\xdc\xa3\x01\x83\xc8\x90\x61\x6b\x6c\x05\x8a\x40\xf9\x0e\xf4\x22\x49\x7e\xc9\xd1\xf4\x53\x54\x09\x43\x21\x36\xe9\x50\x10\xfb\x68\xb1\x5d\xc5\x90\xa4\xd0\x3a\x78\x8b\x2b\x7e\xc0\xaa\x5d\x91\x64\xa5\x91\xa4\x2c\x5b\x4c\xa1\x70\x76\xaf\x52\x64\xa7\x95\xa2\x3c\xec\x69\x03\x72\x18\x20\x48\x04\xca\x05\x45\xcb\xec\xbb\x97\xe8\x84\x72\x54\xae\x4b\xf7\x22\x49\x9e\x2f\x93\x44\xed\x0a\xeb\x08\x2e\x06\x65\xbb\x48\x12\x21\x25\x7a\x3f\x13\x5a\xcf\x3b\x1a\x84\x1f\x7b\x74\x79\x48\x12\x00\x80\xe5\x12\xfe\xbf\xe7\xaa\x05\xe7\xca\x03\xee\x14\x11\xa6\xa1\x7a\x8d\x47\xe1\x10\x52\x2c\xac\x57\x14\x53\xc8\x01\x90\x70\x1b\xa4\xa6\xae\x2e\x58\xeb\x7b\xc6\x60\xb6\xc9\x48\xfa\x3e\xee\x9f\x89\x1d\x67\x77\x05\xf7\x37\xea\xcb\x7f\xff\x73\xd5\xd9\xbd\xbf\xff\xf0\x7e\x05\xf7\x1f\x0c\xf1\xed\xcc\xd9\xdd\x0a\xde\xa4\xa9\x43\xef\x5f\x5d\x01\xd9\xe1\xd5\x70\x75\x6b\xe4\xee\x50\xe0\x0a\xf8\xef\x3c\x39\x41\xd4\x32\x4a\x19\x42\x97\x09\x89\x5d\x49\x7f\x64\x12\xca\x26\x2b\x31\x33\x4b\xf8\x1e\x75\x81\x0e\xda\x62\x32\x1b\x72\x94\x5b\xce\x0e\xe5\xe8\x42\x07\x7d\x72\x28\x55\xa1\xd0\xd0\xa7\x1e\x3b\x07\x76\x94\x07\x63\x09\xb4\x20\xce\x89\x75\x91\x35\x1d\x93\x49\xc5\xbc\x0a\xa0\x43\x81\xbc\x7c\x2f\xb4\x4a\x17\xad\x91\x7e\x18\x59\x69\x22\x8a\xd9\x7c\x05\x6f\xad\xd5\x43\xcc\xdf\x21\xd3\x36\xc7\xb6\x32\x20\xbc\x57\x1b\xd3\x78\x68\xd1\xf6\x00\x2c\x06\x16\x82\x7e\x30\x64\x64\xa7\xc2\x1d\x60\x8d\x52\x94\x1e\x03\x7b\x6d\x49\xa0\xe8\xaa\xee\x20\x0e\xab\xb0\xde\x07\x4d\x22\x0b\xda\xda\x2d\x94\xa1\xf9\x18\x43\x6e\x6d\x1a\x5a\xc0\x23\x82\xca\x58\x6a\xce\x66\xc8\x66\xdc\x7e\xf8\xa5\x40\x19\x68\xc6\x99\xb0\x8e\x3d\x2c\x22\xa4\x1c\x75\xe1\x61\x53\xb2\xf4\x88\x8d\x50\xc6\x13\x28\x93\x29\xa3\x08\xf5\x01\x64\x2e\x14\x47\x39\x66\xba\x75\x60\x43\xb1\x94\x09\x59\x85\x81\xe3\x9d\xd0\x4a\x2a\x5b\x7a\xd8\x2a\x93\x06\x14\x65\x91\x0a\x42\x1f\x5b\x22\x2a\x65\xe1\x22\x9d\xb5\xf2\xa4\xcc\xc6\x07\x7e\xc2\x1a\xd9\xfe\x4e\xa4\x75\xef\x72\x9f\x44\x17\xd6\x80\x27\xeb\x30\x73\xd6\x90\x1f\xa4\x77\xe0\xfd\xb5\x43\x2a\x5d\xd0\x1d\x5b\x30\xc5\x84\xee\xea\xd6\x23\x48\x66\x1d\xb7\xb2\x2f\x77\xe8\x02\x46\x4e\xee\x38\xd0\x86\x9d\xcb\x80\x81\x35\x8b\x29\x1b\xa4\xc3\x56\xe6\x2c\x97\xbc\xc8\xf0\xad\x75\xce\x56\x4c\xa8\x7f\x3f\x0c\xe4\x64\xd1\xe8\xd4\xf1\x55\x30\x70\x7c\xa4\xad\xda\x66\x5a\xc1\xb4\x8d\xab\xc7\xfb\xad\x25\x5e\x95\xa3\xc3\x10\x62\x5f\x75\x82\x14\x55\x4a\x6b\x58\x07\x81\xa7\xc5\x70\x2f\xd6\xcd\x63\x52\x25\xbb\xfa\x45\x9a\x8a\xbe\xcc\xd6\x5d\xd0\xc9\x56\x34\x31\x4e\x90\x47\x9d\xcd\x61\x2f\x5c\xd7\x32\x2b\x78\xd7\xd1\xb7\xef\xbd\xc6\x39\x65\x6d\xb9\xe4\x6c\xd4\xfa\x11\x14\x5e\x6c\xd1\x37\x23\x0b\xec\xfa\x33\x4a\x0a\x43\xce\x80\x70\x9b\x72\x17\x66\xa8\x49\x1b\xf1\xf7\x7d\x4b\x8a\x1a\xf9\x6d\x31\x5d\xfa\xda\x52\xe9\x03\x09\x78\xfa\x31\xf5\xd2\x2e\xe4\x47\x82\x6c\x59\x50\x47\x30\x8b\xc2\xfb\x7a\xc4\x82\xe0\xe1\x38\x87\x87\x76\x3f\x7f\x74\x4f\xff\x6f\x31\x83\x6b\xe0\x9c\x2d\x5a\x68\x8b\x75\xa0\xd5\xcb\xb3\x9c\xfa\xdf\x6c\xfe\x2c\x39\x31\xb9\x16\x5a\x70\xa1\xae\x43\x97\x2d\xea\xcb\xd3\x75\x65\xa9\xd2\x66\x11\x7f\x1f\xae\xe0\x41\x76\x7e\xfc\xd4\x46\x4f\xe6\x0f\xdb\x69\xa6\x4f\x08\xc6\x56\x06\xdd\xab\x85\x88\xb3\x27\x0e\xa2\x5e\xcc\x13\xbf\x47\x43\xfd\x35\xd1\xe8\x68\x48\x05\xd8\x1b\x24\xbe\x9a\xcd\xe7\x43\xf0\xfd\xdd\xc3\xca\xbc\x7c\xc1\xff\xe7\xed\xea\xe3\x3f\x71\x62\x8d\x78\x54\x8b\xe0\x88\x3c\x61\xc7\xa3\xdc\x39\x97\x84\x6f\x23\xf0\xdb\x08\xfc\x4b\x46\xe0\x93\x78\xfb\x04\xd1\x9b\x26\x2e\x97\xcf\x6c\xf0\xb6\x63\x67\xb8\xf6\x43\xbd\x6f\x42\xcf\xda\x93\x52\x3d\x11\xea\x53\x46\xda\x2d\x7d\x8a\xee\x8f\x7c\xce\x7e\x03\x83\xd5\xed\xd4\xc0\x1b\xab\x7f\xe1\x70\x74\x87\x3f\xfd\xdd\x4f\x49\x05\x3c\xbb\x06\xa3\xf4\x0a\x2e\xde\x05\x9a\x71\x37\xc5\x6d\x53\x47\xa4\xc0\x39\x0e\xb6\x83\x75\x31\x80\x70\x1c\x5c\x0d\x2b\x03\xd7\x03\x74\xe7\xd4\xe3\x0d\x6c\x90\x68\x20\xa2\xcc\xec\x58\xec\x58\x8c\xf0\x30\x12\xda\xd3\x83\x2f\x0b\x3e\x86\x61\x0a\xeb\x43\x3c\xc3\x36\x0f\x44\x57\x03\xb3\x55\xae\x64\x1e\x0e\xbc\xeb\xfe\x73\x4d\x37\xb5\x2f\xeb\x9b\x97\xad\xe3\x3f\x6e\x9a\x37\xce\x89\x03\x33\xe2\xe6\xae\x86\x13\x3b\x76\xe4\x65\x5a\x96\xf7\x0a\xab\xc0\x81\x0d\xd2\x4f\x4d\x14\x61\xd2\xf3\x4c\xf2\xdc\x0a\x0f\x71\x56\xb1\x66\x1f\x47\xc5\x56\x19\x3c\xfb\x6a\xc5\x9e\x20\x4c\x1d\xc9\xc3\xf1\x91\x3a\xf2\xb4\xdf\x33\xb0\x3f\xff\x94\x31\x36\xe7\x07\x01\xfb\x51\xa8\xd7\x63\x3c\xa3\xe5\xbf\x36\x68\xba\x09\xfe\x11\xae\x81\x5c\x89\x93\x0a\x31\xdc\x7d\x8e\x79\xb7\x35\xc5\x9a\x59\x1d\xa5\x3f\x90\x63\xa3\xf6\x35\xe3\xc2\xe3\xac\x94\x58\xb4\x94\xeb\x5e\x26\x8c\x78\x1c\x40\x76\x8c\x88\xbb\x40\x98\x43\x34\xe4\xf3\xd0\x71\xe1\x35\x4a\x0d\x94\x03\x60\xa3\x29\x66\xbc\xf7\x71\xda\x28\x7f\xca\x9a\x19\x75\x27\xf0\xc9\x59\x3f\x91\xfb\xa6\xa2\xe7\x68\x38\xa6\xdd\xc0\x04\x6f\x1e\xd5\x86\x21\x7c\x3c\xcf\xb4\x76\xf9\x90\x70\x80\xda\x23\x3c\x34\xab\x32\xc1\x97\xc7\xa9\x52\xf1\xb4\x9d\x4d\x9e\x09\x9e\x26\x91\x5f\xc5\xdc\xbf\x57\x1f\x4f\x47\xc7\xb1\x7f\xec\xe3\x19\x75\xf2\xae\xab\xbe\xc5\x47\x1a\x83\xd5\xe0\x0d\x5e\x03\xab\x7d\xeb\x75\x66\x46\xd5\xea\x76\x32\x9b\x4e\x7c\x9d\x49\xfb\x0a\x5e\x77\x6e\xbb\x84\xd7\xa5\x7c\xf9\xa2\x7e\x85\x37\x69\xa6\xfd\x3a\xaf\x23\x3d\x26\xbf\x07\x00\x00\xff\xff\x01\x05\x3d\xd5\x6c\x15\x00\x00" func utilityTokenforwardingCdcBytes() ([]byte, error) { return bindataRead( @@ -233,7 +255,27 @@ func utilityTokenforwardingCdc() (*asset, error) { } info := bindataFileInfo{name: "utility/TokenForwarding.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa7, 0x61, 0x0, 0x39, 0xe1, 0x8, 0xdd, 0x52, 0xdc, 0x52, 0x6f, 0xcf, 0x1c, 0x71, 0xb0, 0xeb, 0x88, 0x67, 0x4e, 0x94, 0x1f, 0xcb, 0x3f, 0xc6, 0x69, 0x6c, 0xb3, 0x22, 0xe1, 0x68, 0x7f, 0xad}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x37, 0x68, 0x20, 0x8a, 0x97, 0xd3, 0x88, 0x2b, 0xd3, 0x3f, 0x30, 0x2a, 0x82, 0x9a, 0x41, 0x3d, 0x17, 0x5, 0x4c, 0x41, 0x99, 0x4e, 0x7c, 0xb4, 0xe3, 0x46, 0x3a, 0x70, 0x34, 0xec, 0x92, 0x7e}} + return a, nil +} + +var _utilityViewresolverCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x56\xc1\x6e\xe3\x36\x10\xbd\xfb\x2b\xa6\x97\xd6\x06\xb2\xf6\xa5\xe8\xc1\x97\x6d\xb0\x8b\x00\x39\x74\x51\x74\xdd\xbd\x2c\x82\x62\x2c\x8e\x2d\x22\x14\x47\x25\x47\xd6\x0a\x41\xfe\xbd\x18\x52\xa6\x64\x67\xb3\x05\x8a\x9e\x8a\xe6\xa0\x08\xb2\xf8\xde\x9b\x37\x6f\x48\x6d\x36\xb0\xc3\x47\xf2\x70\x08\xdc\x80\xd4\x04\x1f\xee\x76\xf0\x0b\x09\x1a\x14\x84\x28\xe8\x0d\x06\x73\x03\x52\xdb\x08\x15\x7b\x09\x58\x09\xd0\x97\x96\x23\x45\x40\x0f\xd6\x0b\x85\x03\x56\x04\xc2\xe0\x48\x60\xb1\xd9\x00\xfa\x81\x3d\xc1\x9e\x43\xe0\x1e\x70\x5a\x88\xde\x40\xa0\xc8\xee\x44\x70\xb2\xd4\x47\x60\x0f\x56\xd6\x8b\xcd\x46\xd7\xed\x94\xa5\xb7\xce\x01\x3a\xc7\x3d\x0c\xdc\x29\x2c\xef\x05\xad\x52\x1d\x38\x34\x28\x96\x3d\xe0\x9e\x3b\x99\x23\xf7\x56\x6a\x7d\xe4\xa9\xa2\x18\x31\x58\x37\xc0\xa3\xe7\xde\xfa\xa3\xca\x91\x3a\xdd\xa4\x55\x99\x0f\x6e\x9d\x4b\x04\x9e\xc8\x80\x8d\x60\x25\x02\x1a\x13\x28\xc6\xa4\xd3\x63\x43\xe9\x66\xe0\xee\x87\x40\x70\x64\x36\xaa\xe6\xc8\xdf\x2d\xb0\x52\x96\x25\x3a\xb7\x9a\x24\x4c\x56\x7c\xb2\xd4\xff\x96\xcb\x0c\xf0\xb4\x58\x00\x00\x6c\x36\x1b\xb8\xeb\x7c\x95\xe4\x4b\x8d\x02\x81\xa4\x0b\x3e\x6a\xad\xc9\xfa\x62\xfb\xa7\xe4\x8c\x6d\x5a\x47\x0d\x79\x21\x03\xfb\x21\xbd\x91\xad\xd3\x4a\xce\xa4\xeb\x82\xfd\x91\x1b\x2a\x8f\x23\x34\x38\x40\x8d\x27\x82\xa6\x73\x62\x5b\x97\x17\x77\x41\x1b\x35\xb4\x14\xb3\x84\xd8\xb5\x2d\x07\x81\xe6\x4c\x9d\x9a\x52\x30\x23\x2b\x6d\xa0\xf1\x6a\x53\xc7\xb9\xd5\x12\xd0\x41\x8b\x01\x1b\x12\x0a\x70\xe0\x00\xb1\xa5\xca\x1e\x06\xe8\x6b\x5b\xd5\x97\x64\x49\x7b\x85\xce\x51\x28\xd0\x36\x82\x63\x7e\xd4\x5a\x74\x75\x0e\xc3\x81\xc3\x2b\x05\xbd\x71\x74\x22\x37\xbe\xa6\xb5\xed\x33\xf4\x1b\x3c\x7a\x8e\x62\xab\x35\xdc\x8f\xb6\x56\x18\xe9\x26\x53\x8e\x8b\xa7\x7a\x6a\xee\x9c\x19\x8d\x4f\xaf\x44\x6d\x72\x46\x0d\x74\xc4\x60\x9c\xb6\x9f\x0f\xd0\x2b\x54\x12\x6f\x23\xb4\x18\xa3\x86\xc4\x17\x75\x05\xf2\xe7\xe4\x42\xa9\x77\x37\xb4\xb4\x85\xdb\x99\x4b\x57\x4e\xf0\x99\xbd\x54\x3c\x41\x8d\xbf\xdc\x7a\xc0\x10\x70\x50\x19\xbb\xd4\x2b\x43\x07\xeb\xd5\x2a\x95\x3c\xcf\x45\x02\x59\xe7\xb9\x39\xa1\xeb\x28\x4f\xcf\x9e\xa0\x8b\x29\x36\x05\xfc\xfc\x67\xd4\x47\x6e\x29\x44\xd5\xa2\x13\x32\x76\x6c\xea\xa6\x70\x2a\x58\xff\x4f\xa1\x23\x0d\xe5\x72\xa5\x49\xa9\xd9\x5c\xfa\x30\x9f\x06\x55\x04\x87\xce\xc3\x91\xe4\xdd\xe8\x7f\xca\xf3\xf2\xd2\x22\xbd\xbe\x5d\x6d\xe1\xb3\xde\x3c\xbc\x3e\x22\x89\x3b\x02\x5e\x46\x34\x65\x26\xed\x49\xc2\x8f\xe4\xff\x9f\x82\xff\xd0\x14\x64\x28\xfd\x61\x0b\xbb\x9a\x52\x52\x54\x8b\x0a\x35\x14\x6d\x18\x73\xbf\x7e\x39\x38\x10\x25\x74\x95\x74\x41\xfb\xdc\x06\x8a\xe4\xe5\x3c\x36\x81\xfe\xec\x28\xca\xf5\xe2\x17\x01\xd6\xec\x8e\xb1\x9b\xe7\xf7\x6b\xf1\xbd\x49\x50\xd3\x83\x95\xd6\x3c\x7c\x4c\x1a\xde\x4e\x91\xfe\x35\xf0\xc9\x1a\x0d\x71\xa2\xd1\xea\x11\x22\x89\x16\x75\x19\xb9\x75\x29\x01\x38\x40\x01\x28\xe6\x2d\x69\x7d\x5c\x6b\xfa\x3e\xdc\xed\x56\x50\xe9\xf1\x7b\xde\x0c\xf2\x34\x5c\x9c\xc6\x6d\xe6\x9d\xd1\x16\x44\x35\x24\x5b\x9f\xc2\x62\xcb\x0c\xc4\xd7\x8d\x29\x2a\x26\x92\xeb\x33\xae\x84\x36\x1d\x9d\x51\xf7\x80\x7c\x96\xe1\x9e\x4f\x74\x03\xfb\x4e\xf4\xc0\xc7\x71\x4c\x6c\x95\x3e\x37\xac\x8f\x42\x68\xd4\x0e\xbc\x4c\xeb\xb7\x36\x97\xbc\xa9\x5c\xed\x20\xd7\x02\x66\x7b\xd7\xbf\xa5\x61\x96\x8f\x94\x8b\x3f\xce\x51\x7d\x11\x00\x5d\xf9\x3c\xc5\xe0\x16\x8e\x81\xbb\x56\x29\x52\x1d\x23\x48\xd0\xae\x19\xfa\x92\x4f\xf9\xfb\xf7\xff\xa8\x01\xef\xd8\x39\xca\xfb\xe6\xd3\xb7\x9d\xcb\xdf\x64\xf3\x0f\x94\xa5\x35\x5b\xf8\xfd\xde\xcb\x4f\x3f\xae\xb6\xf0\xfd\xd3\xf9\xf9\xf3\xdb\x19\x96\xfe\x8d\x53\xe6\xad\x2b\x8f\x9f\x17\x7f\xdb\xa7\xfb\xf7\xb9\x4b\x99\xe1\xe1\xeb\x98\x9f\x1f\x66\x90\xf9\xfa\xbc\x80\xbf\x02\x00\x00\xff\xff\x28\x02\x38\xc2\x9e\x0a\x00\x00" + +func utilityViewresolverCdcBytes() ([]byte, error) { + return bindataRead( + _utilityViewresolverCdc, + "utility/ViewResolver.cdc", + ) +} + +func utilityViewresolverCdc() (*asset, error) { + bytes, err := utilityViewresolverCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "utility/ViewResolver.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xea, 0xa3, 0x21, 0x4b, 0xe, 0x17, 0x8c, 0x56, 0x92, 0xcf, 0xc2, 0x43, 0xa1, 0x4c, 0x73, 0x91, 0x50, 0xd5, 0xd5, 0x7e, 0xf3, 0xf9, 0x20, 0x4a, 0x25, 0x2d, 0x70, 0x66, 0x7a, 0x67, 0xdb, 0x76}} return a, nil } @@ -332,10 +374,12 @@ var _bindata = map[string]func() (*asset, error){ "FungibleToken.cdc": fungibletokenCdc, "FungibleTokenMetadataViews.cdc": fungibletokenmetadataviewsCdc, "FungibleTokenSwitchboard.cdc": fungibletokenswitchboardCdc, + "utility/Burner.cdc": utilityBurnerCdc, "utility/MetadataViews.cdc": utilityMetadataviewsCdc, "utility/NonFungibleToken.cdc": utilityNonfungibletokenCdc, "utility/PrivateReceiverForwarder.cdc": utilityPrivatereceiverforwarderCdc, "utility/TokenForwarding.cdc": utilityTokenforwardingCdc, + "utility/ViewResolver.cdc": utilityViewresolverCdc, } // AssetDebug is true if the assets were built with the debug flag enabled. @@ -387,10 +431,12 @@ var _bintree = &bintree{nil, map[string]*bintree{ "FungibleTokenMetadataViews.cdc": {fungibletokenmetadataviewsCdc, map[string]*bintree{}}, "FungibleTokenSwitchboard.cdc": {fungibletokenswitchboardCdc, map[string]*bintree{}}, "utility": {nil, map[string]*bintree{ + "Burner.cdc": {utilityBurnerCdc, map[string]*bintree{}}, "MetadataViews.cdc": {utilityMetadataviewsCdc, map[string]*bintree{}}, "NonFungibleToken.cdc": {utilityNonfungibletokenCdc, map[string]*bintree{}}, "PrivateReceiverForwarder.cdc": {utilityPrivatereceiverforwarderCdc, map[string]*bintree{}}, "TokenForwarding.cdc": {utilityTokenforwardingCdc, map[string]*bintree{}}, + "ViewResolver.cdc": {utilityViewresolverCdc, map[string]*bintree{}}, }}, }} diff --git a/lib/go/templates/forward_templates.go b/lib/go/templates/forward_templates.go index d800b692..0dc724e0 100644 --- a/lib/go/templates/forward_templates.go +++ b/lib/go/templates/forward_templates.go @@ -3,10 +3,6 @@ package templates //go:generate go run github.com/kevinburke/go-bindata/go-bindata -prefix ../../../transactions -o internal/assets/assets.go -pkg assets -nometadata -nomemcopy ../../../transactions/... import ( - "strings" - - "github.com/onflow/flow-go-sdk" - "github.com/onflow/flow-ft/lib/go/templates/internal/assets" ) @@ -19,10 +15,6 @@ const ( createAccountPrivateForwarderFilename = "privateForwarder/create_account_private_forwarder.cdc" ) -const ( - defaultPrivateForwardAddr = "\"PrivateReceiverForwarder\"" -) - func GenerateDeployPrivateForwardingScript() []byte { code := assets.MustAssetString(deployPrivateForwardingFilanems) @@ -31,50 +23,26 @@ func GenerateDeployPrivateForwardingScript() []byte { // GenerateCreateForwarderScript creates a script that instantiates // a new forwarder instance in an account -func GenerateCreatePrivateForwarderScript(fungibleAddr, forwardingAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateCreatePrivateForwarderScript(env Environment) []byte { code := assets.MustAssetString(createPrivateForwarderFilename) - code = strings.ReplaceAll( - code, - defaultPrivateForwardAddr, - "0x"+forwardingAddr.String(), - ) - - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } -func GenerateSetupAccountPrivateForwarderScript(fungibleAddr, forwardingAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateSetupAccountPrivateForwarderScript(env Environment) []byte { code := assets.MustAssetString(setupAccountPrivateForwarderFilename) - code = strings.ReplaceAll( - code, - defaultPrivateForwardAddr, - "0x"+forwardingAddr.String(), - ) - - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } -func GenerateTransferPrivateManyAccountsScript(fungibleAddr, forwardingAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateTransferPrivateManyAccountsScript(env Environment) []byte { code := assets.MustAssetString(transferPrivateManyAccountsFilename) - code = strings.ReplaceAll( - code, - defaultPrivateForwardAddr, - "0x"+forwardingAddr.String(), - ) - - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } -func GenerateCreateAccountPrivateForwarderScript(fungibleAddr, forwardingAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateCreateAccountPrivateForwarderScript(env Environment) []byte { code := assets.MustAssetString(createAccountPrivateForwarderFilename) - code = strings.ReplaceAll( - code, - defaultPrivateForwardAddr, - "0x"+forwardingAddr.String(), - ) - - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } diff --git a/lib/go/templates/go.mod b/lib/go/templates/go.mod index 41e95a2a..7defcaa0 100644 --- a/lib/go/templates/go.mod +++ b/lib/go/templates/go.mod @@ -1,30 +1,5 @@ module github.com/onflow/flow-ft/lib/go/templates -go 1.18 +go 1.19 -require ( - github.com/kevinburke/go-bindata v3.22.0+incompatible - github.com/onflow/flow-go-sdk v0.20.0 -) - -require ( - github.com/btcsuite/btcd v0.20.1-beta // indirect - github.com/cheekybits/genny v1.0.0 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/ethereum/go-ethereum v1.9.9 // indirect - github.com/fxamacker/cbor/v2 v2.2.1-0.20201006223149-25f67fca9803 // indirect - github.com/go-test/deep v1.0.5 // indirect - github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381 // indirect - github.com/onflow/cadence v0.15.0 // indirect - github.com/onflow/flow-go/crypto v0.12.0 // indirect - github.com/pkg/errors v0.8.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/rivo/uniseg v0.2.0 // indirect - github.com/segmentio/fasthash v1.0.2 // indirect - github.com/stretchr/testify v1.7.0 // indirect - github.com/x448/float16 v0.8.4 // indirect - golang.org/x/crypto v0.17.0 // indirect - golang.org/x/sys v0.15.0 // indirect - golang.org/x/text v0.14.0 // indirect - gopkg.in/yaml.v3 v3.0.0 // indirect -) +require github.com/kevinburke/go-bindata v3.23.0+incompatible diff --git a/lib/go/templates/go.sum b/lib/go/templates/go.sum index d6035bf9..96e31ea1 100644 --- a/lib/go/templates/go.sum +++ b/lib/go/templates/go.sum @@ -1,588 +1,2 @@ -cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= -cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= -cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= -cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= -cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= -cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= -cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= -cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= -cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= -cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= -cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= -cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= -cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= -cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= -cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= -cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= -cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= -cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= -cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= -cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= -cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= -cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= -cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= -cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= -cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= -cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= -cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= -cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= -cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= -cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= -dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -github.com/Azure/azure-pipeline-go v0.2.1/go.mod h1:UGSo8XybXnIGZ3epmeBw7Jdz+HiUVpqIlpz/HKHylF4= -github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuIlp9AfUH5G1tvCHc= -github.com/Azure/azure-storage-blob-go v0.7.0/go.mod h1:f9YQKtsG1nMisotuTPpO0tjNuEjKRYAcJU8/ydDI++4= -github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= -github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0= -github.com/Azure/go-autorest/autorest/adal v0.8.0/go.mod h1:Z6vX6WXXuyieHAXwMj0S6HY6e6wcHn37qQMBQlvY3lc= -github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA= -github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g= -github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM= -github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc= -github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk= -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/OneOfOne/xxhash v1.2.5/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= -github.com/VictoriaMetrics/fastcache v1.5.3/go.mod h1:+jv9Ckb+za/P1ZRg/sulP5Ni1v49daAVERr0H3CuscE= -github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= -github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= -github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= -github.com/aristanetworks/goarista v0.0.0-20170210015632-ea17b1a17847/go.mod h1:D/tb0zPVXnP7fmsLZjtdUhSsumbK/ij54UXjjVgMGxQ= -github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= -github.com/btcsuite/btcd v0.0.0-20171128150713-2e60448ffcc6/go.mod h1:Dmm/EzmjnCiweXmzRIAiUWCInVmPgjkzgv5k4tVyXiQ= -github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw= -github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= -github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= -github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= -github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= -github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= -github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= -github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= -github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= -github.com/bytecodealliance/wasmtime-go v0.22.0/go.mod h1:q320gUxqyI8yB+ZqRuaJOEnGkAnHh6WtJjMaT2CW4wI= -github.com/c-bata/go-prompt v0.2.5/go.mod h1:vFnjEGDIIA/Lib7giyE4E9c50Lvl8j0S+7FVlAwDAVw= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.0.1-0.20190104013014-3767db7a7e18/go.mod h1:HD5P3vAIAh+Y2GAxg0PrPN1P8WkepXGpjbUPDHJqqKM= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cheekybits/genny v1.0.0 h1:uGGa4nei+j20rOSeDeP5Of12XVm7TGUd4dJA9RDitfE= -github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ= -github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= -github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= -github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= -github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cloudflare/cloudflare-go v0.10.2-0.20190916151808-a80f83b9add9/go.mod h1:1MxXX1Ux4x6mqPmjkUgTP1CdXIBXKX7T+Jk9Gxrmx+U= -github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= -github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= -github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= -github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ= -github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= -github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= -github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= -github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= -github.com/elastic/gosigar v0.8.1-0.20180330100440-37f05ff46ffa/go.mod h1:cdorVVzy1fhmEqmtgqkoE3bYtCfSCkVyjTyCIo22xvs= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/go-ethereum v1.9.9 h1:jnoBvjH8aMH++iH14XmiJdAsnRcmZUM+B5fsnEZBVE0= -github.com/ethereum/go-ethereum v1.9.9/go.mod h1:a9TqabFudpDu1nucId+k9S8R9whYaHnGBLKFouA5EAo= -github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= -github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= -github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fxamacker/cbor/v2 v2.2.1-0.20201006223149-25f67fca9803 h1:CS/w4nHgzo/lk+H/b5BRnfGRCKw/0DBdRjIRULZWLsg= -github.com/fxamacker/cbor/v2 v2.2.1-0.20201006223149-25f67fca9803/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= -github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= -github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/go-test/deep v1.0.5 h1:AKODKU3pDH1RzZzm6YZu77YWtEAq6uh1rLIAQlay2qc= -github.com/go-test/deep v1.0.5/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8= -github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= -github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= -github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= -github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= -github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2-0.20190517061210-b285ee9cfc6c/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= -github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= -github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= -github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= -github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= -github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= -github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= -github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= -github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= -github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= -github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= -github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= -github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= -github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/gorilla/websocket v1.4.1-0.20190629185528-ae1634f6a989/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/graph-gophers/graphql-go v0.0.0-20191115155744-f33e81362277/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= -github.com/hashicorp/golang-lru v0.0.0-20160813221303-0a025b7e63ad/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/huin/goupnp v0.0.0-20161224104101-679507af18f3/go.mod h1:MZ2ZmwcBpvOoJ22IJsc7va19ZwoheaBk43rKg12SKag= -github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/influxdata/influxdb v1.2.3-0.20180221223340-01288bdb0883/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY= -github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= -github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= -github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= -github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= -github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= -github.com/julienschmidt/httprouter v1.1.1-0.20170430222011-975b5c4c7c21/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= -github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= -github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw= -github.com/karalabe/usb v0.0.0-20190919080040-51dc0efba356/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU= -github.com/kevinburke/go-bindata v3.22.0+incompatible h1:/JmqEhIWQ7GRScV0WjX/0tqBrC5D21ALg0H0U/KZ/ts= -github.com/kevinburke/go-bindata v3.22.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= -github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= -github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= -github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= -github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381 h1:bqDmpDG49ZRnB5PcgP0RXtQvnMSgIF14M7CBd2shtXs= -github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= -github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= -github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= -github.com/mattn/go-isatty v0.0.5-0.20180830101745-3fb116b82035/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= -github.com/mattn/go-tty v0.0.3/go.mod h1:ihxohKRERHTVzN+aSVRwACLCeqIoZAWpoICkkvrWyR0= -github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= -github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw= -github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0= -github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E= -github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= -github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/olekukonko/tablewriter v0.0.2-0.20190409134802-7e037d187b0c/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/onflow/cadence v0.15.0 h1:CqvXDUTnN8W34lsrpPSxnw7aOioaABUGppC2hiYhkHQ= -github.com/onflow/cadence v0.15.0/go.mod h1:KMzDF6cIv6nb5PJW9aITaqazbmJX8MMeibFcpPP385M= -github.com/onflow/flow-go-sdk v0.20.0 h1:0xcSC7OGO8DWZ7GWk/TUorVNcaPRfudH67RTzc782Kw= -github.com/onflow/flow-go-sdk v0.20.0/go.mod h1:52QZyLwU3p3UZ2FXOy+sRl4JPdtvJoae1spIUBOFxA8= -github.com/onflow/flow-go/crypto v0.12.0 h1:TMsqn5nsW4vrCIFG/HRE/oy/a5/sffHrDRDYqicwO98= -github.com/onflow/flow-go/crypto v0.12.0/go.mod h1:oXuvU0Dr4lHKgye6nHEFbBXIWNv+dBQUzoVW5Go38+o= -github.com/onflow/flow/protobuf/go/flow v0.1.9/go.mod h1:kRugbzZjwQqvevJhrnnCFMJZNmoSJmxlKt6hTGXZojM= -github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= -github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= -github.com/pborman/uuid v0.0.0-20170112150404-1b00554d8222/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34= -github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= -github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= -github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= -github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= -github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= -github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= -github.com/prometheus/tsdb v0.6.2-0.20190402121629-4f204dcbc150/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= -github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= -github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho= -github.com/robertkrimen/otto v0.0.0-20170205013659-6a77b7cbc37d/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY= -github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rs/cors v0.0.0-20160617231935-a62a804a8a00/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xhandler v0.0.0-20160618193221-ed27b6fd6521/go.mod h1:RvLn4FgxWubrpZHtQLnOf6EwhN2hEMusxZOhcW9H3UQ= -github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/schollz/progressbar/v3 v3.7.6/go.mod h1:Y9mmL2knZj3LUaBDyBEzFdPrymIr08hnlFMZmfxwbx4= -github.com/segmentio/fasthash v1.0.2 h1:86fGDl2hB+iSHYlccB/FP9qRGvLNuH/fhEEFn6gnQUs= -github.com/segmentio/fasthash v1.0.2/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= -github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= -github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spaolacci/murmur3 v1.0.1-0.20190317074736-539464a789e9/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q= -github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570/go.mod h1:8OR4w3TdeIHIh1g6EMY5p0gVNOovcWC+1vpc7naMuAw= -github.com/steakknife/hamming v0.0.0-20180906055917-c99c65617cd3/go.mod h1:hpGUWaI9xL8pRQCTXQgocU38Qw1g0Us7n5PxxTwTCYU= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/syndtr/goleveldb v1.0.1-0.20190923125748-758128399b1d/go.mod h1:9OrXJhf154huy1nPWmuSrkgjPUtUNhA+Zmy+6AESzuA= -github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs= -github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= -github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees= -github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= -github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= -github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= -go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= -go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.uber.org/goleak v1.0.0 h1:qsup4IcBdlmsnGfqyLl4Ntn3C2XCCuKAE7DwHpScyUo= -go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= -golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= -golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= -golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= -golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= -golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= -golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= -golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= -golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= -golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= -golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= -golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= -golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= -golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= -golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k= -golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= -golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= -golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= -golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= -golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= -golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200828194041-157a740278f4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200918174421-af09f7315aff/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210223095934-7937bea0104d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= -golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= -golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= -golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= -golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200828161849-5deb26317202/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= -gonum.org/v1/gonum v0.6.1/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= -gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= -gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= -google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= -google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= -google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= -google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= -google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= -google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= -google.golang.org/api v0.31.0/go.mod h1:CL+9IBCa2WWU6gRuBWaKqGWLFFwbEUXkfeMkHLQWYWo= -google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= -google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= -google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= -google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= -google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= -google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= -google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= -google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200831141814-d751682dd103/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= -google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= -google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= -google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= -google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= -google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= -google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= -google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= -google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= -gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= -gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c= -gopkg.in/olebedev/go-duktape.v3 v3.0.0-20190213234257-ec84240a7772/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns= -gopkg.in/sourcemap.v1 v1.0.5/go.mod h1:2RlvNNSMglmRrcvhfuzp4hQHwOtjxlbjX7UPY/GXb78= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0= -gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= -gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= -honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= -honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= -rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= -rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= -rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +github.com/kevinburke/go-bindata v3.23.0+incompatible h1:rqNOXZlqrYhMVVAsQx8wuc+LaA73YcfbQ407wAykyS8= +github.com/kevinburke/go-bindata v3.23.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= diff --git a/lib/go/templates/internal/assets/assets.go b/lib/go/templates/internal/assets/assets.go index e86e1834..7f6d2441 100644 --- a/lib/go/templates/internal/assets/assets.go +++ b/lib/go/templates/internal/assets/assets.go @@ -1,42 +1,42 @@ // Code generated by go-bindata. DO NOT EDIT. // sources: -// ../../../transactions/burn_tokens.cdc (1.412kB) -// ../../../transactions/create_forwarder.cdc (2.319kB) -// ../../../transactions/generic_transfer.cdc (1.216kB) -// ../../../transactions/metadata/setup_account_from_vault_reference.cdc (1.839kB) -// ../../../transactions/mint_tokens.cdc (1.707kB) -// ../../../transactions/privateForwarder/create_account_private_forwarder.cdc (1.428kB) -// ../../../transactions/privateForwarder/create_private_forwarder.cdc (961B) -// ../../../transactions/privateForwarder/deploy_forwarder_contract.cdc (403B) -// ../../../transactions/privateForwarder/setup_and_create_forwarder.cdc (1.82kB) -// ../../../transactions/privateForwarder/transfer_private_many_accounts.cdc (1.144kB) -// ../../../transactions/safe_generic_transfer.cdc (1.831kB) -// ../../../transactions/scripts/get_balance.cdc (474B) -// ../../../transactions/scripts/get_supply.cdc (187B) -// ../../../transactions/scripts/get_supported_vault_types.cdc (971B) -// ../../../transactions/scripts/metadata/get_token_metadata.cdc (554B) -// ../../../transactions/scripts/metadata/get_vault_data.cdc (618B) -// ../../../transactions/scripts/metadata/get_vault_display.cdc (612B) -// ../../../transactions/scripts/metadata/get_vault_supply_view.cdc (695B) -// ../../../transactions/scripts/switchboard/check_receiver_by_type.cdc (562B) -// ../../../transactions/scripts/switchboard/get_vault_types.cdc (690B) -// ../../../transactions/scripts/switchboard/get_vault_types_and_address.cdc (721B) -// ../../../transactions/scripts/tokenForwarder/is_recipient_valid.cdc (436B) -// ../../../transactions/setup_account.cdc (1.323kB) -// ../../../transactions/switchboard/add_vault_capability.cdc (1.415kB) -// ../../../transactions/switchboard/add_vault_wrapper_capability.cdc (1.443kB) -// ../../../transactions/switchboard/batch_add_vault_capabilities.cdc (1.34kB) -// ../../../transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc (1.591kB) -// ../../../transactions/switchboard/remove_vault_capability.cdc (1.155kB) -// ../../../transactions/switchboard/safe_deposit_to_lnf.cdc (4.493kB) -// ../../../transactions/switchboard/safe_transfer_tokens.cdc (2.087kB) -// ../../../transactions/switchboard/safe_transfer_tokens_v2.cdc (1.866kB) -// ../../../transactions/switchboard/setup_account.cdc (1.685kB) -// ../../../transactions/switchboard/setup_royalty_account.cdc (5.883kB) -// ../../../transactions/switchboard/setup_royalty_account_by_paths.cdc (5.958kB) -// ../../../transactions/switchboard/transfer_tokens.cdc (1.518kB) -// ../../../transactions/transfer_many_accounts.cdc (1.35kB) -// ../../../transactions/transfer_tokens.cdc (1.404kB) +// burn_tokens.cdc (1.637kB) +// generic_transfer_with_address.cdc (2.072kB) +// generic_transfer_with_paths.cdc (1.678kB) +// metadata/scripts/get_token_metadata.cdc (724B) +// metadata/scripts/get_vault_data.cdc (788B) +// metadata/scripts/get_vault_display.cdc (782B) +// metadata/scripts/get_vault_supply_view.cdc (865B) +// metadata/scripts/get_views.cdc (752B) +// metadata/setup_account_from_address.cdc (1.857kB) +// metadata/setup_account_from_vault_reference.cdc (1.84kB) +// mint_tokens.cdc (1.758kB) +// privateForwarder/create_account_private_forwarder.cdc (1.926kB) +// privateForwarder/create_private_forwarder.cdc (1.604kB) +// privateForwarder/deploy_forwarder_contract.cdc (418B) +// privateForwarder/setup_and_create_forwarder.cdc (2.455kB) +// privateForwarder/transfer_private_many_accounts.cdc (1.444kB) +// safe_generic_transfer.cdc (1.869kB) +// scripts/get_balance.cdc (655B) +// scripts/get_balance_generic.cdc (370B) +// scripts/get_supply.cdc (177B) +// scripts/get_supported_vault_types.cdc (903B) +// setup_account.cdc (1.63kB) +// switchboard/add_vault_capability.cdc (4.239kB) +// switchboard/add_vault_wrapper_capability.cdc (1.906kB) +// switchboard/batch_add_vault_capabilities.cdc (1.636kB) +// switchboard/batch_add_vault_wrapper_capabilities.cdc (1.878kB) +// switchboard/remove_vault_capability.cdc (1.169kB) +// switchboard/safe_transfer_tokens.cdc (2.074kB) +// switchboard/scripts/get_vault_types_and_address.cdc (627B) +// switchboard/setup_account.cdc (2.042kB) +// switchboard/setup_royalty_account.cdc (4.831kB) +// switchboard/setup_royalty_account_by_paths.cdc (4.942kB) +// switchboard/transfer_tokens.cdc (1.684kB) +// tokenForwarder/create_forwarder.cdc (2.706kB) +// tokenForwarder/scripts/is_recipient_valid.cdc (278B) +// transfer_many_accounts.cdc (1.772kB) +// transfer_tokens.cdc (1.803kB) package assets @@ -106,7 +106,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _burn_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x54\x4f\x6f\x9b\x4e\x10\xbd\xf3\x29\xe6\xc7\xe1\x27\xe7\x10\x68\xa5\xaa\x07\x2b\x6e\xea\x44\xcd\xb1\xaa\x1a\xb7\x3d\x2f\x30\x98\x6d\x61\x17\xcd\x0e\xb5\xad\x28\xdf\xbd\xda\x59\xc0\x4b\x13\x97\x83\x91\x77\xdf\xbc\x79\x6f\xfe\x90\xe7\xb0\x6b\xb4\x03\x26\x65\x9c\x2a\x59\x5b\x03\xda\x81\x02\xc6\xae\x6f\x15\x23\xd4\x96\xfc\xdf\xe8\x9e\x1b\xc5\x49\x9e\x43\x69\x87\xb6\x82\x02\x61\x70\x58\x41\x71\x02\x6e\x10\x54\xd5\x69\x03\xaa\x2c\xed\x60\x18\xd8\x42\x31\x90\x01\xb6\xbf\xd0\x38\x1f\x54\x93\xed\x3c\x50\x13\x38\xb6\x84\x15\x7c\x57\x43\xeb\xf9\x12\xd1\x82\x12\xa0\xcd\x1e\x54\x27\x14\x87\x29\x8b\x82\x5e\x91\xea\x90\x91\x3c\xaf\x4f\x16\xa9\x4a\x12\xdd\xf5\x96\x18\x1e\x06\xb3\xd7\x45\x8b\x3b\x9f\x32\xa4\x4b\x17\x67\xe9\x84\xfc\x74\x54\x5d\xbf\x04\xc6\x47\x69\x92\x44\xfc\xab\x20\x67\x0d\xdf\x1e\xf4\xf1\xfd\xbb\x2b\x78\x4a\x12\x00\x80\x3c\xcf\x83\x03\x20\x74\x76\xa0\x12\xa5\x3e\xd0\xd8\xb6\x72\x41\xa4\x78\x0f\xa7\x8a\x10\x0a\xf4\xee\xbc\x4b\xac\x84\xa2\x45\x86\xdf\x9e\x62\x0d\x1f\x17\x4a\xb3\x50\x9a\x39\xcf\x57\xac\x91\xd0\xf8\x14\xc1\xff\xc2\xc1\x56\x2a\x6f\x8b\x9f\x58\xf2\xcc\x2b\xed\x58\xc3\xff\x31\x32\x13\xa4\x76\x4c\x8a\x2d\x9d\xe9\x77\x22\x96\x55\x0b\x6e\xe8\xfb\xf6\x04\xb6\x9e\xc4\x17\x58\x5b\x42\xc9\xe9\x85\xcf\xf4\x01\x78\x27\xb7\x53\x69\x02\x61\x4f\xd8\x2b\xc2\x95\xd3\x7b\x83\xb4\x86\xed\xc0\xcd\x36\x4c\xc5\x5c\x3b\xff\x38\x6c\xeb\x2c\xa6\x81\xcd\xc2\x56\x26\x8a\x1e\x05\x70\x8e\xca\x73\xf8\xa1\xb9\xa9\x48\x1d\xe0\xed\x9b\x49\xe5\x34\x5b\xe3\x10\x4a\x4d\x41\x1b\x19\x34\xb5\xc7\x65\xce\x70\x7b\x73\x0d\x41\x61\x56\x58\x22\x7b\xb8\x59\x56\x4a\x1a\xf0\x61\xe5\x89\xd7\xf0\xf2\xe6\x31\x10\x7f\x51\xdc\x5c\xfd\x37\xd3\xfb\x27\x3b\x8c\xf2\xe6\xb9\x09\xef\xab\x85\x87\x7b\x42\xbf\x62\x0a\xe8\xef\xce\x8e\x6b\x24\xbf\xf3\x60\x5d\xb2\x12\x60\x9b\x7f\x3a\x59\xf4\xfc\x55\x47\x82\x88\x1d\x2d\x0c\xdd\xde\x42\xaf\x8c\x2e\x57\xe9\xbd\x2c\xa4\xb1\x0c\x21\xd1\x65\xf9\x93\xf0\x34\x50\x3d\x07\xef\x78\xc4\x72\x60\x84\xa7\x99\xdf\x4f\x92\xec\x03\x49\x3f\x66\x4b\x59\x29\xf5\xf9\x8c\x87\x3b\xb9\x5d\x45\xd5\x0b\xf8\xcc\xbf\x44\xbe\x1b\x2d\xdd\x5c\x9f\xbb\x1b\xc1\x2b\x74\x4c\xf6\x34\x86\xc5\x72\x7a\xeb\x38\xd2\x72\x69\xf6\x60\xb3\x79\x65\x56\xaf\x61\x6a\x6f\xfa\x62\x7b\xba\xc1\xb1\xff\x6e\x55\xe8\x6d\xc4\x9f\x48\x09\x49\x47\x11\xcf\xc9\x9f\x00\x00\x00\xff\xff\xe2\xec\xe9\x43\x84\x05\x00\x00" +var _burn_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\xcd\x6e\x9b\x40\x10\xbe\xf3\x14\x53\x0e\x29\x48\x0d\xbe\x54\x3d\x58\x76\xd2\x24\x4d\x6e\x95\x2a\xc5\x75\xcf\x03\x0c\x66\x55\xd8\x45\xbb\x43\xec\x28\xcd\xbb\x57\xbb\xcb\x62\x88\xe3\xaa\x1c\x12\xb1\xcc\x7c\x3f\x33\xdf\x5a\xb4\x9d\xd2\x0c\xf1\x43\x2f\x77\x22\x6f\x68\xa3\x7e\x93\x8c\xa3\x70\x7c\x7f\xc0\xb6\x3b\x39\x9d\x15\x7f\x27\xc6\x12\x19\xb7\x82\xf6\xe6\x58\x73\xdb\x6b\x49\x3a\x8e\xa2\xc5\x62\x01\x9b\x5a\x18\x60\x8d\xd2\x60\xc1\x42\x49\x10\x06\x10\x98\xda\xae\x41\x26\xa8\x94\xb6\xaf\x93\xef\x5c\x23\x43\xa1\xfa\xa6\x84\x9c\xa0\x37\x54\x42\xfe\x0c\x5c\x13\x60\xd9\x0a\x09\x58\x14\xaa\x97\x0c\xac\x20\xef\xb5\x04\xb6\x4a\x0c\x54\x5a\xb5\xb6\x4a\x68\x47\x6b\x58\x69\x2a\x61\x8b\x7d\xc3\xf6\x60\xd0\x42\xae\x47\xc8\x1d\x60\xeb\x50\xf6\x81\x08\xa1\x43\x8d\x2d\x31\x69\x0b\x6d\xf9\x26\xaa\x1c\xc4\xe4\x3d\xf1\xed\x4b\xf8\xf9\x20\x0e\x5f\x3e\xa7\xf0\x12\x45\x00\x00\x81\x85\x15\x63\x03\xa6\xef\xba\xe6\x19\x54\x15\x44\xe6\x54\x29\x4d\x0e\xdc\xea\x70\x2d\x0d\xf1\x50\x78\xeb\xbe\x06\xcc\x23\xa0\x33\x01\x9a\x8c\xea\x75\x41\x7e\x40\xb5\x6a\x4a\xe3\x55\x7a\x68\x77\x8a\x9a\x20\x27\x6b\xcf\xc2\x53\x39\x12\xd8\x57\x07\xb3\x84\xaf\xd3\xc5\x66\x7e\x40\xae\xae\xd3\xd4\xa1\xa6\xc4\x88\x9d\x24\xbd\x04\xec\xb9\x4e\x6e\x95\xd6\x6a\xbf\xc5\xa6\xa7\x14\x2e\x6e\xfc\xec\x47\xbb\xf6\x31\xd4\x54\xd9\xd4\x00\xac\x61\x46\xe1\x66\xf1\xe8\x0a\x8e\x5d\x56\xd4\x93\xe5\xfe\x86\x8c\x6f\x3b\xac\xd5\xe6\x89\xee\x94\x64\x8d\x05\xdb\x78\x25\xc1\xfe\xe6\xb9\xa3\x25\x48\xd1\x7c\x82\x27\x41\x7b\xff\x6a\xff\xae\xce\x47\x33\x7b\xd8\x6c\x03\xd7\x55\x92\xa6\x80\xe6\x03\xfc\x5f\xf9\xf5\xa8\xd8\x3e\xd7\xd7\xd0\xa1\x14\x45\x12\xdf\xb9\xdc\x48\xc5\xb0\x0b\x4e\xc0\x02\x38\x51\x2e\xd5\x76\x37\xc5\xe0\x20\x4e\x8f\xce\x17\x0b\xf8\x25\xb8\x2e\x35\xee\xdf\x66\x17\xfc\xe8\x3f\x9a\x01\x50\x48\x97\x63\xdc\xd1\x6c\x6e\x7e\x10\x3e\x15\xeb\xa1\x27\x1b\x0a\xb3\xdc\x2d\x6c\xe5\x96\x37\xb3\x98\x05\xd6\x14\x2e\x4e\x23\x70\x95\xcc\x8c\xda\xc7\xaa\x5a\x1e\x97\x14\x18\x7e\x20\xd7\xb3\xda\xf4\xdd\xb1\x78\x1d\x80\xa0\xa9\x22\x4d\xd2\x06\x57\xcd\x4d\x4e\x55\x78\x9e\x38\x9d\xc7\x6a\x8c\x2d\xac\x2e\xa7\xb6\xb3\xfd\xe0\x65\xbc\x87\xfe\xbf\xdf\xec\x7b\x09\xb7\x90\xaf\x7e\x09\x74\xa0\xa2\x67\x9a\x66\xd8\xff\x62\x39\xba\x64\x75\x39\xa7\x1e\x56\x37\x34\x77\xca\x30\xbc\x8c\x8d\xe7\x82\x0e\xeb\x35\x24\xa7\x37\xe3\x32\xe8\x5c\xce\x26\x18\x87\x9b\x1f\x67\x85\x92\x05\xf2\x69\x6b\xc6\xea\x91\xb5\x90\xbb\x24\x4d\x67\xbd\xa1\x23\x86\x3f\x70\x53\xb1\xbd\xb8\x23\xca\x39\x75\x53\xb0\xf3\x68\xf7\x87\x8e\x0a\xa6\x72\x02\xf8\x2f\x4b\xa7\xa0\xaf\xd1\x6b\xf4\x37\x00\x00\xff\xff\x87\x35\xe9\x7a\x65\x06\x00\x00" func burn_tokensCdcBytes() ([]byte, error) { return bindataRead( @@ -122,431 +122,411 @@ func burn_tokensCdc() (*asset, error) { } info := bindataFileInfo{name: "burn_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbe, 0x91, 0xe, 0x82, 0x84, 0xc4, 0xe2, 0x8f, 0x0, 0xc0, 0x5, 0x19, 0x4d, 0x9a, 0x77, 0x5a, 0xed, 0x97, 0x1, 0xc5, 0xd6, 0x8, 0x0, 0x0, 0x57, 0x2a, 0x64, 0x4f, 0xb5, 0xc0, 0xf9, 0x77}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xcd, 0x3a, 0x71, 0x8e, 0xc0, 0xcf, 0x7, 0x23, 0xb1, 0x43, 0xfd, 0x39, 0xec, 0xdf, 0x21, 0xe7, 0x92, 0x6d, 0xba, 0x52, 0x22, 0x80, 0x25, 0xdb, 0x62, 0xe9, 0xeb, 0x93, 0x24, 0x5, 0xda, 0xad}} return a, nil } -var _create_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x54\x4d\x6f\xe3\x36\x10\xbd\xf3\x57\x0c\x72\x68\x9d\xc0\x91\xd1\xaf\x8b\x91\x16\x08\xb6\x4d\x51\xa0\x28\x16\x6d\xda\x6b\x77\x4c\x8e\x4d\x36\x12\x29\x90\x23\x6b\x8d\x45\xfe\x7b\x41\x52\xa2\x29\x63\x1b\x1f\xea\x93\x45\xce\xc7\x7b\xf3\x1e\x67\x73\x77\x27\xc4\xb3\x36\x01\xd8\xa3\x0d\x28\xd9\x38\x0b\x26\x00\x02\x53\xd7\xb7\xc8\x04\x7b\xe7\xe3\x67\x75\xcf\x1a\x19\xa4\x1b\x5a\x05\x3b\x82\x21\x90\x12\xec\x20\x10\xc3\xd0\x03\x5a\x40\x29\xdd\x60\x19\xd8\xc5\xe4\x11\xbd\x02\x45\xbd\x0b\x86\x49\x01\xbb\x17\xb2\x21\xde\xa1\x75\xac\xc9\x83\x27\x49\xe6\x48\xbe\x11\xe2\x97\x3d\xa0\x3d\x39\x4b\x10\xc8\xaa\x50\x07\xc7\x3e\xfe\xcb\x00\x4f\xb9\x22\x79\xf8\x7d\xca\x5b\x0b\xd6\x54\xbe\x60\x34\x6d\x0b\xff\x0c\x81\x4b\x73\xd6\x2e\x50\x55\x2b\x86\xff\x85\x43\xcb\x99\x89\xc6\x00\x3b\x22\x2b\x22\x03\x0c\xe9\xda\x93\x34\xbd\x21\xcb\x80\x56\x01\x75\x26\xfe\x01\x3a\xc6\x93\x94\x64\xac\x32\x12\x99\x82\x18\xb5\x91\x3a\xa1\x9b\x1b\x46\x96\x7a\x6e\xd8\x4c\x03\x1e\xf1\xb4\x06\x13\xf9\x81\xdb\xef\xef\xa5\x46\x63\x21\x90\x3f\x1a\x49\x30\xa2\xe5\x04\xad\x73\xd6\xb0\xf3\x30\x6a\x17\x65\x98\x0a\x1a\x7b\x10\x67\xf8\x86\xd7\x60\x18\x24\x5a\x18\x91\xa5\xce\xb0\xd2\x55\x20\x82\x51\x93\xa7\x0a\x00\x48\xec\x08\xf6\xde\x75\x8d\x10\x7f\x30\xf5\x53\x64\x56\x2b\x4b\x15\x60\x34\xac\x73\x42\x61\xe1\xb7\x42\x7c\xd5\xc0\xb3\x26\x78\x1a\xec\xc1\xec\x5a\x82\xe7\x14\x21\x9d\x65\x8f\x32\x4e\x81\xc9\xef\x51\x12\x04\x9d\xfc\x80\xad\x27\x54\xa7\xe8\x0b\x45\x7d\xeb\x4e\xa4\x20\xb8\x8e\x12\x28\xf1\x75\xae\x86\x7d\xdf\x1a\x89\xb1\x1e\x2f\xeb\x4d\x55\xaa\xec\x46\x7c\x93\x93\x2a\x45\x26\x7b\x4d\xc1\x1a\x8f\x04\x38\x09\x1a\xcd\xca\xc9\xcf\xb9\xb0\x27\x64\x52\x02\x00\x92\x90\x81\x9d\x27\x05\xc6\x82\xe1\x90\xbe\xf0\x40\x99\x3b\x42\x3f\xec\x5a\x13\x34\xa9\xe2\x25\xf1\x6d\x03\x3f\x26\x20\x69\x9e\x1f\x12\xfb\xa7\xa2\x49\x23\x95\xfc\x70\x06\x9f\x5c\xaa\xcc\x7e\x4f\xbe\x82\x29\xbe\x6b\xa2\x67\x01\xc1\xd2\x08\x8f\xf9\x70\x0b\xef\x12\xb2\x54\x76\xe6\x63\x9d\xef\xb0\x6d\x4f\xeb\x04\x97\x35\x59\xf0\x83\xcd\x9d\x33\x91\xbf\x8b\x34\xb9\x75\xf5\x28\x73\xd2\x81\x98\x8d\x3d\xc0\xe2\x41\x44\xe9\x17\x8d\xb2\x81\x2f\x8c\xde\x88\xbb\x8d\x10\xa6\xeb\x9d\xe7\xa2\x77\x96\x3b\x15\xb8\x59\x9c\xdd\xcc\x91\x3f\x7d\xc4\xae\x5f\x06\xd6\x47\x25\xee\x62\x74\x53\xe8\xc5\xe9\x8d\x10\x15\xa5\xd5\xbc\x18\xb6\xf0\xa8\x94\xa7\x10\x6e\xe1\x93\x48\x3c\x7b\x4f\x3d\x7a\x5a\xa1\x94\xbc\x85\xc7\x81\xf5\x34\xd8\x12\x11\x7f\x9b\x0d\xfc\x4c\x3c\xd3\xcc\xc3\x90\xd8\xe3\xce\xb4\x86\x4f\x93\x57\xce\x63\xd9\x51\x02\x76\x7e\xc3\xae\x54\x6a\x89\x2b\x03\x7e\x1f\xe7\x3c\x35\x2c\x20\x6f\x4b\x70\xfc\x35\x07\xe2\x77\xa5\xd5\xc3\x17\x9f\x16\xd3\x6b\x66\x6d\x5e\x7f\x58\xd5\xd3\x2a\xe7\xef\xa3\x15\xe5\x7b\x64\x7d\xbb\xa0\x53\xb9\xa6\x58\x21\x1b\x3b\x3e\x02\xc3\xf3\x76\xbb\x54\x5a\xb9\xd9\x15\xd5\x46\xa9\xc9\x1d\xd3\xeb\x79\xb8\xbf\xd4\xa9\xc9\xc6\xfb\x8d\xc6\xb2\x77\x57\x65\x10\xdb\xf3\x4c\xce\xec\xa3\x24\x4d\x84\xb3\x7a\xb8\x4f\x55\xd7\xc0\x6e\x0b\x9b\xe9\xb1\x6d\xa8\xe2\x5b\x6a\x2e\x59\xfe\x69\x5b\x63\x5f\x12\x5c\xfa\x68\x42\x72\xf4\x67\x04\x2c\x29\x71\xab\xc6\xae\x8b\x99\x5f\x1d\x6c\x23\x35\xc9\x97\xb7\xa4\x89\x66\xaa\x45\x4d\x4d\x86\x04\xee\xba\x6c\x73\xd2\xeb\x82\xda\xaf\x33\xb1\xb8\x0c\xce\x5a\xbc\x49\x2f\xb5\x8d\x4d\xdf\xc2\xba\x00\x7a\x05\xdc\x7a\x11\xcc\xe8\x0f\xc4\xd7\x14\x2a\x29\xb7\xff\xcd\xa7\x04\xe7\x56\xd7\xb8\x5c\x5a\xed\x22\xfd\x92\xd4\x26\xed\x67\xf9\x79\x78\xff\x93\x52\x16\xea\xf5\xdf\x00\x00\x00\xff\xff\x66\x2e\x02\x56\x0f\x09\x00\x00" +var _generic_transfer_with_addressCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x55\x4d\x6f\xdb\x46\x10\x3d\x5b\xbf\xe2\x59\x87\x84\x04\x1c\xfa\x52\xf4\x20\x38\x76\x5d\x17\xee\xa9\x45\x90\x2a\xee\x79\x44\x8e\xc4\x85\xa9\x5d\x62\x77\x28\xc5\x30\xf4\xdf\x8b\xfd\xe0\x56\x54\x6c\xc7\x3e\x58\xd2\x70\xe7\xcd\xcc\x7b\x6f\x96\x6a\xdb\x1b\x2b\x98\xdf\x0f\x7a\xa3\x56\x1d\x2f\xcd\x23\xeb\xf9\xec\xc5\xf0\x5f\x2c\xd4\x90\xd0\x83\xe2\xbd\x9b\xcf\x66\x97\x97\x97\xb8\x23\x8d\x9e\x9c\x83\xd2\x20\xfd\x84\xda\x68\xb1\x54\x0b\xa8\x69\x2c\x3b\x07\xd2\x0d\x34\x6d\x19\x62\x20\x96\xb4\x5b\xb3\x05\x41\x3c\x20\xd6\xd6\x6c\x21\x2d\x49\xce\x0b\xa0\xcb\x56\x39\x74\x2c\x0e\x4f\x66\x40\xdd\x1a\xe3\x18\xd2\x72\xca\xf2\xc1\x3d\x69\xf1\x90\x8e\x75\xe3\x73\x42\xde\xed\x71\x03\x35\x69\xac\xd8\x67\x3b\xd6\x68\xd9\xf2\x05\x9c\xc1\x9e\xba\x80\xec\x5a\x33\x74\x0d\xea\x96\xeb\x47\x90\xdd\x0c\x5b\xd6\x82\x1d\x75\x03\xbb\x00\x26\x06\x5b\x7a\x64\xb8\xc1\xc6\xe2\x4a\x0b\xeb\x86\x9b\xd4\x45\x2e\x14\xa6\xf3\x63\x8e\x23\x2b\x17\x28\xe1\x06\x4a\x87\xde\xc2\xdc\x54\x8b\x32\xba\xa0\xad\x19\xb4\x2c\xf0\xed\x5e\x7d\xff\xf5\x97\x0b\x88\x59\xe0\x36\x26\x5e\x64\xcc\x14\x78\xe1\xc9\xdf\xb4\xe5\x05\xfe\x11\xab\xf4\xa6\xc4\xf3\x6c\x06\x00\x81\x32\xc6\x03\x0d\x9d\xc0\xb2\x33\x83\xad\x39\xf2\xda\x9a\xae\x71\xff\x73\xe7\x62\x94\x2c\x63\xc5\x4a\x6f\xb2\x24\x96\x9b\x00\xd5\xb1\x40\x78\xdb\x07\xac\x05\x7e\x7b\x9e\x38\xa0\x0a\xe1\x43\xae\x7a\xbf\x0c\x81\x3f\x48\x08\x4e\xec\x50\x07\x4d\x36\x2c\xe8\x49\x5a\x17\xf4\xcd\xb0\xbb\xf1\xe8\x02\xaf\xdb\xaa\x3a\x82\x8c\x65\x7a\xcb\x3d\x59\x2e\x9c\xda\x68\xb6\x0b\xd0\x20\x6d\xf1\xbb\xb1\xd6\xec\x1f\xbc\x5a\x25\x3e\xdc\xd6\xb5\x27\x35\xf3\x91\xba\x8b\x87\x40\xb0\xbc\x66\xcb\xba\x8e\x26\x6c\x39\xb6\x02\x27\xc6\x72\x03\xa3\x43\x2c\x49\x46\x11\x0b\x24\xc7\xd1\x7e\x58\x75\xaa\xfe\x42\xd2\xe6\x02\x7e\x24\xcf\x75\xb7\x63\xfb\x95\xd7\xf8\xec\xe7\x4e\x9d\x14\x27\x42\x96\x39\xcb\xff\x55\xe3\x53\x57\xad\x42\x8b\x57\x1f\xa6\x34\x1f\xae\x0b\x1d\x74\x3e\x56\x7d\x8a\x71\x73\x83\x9e\xb4\xaa\x8b\xf9\x5d\xf0\xb1\x36\x82\xd5\xab\xf3\xae\x13\xfa\x89\x75\xe7\xe5\x84\xaf\x6f\x2e\x99\x66\x92\x6f\x59\xac\xe2\x5d\xdc\x81\xfb\xa5\x57\x09\x39\xcb\x71\xb7\xae\xb2\xb0\xf8\x7c\xcc\x48\x95\xbe\xdf\xa5\x6a\x3e\xb3\x18\xdd\xb9\x7c\xea\x79\x01\xad\xba\x0b\xec\x14\xef\xe3\x4f\xff\xff\xea\x7d\xde\xb8\x2e\xca\x12\xe4\xce\xdf\x69\xa5\x9b\x9f\x92\x97\x9a\x1d\xa7\xcc\x23\xf9\xee\xb0\x36\x36\x3c\xd8\xa8\x1d\xeb\x5c\xf2\x6d\x36\xff\x64\x79\x49\x8a\x68\xe3\x8f\x6e\x74\x5f\x20\x6f\x62\xaa\x10\x89\x8e\x8a\x87\x2b\x7f\x94\x36\x3c\xba\x25\x6c\xc0\x74\x2f\xff\x55\xd2\x36\x96\xf6\x25\x4e\xac\x54\x7d\xb1\x66\xa7\x1a\xb6\x87\xeb\xc2\x6f\xe3\xe2\x44\xb2\x11\xdb\x5b\xbb\x9c\x9d\x9d\x9d\xbd\x61\xac\x1f\x66\x31\xfb\x38\x4a\x60\xeb\xfc\x78\xfe\x50\x24\xdf\x23\xb8\xfa\x94\xa7\xaa\xf6\xa9\xd5\x7c\x13\xc6\xcf\x68\xef\x74\xb5\xf0\x77\xae\x07\x61\x3c\x9f\x6c\x5b\xad\x7a\xe5\xaf\xe9\xc9\xae\x89\x29\x4f\x8f\xb1\xca\x4b\x99\x93\xaa\x9a\x7a\x5a\xa9\x4e\x89\xe2\xd7\x16\xaf\xfa\x9a\x72\x0f\xd7\xc5\x09\x4f\x23\x6a\x24\xea\x9d\xab\xf8\x03\x63\xb9\x9b\x8f\x0e\x63\xad\xf3\x13\xe3\x2c\xc7\xb7\x64\xba\xb1\xd3\x4b\xf2\x15\xeb\x1c\x21\x07\x34\xe4\x31\x9f\x32\xe8\x11\x23\x55\xc3\xbd\x71\x4a\x92\x19\xae\x3e\x4d\x95\x1a\x55\x38\xfc\x17\x00\x00\xff\xff\xb0\x78\xc6\x50\x18\x08\x00\x00" -func create_forwarderCdcBytes() ([]byte, error) { +func generic_transfer_with_addressCdcBytes() ([]byte, error) { return bindataRead( - _create_forwarderCdc, - "create_forwarder.cdc", + _generic_transfer_with_addressCdc, + "generic_transfer_with_address.cdc", ) } -func create_forwarderCdc() (*asset, error) { - bytes, err := create_forwarderCdcBytes() +func generic_transfer_with_addressCdc() (*asset, error) { + bytes, err := generic_transfer_with_addressCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "create_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6c, 0xb, 0x4f, 0x5, 0xa7, 0x5a, 0xc1, 0x1a, 0x19, 0xbb, 0xe4, 0xc5, 0x2b, 0xb4, 0xdb, 0x55, 0xa8, 0x60, 0x5, 0x5e, 0xa, 0xc9, 0x86, 0xf8, 0xdf, 0xf8, 0x64, 0x3b, 0xea, 0xdd, 0x7, 0x2b}} + info := bindataFileInfo{name: "generic_transfer_with_address.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x50, 0xe3, 0x8f, 0x2b, 0xb4, 0xff, 0xf8, 0x64, 0xaf, 0xe5, 0x57, 0xf, 0x46, 0xc6, 0x47, 0xae, 0xd8, 0x1c, 0x23, 0x52, 0x67, 0xa5, 0x96, 0xdd, 0xdc, 0x5d, 0x39, 0x26, 0x21, 0x75, 0xb8, 0x7}} return a, nil } -var _generic_transferCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x54\x4d\x6f\xe3\x38\x0c\x3d\x37\xbf\xe2\x35\x87\xdd\x04\x48\xd3\xcb\x62\x0f\x41\x3f\x36\x28\xd0\xbd\x16\x9d\xce\xdc\x19\x89\xb6\x35\x75\x24\x83\xa2\xe3\x06\x45\xfe\xfb\x40\xb2\xe3\x24\x53\x4c\x2e\x56\x68\xf2\xf1\xf1\xf1\x59\x6e\xdb\x04\x51\x3c\xb7\xbe\x74\x9b\x9a\xdf\xc2\x3b\x7b\x14\x12\xb6\x98\x5e\xc4\xa6\x93\xc9\xed\xed\x2d\x9e\xc8\xa3\xa1\x18\xe1\x3c\xc8\xef\x11\x35\x08\x95\x8c\x86\xb4\x02\x79\x0b\x61\xc3\x6e\xc7\xd2\x47\x9c\x8f\xca\x64\x11\x0a\xfc\x6c\xa3\x42\x2b\x86\xe5\x82\xda\x5a\x97\x19\xef\xad\x72\x11\x35\x6b\xc4\x3e\xb4\x30\x55\x08\x91\x73\x96\x66\x22\x29\xd8\x91\x57\x68\x40\x64\x6f\x41\x11\x1d\xd7\x75\x4e\x31\xd4\xd0\xc6\xd5\x4e\xf7\x5f\xf3\x5c\x3a\xe6\x16\xb9\xcd\xda\xef\x07\xc4\x4c\xcb\x90\xc7\x86\xf3\x20\x9c\x31\xc9\x83\xa4\x6c\xb7\xec\x15\x15\x0b\x2f\x10\x03\x3a\xaa\x33\xb3\x58\x85\xb6\xb6\x19\xa7\x3f\xc2\x54\x6c\xde\x4f\x15\x3b\xaa\x5b\x8e\xa9\xf7\x96\xde\x19\xb1\x95\x7e\x06\xe7\x95\xbd\x65\x7b\xde\xda\xc5\x63\x5b\xe7\x33\x3d\x15\xf2\x91\x8c\xba\xe0\x67\xb4\x0d\xad\xd7\x15\xbe\x3f\xbb\x8f\x7f\xff\x59\x40\xc3\x0a\x6b\x6b\x85\x63\x5c\xe4\xb9\x58\x5e\x48\xab\x15\xbe\xf5\xb2\xa7\x3f\x8b\x51\xf2\xfe\xd5\x4b\xbb\xa9\x9d\x49\xe7\x39\x3e\x27\x13\x00\xc8\x3a\x33\x7e\x24\xd9\x21\x1c\x43\x2b\x26\x31\x24\x45\x15\x6a\x1b\x4f\x82\xc7\x3e\x4a\xc2\xd8\xb0\xf3\x25\x32\xbb\x82\x45\xd8\x66\xa8\x9a\x15\xca\xdb\x26\x63\xad\xf0\xdf\x85\x47\x96\x39\xda\xf7\x6c\x84\x1b\x12\x9e\x45\x57\x7a\x96\x15\xd6\xad\x56\x6b\x63\xd2\x7c\x23\xaf\x81\xdb\xff\xac\x20\x08\x17\x2c\xec\x13\xb1\x90\x09\xf5\x95\x7f\xc7\xec\x31\xb6\xd8\x65\xf0\x63\x5d\x22\x92\x23\xaf\x5c\xe0\x7e\x48\x5e\x6e\x82\x48\xe8\xee\xfe\xfa\xbc\xe4\xf5\x22\x61\xe7\x2c\xcb\xe1\x61\x96\xac\xbd\x3a\xd3\x72\x3e\xb9\xba\xba\x7a\x7c\x44\x43\xde\x99\xd9\xf4\x29\xef\xd7\x07\x45\x0f\xf5\x95\x56\xe8\x7a\x56\x79\xd6\xeb\xe9\xfc\x34\x4a\xe4\xba\x58\x8e\xe2\xe0\xee\x66\x24\xb8\xec\x9c\x56\x56\xa8\x1b\x37\xdc\x3f\x87\xe2\x43\xff\xe0\x0f\x36\xad\xf2\xb9\x3a\x69\x4a\x61\xe3\x1a\x97\x7c\x76\x8f\x92\x75\x10\x71\xa6\x61\xfe\x7b\x5a\x76\x41\xaf\xc7\x58\xb4\x2c\x59\x9f\xc6\x0f\xe5\x8b\x32\xaf\x43\xd5\xe1\x61\x76\x6e\xa3\x13\x74\xfa\x0d\xb2\xce\xe6\xd7\x17\x7b\x7b\x1b\xbc\x71\xb4\x4e\xbe\x35\xfe\xb8\xb9\xa3\x7e\xe3\x05\x71\xfa\x7c\x47\xd0\xb3\x19\x96\x96\x9b\x10\x9d\x0e\x0b\xbb\xbb\xb9\x54\x77\x3e\x08\x77\xf8\x15\x00\x00\xff\xff\xad\x94\x66\x8c\xc0\x04\x00\x00" +var _generic_transfer_with_pathsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x55\x4b\x4f\xeb\x38\x14\x5e\xd3\x5f\xf1\xd1\x05\xa4\x52\x49\x37\xa3\x59\x54\x3c\x86\x41\x62\x34\x3b\x04\x0c\xb3\x76\xed\x93\xc6\x97\xd4\x8e\x7c\x4e\x5a\x2a\xd4\xff\x7e\x65\x27\x4d\x1f\xf4\xea\xea\x5e\x36\x24\xae\x7d\xbe\x67\x5d\xbb\xa8\x7d\x10\x0c\x1f\x1b\x37\xb7\xb3\x8a\x5e\xfd\x3b\xb9\xe1\x60\x30\x99\x4c\xf0\xa0\x1c\x6a\xc5\x0c\xeb\xa0\xdc\x1a\x2c\x3e\xa8\x39\xa1\x56\x52\x42\x39\x83\x40\x9a\xec\x92\x42\xbb\x62\x0d\x39\xb1\x85\xa5\x00\xeb\x58\x48\x19\xf8\x02\xdf\x1a\x16\x48\x49\x30\x54\xa8\xa6\x92\x3c\x8d\x7e\x2d\x2d\xa3\x22\x61\xac\x7d\x03\x5d\x7a\xcf\x94\x76\x49\xc4\x4f\x8b\x2b\xe5\x04\xe2\xc1\xe4\x0c\x14\x63\x45\x55\x95\xb6\x68\x55\xab\x99\xad\xac\xac\xbf\xee\xb3\xf1\x31\x41\x24\x98\x7b\xb7\xee\x26\x26\x86\x5a\x39\xcc\x28\x69\xa2\x34\x53\x39\xa8\x30\x6f\x16\xe4\x04\x25\x05\x1a\x83\x3d\x56\xaa\x4a\xcc\xb8\xf4\x4d\x65\xd2\x9c\xf6\x11\xba\x24\xfd\xbe\x3b\xb1\x54\x55\x43\x1c\xb1\x17\xea\x9d\xc0\x4d\x68\x35\x58\x27\xe4\x0c\x99\x7d\x68\xcb\x5b\x58\xeb\x12\x3d\x09\xca\xb1\xd2\x62\xbd\xcb\xd4\xc2\x37\x4e\xa6\xf8\xef\xd1\x7e\xfc\xf9\xc7\x18\xe2\xa7\xb8\x37\x26\x10\xf3\x38\xe9\xa2\xf0\xa4\xa4\xfc\xb7\x37\x78\x8a\x17\x09\xd6\xcd\xc7\x7d\x04\xa7\x3f\x1f\xe1\x73\x30\x00\x80\x64\x39\xe1\x2d\x26\x80\x40\xec\x9b\xa0\x23\x59\x25\x28\x7d\x65\x78\xe7\x3d\xb7\xab\x2a\x10\x66\x64\xdd\x1c\x89\x68\x41\x21\x90\x49\xa3\x2a\x12\x08\x2d\xea\x34\x6b\x8a\xbf\x3e\x0f\xaa\x93\xa7\xe5\x4d\x8b\x5a\x07\xaa\x55\xa0\x8c\xed\xdc\x45\x52\xaa\x91\x32\xfb\xdb\x87\xe0\x57\x6f\xd1\xbb\x11\x2e\xee\xb5\x8e\xda\x7b\xa2\x5b\x84\xae\x6b\x51\x16\x6e\xf0\xb2\x7b\xcb\xec\x9e\xca\x53\xde\x8c\xfa\x39\xf1\xef\xee\x0e\xb5\x72\x56\x67\xc3\x87\x14\xa1\xf3\x02\xed\x1d\x4b\x68\xb4\x40\x1d\x76\xba\x08\x7e\x91\x9c\xa8\x83\x5f\xda\x98\xe0\x71\xb1\x39\xd9\x3a\x1c\xed\xc8\x4e\x26\xf8\x87\xe2\xa4\x40\x05\x05\x72\xd1\x56\x9f\x86\xb4\xaa\x2f\x39\x61\x90\xc1\x32\x3a\x73\x20\x32\xad\x3c\x53\x81\x9b\x6e\x73\xde\xd1\xc9\x67\xc9\xa4\xeb\x64\xd8\xa1\xbf\xff\x5b\x29\x4d\x50\xab\x11\x2e\x8e\x9c\x7f\x6a\x49\x87\xcd\x6d\x16\x85\x4c\xf7\x3d\x1c\x0d\xce\xce\xce\x4e\x79\xd1\x02\x7d\x25\xef\x57\x2d\xf7\x14\xe7\xf9\xbe\x60\xa6\xaa\xc8\xfb\x02\xe0\xfa\xaa\x97\x91\xaf\x3a\x6e\x7d\xa1\xdb\xff\x6d\x22\x5d\x27\xe8\x83\x74\x23\x84\xcf\x03\x27\xea\x66\x56\x59\xdd\xa5\xfd\xd4\xbf\x1c\x84\x7d\xba\xea\xbf\x16\x77\x8b\xf3\xfb\x69\x47\xae\x81\xb4\xad\x6d\xbc\x00\x6e\x30\x27\xe9\x1a\x9c\x89\x1f\x1d\x6f\x4b\x74\xdb\x7c\xfb\x43\x79\x7f\x7d\x59\xe2\x6d\xce\xc7\x51\x3e\x77\x67\x37\xb7\xd9\xce\x99\x9f\x2b\xfd\x51\x98\x3d\xf8\x25\x63\x3b\xfa\xfc\xa8\xc4\xaf\xdd\xd7\x7c\x7b\x0b\xf4\xee\x9c\xac\xf1\xde\xe4\xf6\x17\x60\x77\x29\xf7\x43\xf7\x0c\xc8\x0d\xd5\x9e\xad\x74\xc5\xbc\xbe\x3a\x2c\xd1\xb6\x20\x9b\xef\x01\x00\x00\xff\xff\xa3\xb6\x2f\xc4\x8e\x06\x00\x00" -func generic_transferCdcBytes() ([]byte, error) { +func generic_transfer_with_pathsCdcBytes() ([]byte, error) { return bindataRead( - _generic_transferCdc, - "generic_transfer.cdc", + _generic_transfer_with_pathsCdc, + "generic_transfer_with_paths.cdc", ) } -func generic_transferCdc() (*asset, error) { - bytes, err := generic_transferCdcBytes() +func generic_transfer_with_pathsCdc() (*asset, error) { + bytes, err := generic_transfer_with_pathsCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "generic_transfer.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x5b, 0x68, 0xc3, 0xf5, 0x27, 0xf, 0xe0, 0x8f, 0x1b, 0xce, 0xc8, 0xc2, 0xc4, 0x41, 0x1e, 0x30, 0x28, 0x2c, 0xb5, 0x73, 0xbd, 0x65, 0xb8, 0x49, 0xd7, 0x4, 0x76, 0xba, 0xdc, 0x41, 0xee, 0x78}} + info := bindataFileInfo{name: "generic_transfer_with_paths.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x76, 0xb6, 0xe6, 0xe, 0x4f, 0x9f, 0xd0, 0x1, 0xaa, 0xaf, 0xa9, 0xcf, 0x67, 0x93, 0xb0, 0x92, 0x46, 0x35, 0xe5, 0xf0, 0xa6, 0xb6, 0x1, 0x1b, 0xa, 0x2a, 0x9c, 0x94, 0xcc, 0xac, 0x94, 0xd5}} return a, nil } -var _metadataSetup_account_from_vault_referenceCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x94\x41\x6f\x9b\x4c\x10\x86\xef\xfc\x8a\x91\x0f\xf9\x88\xe4\xc0\xdd\x72\x12\x25\xf9\x9a\x9e\x2a\x45\xa9\xdb\xfb\x18\x06\x58\x05\x76\xd1\xee\x60\x1a\x45\xfe\xef\xd5\xee\xc2\x1a\x90\xdd\x56\x6a\x39\x58\x68\x3c\xef\xec\x33\xef\xce\x20\x9a\x56\x69\x86\xe7\x4e\x96\x62\x5f\xd3\x4e\xbd\x91\x84\x42\xab\x06\x56\xb3\xd8\x2a\x3a\x97\xf9\x85\x18\x73\x64\xfc\x2e\xa8\x37\xe7\x64\xb3\x84\x50\xe3\x9c\x2c\x53\x92\x35\x66\x6c\xd2\x8e\x45\x2d\xf8\x3d\x5d\x68\xa3\x34\x4d\x61\x57\x09\x03\xac\x51\x1a\xcc\x58\x28\x09\xc2\x40\x5f\x21\x03\x4a\xc0\x2c\x53\x9d\x64\xe8\x55\x57\xe7\xa0\x3b\xe9\x14\xac\xc0\x10\x83\x60\x43\x75\x01\x5d\x6b\x03\x0d\x4a\x2c\x09\x8a\x81\x14\xd8\xa2\x9a\xc4\x57\x2f\x3a\xe9\x4a\x3b\x75\x67\xc8\xc0\xc1\x61\xb2\x82\x37\xa9\x7a\xe8\x2b\xd2\x34\x96\xb5\xf5\x2a\x82\x03\x76\x35\x3b\x81\x90\x60\x58\x69\x5b\x1e\x65\x6e\xd3\x32\x4d\xc8\xe4\xd2\xa8\x69\xf9\xdd\x27\x27\x51\x34\x69\x23\xc6\x3c\xd7\x64\xcc\x06\x1e\xfc\xcb\x1a\xda\x6e\x5f\x8b\xec\x05\xb9\xda\xc0\x4b\x78\xbf\x86\x8f\x28\x02\x00\x68\x35\xb5\xa8\x29\x36\xa2\x94\xa4\x37\xf0\xd0\x71\xf5\xe0\x0d\xb0\x39\x30\x3c\x69\x0a\x8f\x4a\x6b\xd5\x03\x82\xa6\x82\x34\xc9\xcc\xc1\x07\x6a\x87\x4b\x39\x28\xe9\x62\x2d\x1a\x43\x79\xf0\x12\x79\x1a\x3d\x31\x85\x03\x6a\x62\xd0\x64\x54\x7d\x20\xfd\x4a\x05\xdc\x42\x49\x3c\x80\x8c\x5d\x5d\x87\x6c\xfb\x24\x25\xf1\x13\xb6\xb8\x77\xb7\x1c\x9f\x6a\x2e\xd2\xf6\x8e\x7b\x7b\xf5\x31\x9b\x83\xe4\x75\x38\xec\x78\x17\xcf\x05\xf7\xf7\xd0\xa2\x14\x59\xbc\x7a\x72\x03\x20\x15\xc3\xfe\x37\xbd\xdb\x9b\x0d\xf8\xb0\xba\x8e\xa6\xc6\x7d\x33\xf6\xd6\x90\xe7\x62\x4d\xac\x05\x1d\xfc\x85\x3e\xef\x2c\x14\xcc\xdc\x28\xd8\xc5\x6e\x7f\xb1\x29\xd6\x02\x2f\x8d\x2d\xc1\xd8\xd2\x66\xea\xe4\x9c\xe5\x33\xf1\x78\xa0\x05\xff\x1f\x19\x3d\xbc\x5b\x1e\xf7\x73\xe2\x59\xe2\x04\xc5\xed\x00\x97\x4c\x83\xa3\x6f\x10\xaf\x76\x15\x8d\xe3\xe0\xfd\xc9\x45\x2e\xff\x63\x10\x4d\x5b\x53\x43\x92\x27\xd6\xe5\x23\xc2\xc2\xb5\x27\x3f\xee\x08\x92\xfa\xe9\xc0\x43\x67\x84\x2c\x5d\x01\xbf\x11\x9f\xec\x7f\x0e\x23\xac\x1c\x08\x69\x44\x4e\xcb\x4e\x67\xfd\xd0\x49\xb6\xbd\x99\xf4\x91\x2c\xab\xc6\x73\xae\xaf\x78\x20\x10\x3c\xde\xff\x30\xe0\x21\xc3\xef\x51\x62\xf0\x40\xf1\xf6\xe6\x74\xc8\x1a\x58\x6d\xa6\x26\x26\xc3\x7a\xfb\x89\x3d\xdb\xb9\x1f\x69\xc8\xc2\x90\x43\xa1\xf4\xc4\x3a\xfa\xd1\xaa\x60\x86\xa6\x8c\x84\x9d\x3e\x21\x99\x74\x81\x19\x2d\x99\x6a\x21\xdf\xb6\x57\x1f\xb3\x71\x4a\x5e\x07\xd9\xf1\x2e\x9e\x6d\xc1\x94\x74\x2c\x6d\x51\xd7\xb3\x2c\x46\x5d\x12\x5f\xec\x2b\xe4\xfe\x8b\x06\xf7\x58\xa3\xdd\x1d\xfb\x39\x0c\xab\x16\x9a\x35\x7f\xd4\xed\xa3\xaf\xb1\x86\x8b\xdf\x82\x8b\x26\x34\x83\xe2\xaf\x4d\x38\x46\xc7\x08\x7e\x06\x00\x00\xff\xff\x05\xda\xfa\x5c\x2f\x07\x00\x00" +var _metadataScriptsGet_token_metadataCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x92\x51\x6b\xab\x40\x10\x85\xdf\xfd\x15\x73\x7d\xb8\x28\x5c\xfc\x01\x12\x13\x42\x6e\xf3\x56\x28\x21\xf4\x7d\xb2\x8e\xc9\xd2\x75\x57\x66\x47\xd3\x52\xfa\xdf\xcb\xba\x9a\xa6\x85\xa4\x3e\xa8\x3b\x1c\xcf\x7e\xe7\xb8\xba\xed\x1c\x0b\xa4\x0f\xaf\xd8\x76\x86\xf6\xee\x85\x6c\x9a\xcc\xd3\x6d\x6f\x8f\xfa\x30\x8d\x1f\x49\xb0\x46\xc1\x67\x4d\x67\x7f\x43\xf3\x35\x0e\xaa\x1d\x79\x67\x06\xe2\x34\x49\x50\x29\xf2\x3e\x43\x63\x72\x68\x7a\x0b\x2d\x6a\x9b\x61\x5d\x33\x79\x5f\xc2\x3a\xbe\xe4\x25\xdc\xde\xb1\xd8\xee\xc3\x13\xde\x13\x00\x00\x43\x02\xa8\x94\xeb\xad\x40\x05\x47\x92\x75\x5c\xcc\x9e\x79\x72\x91\x0d\xd8\x1b\xf9\x8f\x82\x50\xc1\x75\xcc\x82\x23\xde\xc6\x59\x61\x54\x12\xdc\xb3\x30\xeb\x59\xd1\xfe\xad\xa3\x12\xac\x36\xff\x60\xd0\x74\x8e\xcb\x70\x5f\xdc\x27\x9c\xf7\x5a\x66\x79\x0e\xe8\xff\xfc\x12\x68\x96\xaf\x46\xda\x70\xad\x56\xd0\xa1\xd5\x2a\x4b\x37\xae\x37\x35\x58\x27\x21\x5e\x4c\x01\xe1\xe3\x11\x08\x1a\xc7\x20\x27\x02\x35\xd1\xa7\x3f\x13\xef\xa8\x81\x6a\xee\xa8\x50\xd8\xe1\x41\x1b\x2d\x9a\x7c\x71\x70\xcc\xee\xbc\xf8\xfb\xad\x8d\x91\x65\x99\x5d\xda\x2a\xda\x09\xf6\x09\xe5\x94\xdf\xe5\x8b\x7e\x80\xc0\xd4\x10\x93\x55\x04\xe2\x46\xba\x48\xcd\xf3\x39\xb8\x62\x6c\xc6\xbe\xa1\xba\x57\xd0\x91\x24\xfe\xf4\x6c\xb8\x3a\x4d\xe5\x25\xdf\x64\xc7\x24\x3d\xdb\xc9\x31\xf9\x48\x3e\x03\x00\x00\xff\xff\xc9\x37\x5b\x08\xd4\x02\x00\x00" -func metadataSetup_account_from_vault_referenceCdcBytes() ([]byte, error) { +func metadataScriptsGet_token_metadataCdcBytes() ([]byte, error) { return bindataRead( - _metadataSetup_account_from_vault_referenceCdc, - "metadata/setup_account_from_vault_reference.cdc", + _metadataScriptsGet_token_metadataCdc, + "metadata/scripts/get_token_metadata.cdc", ) } -func metadataSetup_account_from_vault_referenceCdc() (*asset, error) { - bytes, err := metadataSetup_account_from_vault_referenceCdcBytes() +func metadataScriptsGet_token_metadataCdc() (*asset, error) { + bytes, err := metadataScriptsGet_token_metadataCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "metadata/setup_account_from_vault_reference.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x11, 0x57, 0x6c, 0xcd, 0x92, 0xe8, 0xa, 0x42, 0xf7, 0x79, 0x7a, 0x78, 0x52, 0x41, 0x12, 0xb9, 0x60, 0xec, 0x5a, 0xef, 0x2, 0x92, 0x3f, 0x63, 0x1e, 0x3a, 0x36, 0x98, 0xa, 0x43, 0xab, 0x81}} + info := bindataFileInfo{name: "metadata/scripts/get_token_metadata.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdc, 0xfc, 0x4e, 0xb4, 0x47, 0xb8, 0x1e, 0xb9, 0x13, 0x51, 0x56, 0xbe, 0x7c, 0x8b, 0x10, 0x98, 0x7c, 0xa, 0xb3, 0x49, 0x78, 0x0, 0x61, 0x80, 0xd6, 0x16, 0x9d, 0x83, 0x3f, 0xf7, 0xcd, 0xdb}} return a, nil } -var _mint_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x54\xcb\x6e\xdb\x40\x0c\xbc\xeb\x2b\x08\x1d\x02\x19\x4d\xe4\x4b\xd1\x83\x11\x27\x70\xd2\xa6\xa7\x16\x41\x1e\xbd\xaf\x24\xca\xde\x56\xda\x15\xb8\x54\x1c\x23\xc8\xbf\x17\xfb\x92\x25\x3b\x8e\x2f\x06\x56\xc3\x21\x39\x1c\x52\xb6\x9d\x26\x86\xbb\x5e\xad\x65\xd1\xe0\x93\xfe\x87\x0a\x6a\xd2\x2d\xa4\x93\xb7\x34\x09\xc8\x1f\xaf\xa2\xed\xa6\xc0\xf1\x53\x9a\x24\xf3\xf9\x1c\x9e\x36\xd2\x00\x93\x50\x46\x94\x2c\xb5\x02\x69\x60\xbb\x11\x0c\xbc\x41\x68\xa5\x62\x24\x58\x95\xa5\xee\x15\x43\x6f\xd0\x00\x6b\xf7\x0c\x0a\xb7\xc0\x96\xc8\x04\x1e\xdc\x41\x47\xfa\x45\x56\xe8\x62\x09\x4b\xd9\x49\x54\x0c\xa2\xaa\x08\x8d\x01\xa1\x2a\x10\xad\x63\x0a\x24\xe7\xee\xcd\xa2\x47\x4c\x82\xd0\x17\x54\x23\x11\x56\x16\x6b\x11\x03\x4b\x6d\x4b\xb2\xd1\x52\xad\x93\x64\x54\x7a\x36\xa4\x5c\xc0\xca\xa3\xcf\x43\xc2\x05\x3c\xdf\xc9\xd7\x6f\x5f\x67\xf0\x96\x24\x00\x00\x36\xd1\x03\xd6\x48\xa8\x4a\x8c\x29\x82\x3c\xe0\x25\x5b\x55\xad\x54\xf0\x80\x46\xf7\x54\x22\xe8\xe2\x2f\x96\xec\x82\x1b\x64\x5f\xb0\x83\x2c\xe0\x6c\xac\x6b\xee\x1e\xa5\x61\x12\xac\xe9\x93\x6c\x71\x6a\x21\xdd\x03\x96\x28\x5f\x90\x40\xd7\x53\xfd\xa6\x29\x23\x6c\x01\x67\x6f\x93\xb9\xe7\xf1\xcb\xfb\x3e\xe7\x93\x53\x96\x45\x03\xa6\xef\xba\x66\xe7\xb8\x9d\xd2\x50\x60\xad\xc9\x4f\xaa\xe8\x49\x0d\x49\x3c\xf0\xc6\x7d\x8d\xaa\x79\xc2\x8e\xb0\x13\x84\x99\x91\x6b\x65\xf3\xaf\x7a\xde\x04\x67\x58\x59\x21\xfc\x0c\x36\x75\x3e\x66\x81\xe5\xc4\x8a\xb9\x2b\xe8\xd1\x01\x92\x21\x6a\x3e\x87\x1b\x4d\xa4\xb7\x20\x80\x0e\x95\x12\x6e\x12\xa3\x01\x0c\x79\xf6\x53\x80\x25\xf8\xc2\xf2\xc2\xf1\x5c\x7e\x32\x94\xab\xcc\xae\xc3\x02\x8e\x11\x8f\xac\x49\xac\xf1\x5e\xf0\x66\x36\x64\xb2\xbf\xeb\x6b\xe8\x84\x92\x65\x96\x3e\xba\x2c\x76\x4d\x94\xe6\xbd\x77\x7d\x91\xe9\x6c\xd2\xd2\x4f\xf4\x08\x11\x16\xe8\x70\xb4\xce\xfe\xc5\xa9\xbe\x25\x59\xa4\x9b\xe9\x07\x5d\x0f\x7e\x59\xc2\x1a\x39\x0c\x62\xbf\x02\xd3\xf2\xf3\x35\xf2\xad\xe8\x44\x21\x1b\xc9\xbb\x6c\xd2\x78\x24\xba\xef\x8b\x46\x96\xc7\xad\x0f\x82\x9e\xf2\xdb\x55\x76\x4a\xab\x67\x25\xac\xc1\x59\xc7\x26\x63\x3f\xfb\x5e\x53\x1f\x1b\x4c\x8b\xaf\x58\xf6\x8c\x71\x4b\x83\x8c\xb7\x84\x82\x11\x44\xbc\x47\x56\x35\x77\x83\xc2\xd5\x88\x50\xeb\xdf\x00\xb9\xbc\x38\x34\x48\x5e\x3a\x96\xdf\xb8\xfd\xe5\x20\x99\x68\x1a\xbd\xc5\x6a\x15\x0e\x84\x3f\x14\xb3\x63\xb2\xea\x8f\xe8\x1b\xb6\x8c\x9e\x3b\xb7\x7f\x4e\x02\x93\x89\x83\xe0\x71\xd5\xdf\xb1\xd3\x46\x3a\x03\xb4\xd1\xc9\xae\x7f\xfc\x7c\xa0\x79\xe5\x03\x83\x49\x2f\x2f\x46\x55\x8c\x32\x54\x68\x98\xf4\x2e\x14\x35\x16\xb1\xd3\x86\x47\x0b\x79\x6a\xf9\x60\xb9\xfc\x60\x59\xbf\x0c\x17\x33\x3d\xba\x1e\x6d\x6f\x18\x0a\x04\xa9\xac\x96\x06\x2b\x28\x76\xde\xdf\x2e\x24\x0d\x45\xbc\xff\x0f\x00\x00\xff\xff\xee\xc5\x65\x61\xab\x06\x00\x00" +var _metadataScriptsGet_vault_dataCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x92\x5f\x6b\xea\x40\x10\xc5\xdf\xf3\x29\xce\xcd\xc3\x25\x81\x4b\x3e\x80\xf8\x07\xf1\xd6\xb7\x42\x11\xf1\x7d\xdc\x4c\x74\xe9\x66\x37\xec\x4e\xb4\xa5\xf4\xbb\x97\x4d\x8c\xda\x52\xc5\x3c\x84\xec\x61\x66\xe7\x77\x4e\x46\xd7\x8d\xf3\x82\xf4\xe9\x8d\xea\xc6\xf0\xda\xbd\xb2\x4d\x93\x41\x5d\xb6\x76\xa7\xb7\x27\xf9\x99\x85\x4a\x12\xda\x68\x3e\x86\x1b\x35\x17\x39\x56\xad\x38\x38\x73\x60\x9f\x26\x09\x29\xc5\x21\x64\x64\x4c\x8e\xaa\xb5\xa8\x49\xdb\x8c\xca\xd2\x73\x08\x23\xcc\xfb\x8f\x7c\x84\xdb\x13\x8b\xe5\x7a\x43\xad\x91\xff\x24\x84\x8f\x04\x00\x0c\x0b\x48\x29\xd7\x5a\xc1\x04\x3b\x96\x79\x7f\x18\x2e\xce\x93\x73\xd9\xe1\xdc\x3a\xc1\xb5\xd7\xc2\xf7\x8c\x0b\x67\xc5\x93\x92\x38\x2a\x8b\x5a\xeb\x15\xaf\xdf\x1b\x1e\xc1\x6a\xf3\x0f\x07\xcd\xc7\xfe\x18\xdf\xe3\xc7\x30\xa7\x59\x9e\x83\xc2\x9f\x07\x5d\xcd\x3a\xda\xf8\xcc\x66\x68\xc8\x6a\x95\xa5\x0b\xd7\x9a\x12\xd6\x49\xb4\xd7\xbb\x40\x6c\xee\x80\x50\x39\x0f\xd9\x33\xd4\x89\x3e\xfd\xe9\x78\xc5\x15\x26\x43\x46\x85\xa2\x86\xb6\xda\x68\xd1\x1c\x8a\xad\xf3\xde\x1d\xc7\x7f\xbf\xa5\xd1\xb1\x4c\xb3\x73\x5a\x45\x7d\x82\x7d\x21\xd9\xe7\x77\xf9\xfa\xfb\x40\xf0\x5c\xb1\x67\xab\x18\xe2\x3a\xba\x9e\xda\x0f\xcb\x70\xe3\xaf\xdc\xc9\x68\xc7\x72\x15\x53\x36\x38\xfb\x8d\xa7\xeb\x46\xe9\x38\x74\x50\x3a\x5a\xab\xd9\x0a\xae\xb7\x27\x66\x37\x60\x78\x96\xd6\xdb\x0b\x49\xf2\x99\x7c\x05\x00\x00\xff\xff\x3b\x31\x07\x10\x14\x03\x00\x00" -func mint_tokensCdcBytes() ([]byte, error) { +func metadataScriptsGet_vault_dataCdcBytes() ([]byte, error) { return bindataRead( - _mint_tokensCdc, - "mint_tokens.cdc", + _metadataScriptsGet_vault_dataCdc, + "metadata/scripts/get_vault_data.cdc", ) } -func mint_tokensCdc() (*asset, error) { - bytes, err := mint_tokensCdcBytes() +func metadataScriptsGet_vault_dataCdc() (*asset, error) { + bytes, err := metadataScriptsGet_vault_dataCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "mint_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4a, 0xc0, 0xaf, 0x31, 0xa, 0x7f, 0x60, 0x76, 0xe3, 0xd, 0xeb, 0xc7, 0x4, 0x8b, 0x85, 0x48, 0xf4, 0x4a, 0x4c, 0xf3, 0xcb, 0x7e, 0xa7, 0x4c, 0xe0, 0xd8, 0x2b, 0x64, 0xc0, 0xdf, 0xa0, 0x9f}} + info := bindataFileInfo{name: "metadata/scripts/get_vault_data.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xac, 0x3d, 0xd, 0xf, 0x6f, 0x5f, 0xca, 0x47, 0x3d, 0x78, 0x5f, 0xb, 0xa, 0x53, 0x78, 0xe, 0x43, 0x6b, 0x95, 0xa2, 0x5a, 0x6d, 0x68, 0xae, 0xde, 0x44, 0x79, 0x1, 0xf1, 0xc0, 0x85, 0x5e}} return a, nil } -var _privateforwarderCreate_account_private_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x53\x4d\x6f\xdb\x30\x0c\xbd\xfb\x57\x70\x39\x6c\x36\xd0\xda\xf7\x22\x1d\x50\x14\xcd\x69\x28\x82\xb5\xdb\x9d\x71\x98\x58\x88\x62\x09\x32\x6d\x37\x08\xf2\xdf\x07\xf9\x43\x95\x9c\x1a\x2b\xea\x4b\x1b\xea\xf1\xe9\xf1\xf1\x49\x1c\xb5\x32\x0c\xab\xba\xdc\x8b\x8d\xa4\x57\x75\xa0\x12\x76\x46\x1d\x61\x11\xd4\x16\xd1\x80\x7c\x7a\xc3\xa3\x0e\x81\x7e\xc9\xe1\xd6\x46\x34\xc8\xf4\x9b\x72\x12\x0d\x99\x95\x32\x2d\x9a\x2d\x99\xa1\x67\xee\x78\x11\x45\x59\x96\xc1\x6b\x21\x2a\x60\x83\x65\x85\x39\x0b\x55\x82\xa8\xa0\xae\x68\x0b\xac\x20\x37\x84\x4c\x80\xb6\x60\x7e\x54\xb0\x92\xaa\x05\xcc\x73\x55\x97\x0c\xad\xe0\x02\x10\x74\x4f\x0f\xbb\x91\x37\x8a\x7c\xb6\x73\x14\x01\x00\xd8\x9b\x9e\xa9\x85\x87\xa1\x99\x0b\xb4\x0c\x52\x42\xa1\xe4\x16\xb8\xf0\x09\x6c\x83\x24\x86\x92\xda\x01\x7f\x07\x0f\x35\x17\xc3\x8f\x9e\x51\x1b\xd2\x68\x28\xd6\x78\x22\x13\x9c\x27\x70\xee\x10\xf6\xab\x48\xee\xd2\x77\x1e\xb8\xf7\x81\x63\x6f\xf7\x27\xe9\x7a\x2e\x3d\x39\xbd\x51\x5e\x33\x8d\xea\xfb\x09\xe0\x05\x1b\x6b\x86\xa1\x7d\x2d\xd1\x40\x83\xb5\x64\x6b\x93\x55\x5f\x92\x73\x66\xee\xf2\xb4\xc2\x86\xe2\xe5\xad\xbf\xc4\xb4\xb7\xf8\xe9\xa8\xf9\xf4\xd7\xf2\xc5\xc9\x8d\xeb\xb7\x1f\xab\xbb\x20\x08\x69\x87\x7a\x61\x65\x70\x4f\x6b\xe4\xc2\xa1\x93\x40\xeb\xe3\xb8\xba\x71\x3f\x66\xd8\xbf\x03\x59\x87\xc7\xe2\x23\x6a\xdc\x08\x29\xf8\x04\xf7\x57\xb2\xa5\x28\x0f\xcb\xef\xe7\x20\xa4\xe9\x18\xa7\xcb\xcf\x38\xd0\x9b\x0d\xf7\x65\xe4\x89\x1e\xc1\x93\xd1\xd0\xec\x89\x3f\x3d\xde\xb7\x60\xbe\x3f\x15\x75\xbe\x4f\xc7\x0b\x62\x7b\x9d\x4d\x7f\x78\x57\x85\xe5\xed\xec\x23\x1a\x16\xf4\x4c\xad\x2b\xc5\x86\x72\xa1\x05\xd9\x58\x5e\x1b\x98\x5c\x47\xc6\xd7\xf9\x7e\x29\x2b\xf7\x94\xaa\x7e\xde\xff\x05\xc7\xf5\xde\x74\xb1\x98\x95\x3c\x39\xf0\xdc\x0c\xc5\xfd\x12\xe5\x21\x7c\x7a\x9d\x28\xa7\x55\xfb\xfe\x7f\x9c\x8a\x59\x0d\xee\xbf\x49\x3e\x3e\x2b\x7a\x5d\x6f\xa4\xc8\xad\xe6\x8f\x43\xf3\x85\xe1\xa7\x2f\xe5\x12\x5d\xfe\x05\x00\x00\xff\xff\x94\xdc\x66\x5c\x94\x05\x00\x00" +var _metadataScriptsGet_vault_displayCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\x51\x6b\xc2\x30\x10\xc7\xdf\xfb\x29\x6e\x7d\x18\x2d\x8c\x7e\x00\xb1\x8a\xe8\x7c\x1b\x0c\x11\xdf\xcf\xf4\xaa\x61\x69\x52\x92\xab\x4e\xc6\xbe\xfb\x48\x63\xaa\x1b\xb3\x7d\x28\xc9\xf1\x4f\xee\xf7\xff\xe7\x64\xd3\x1a\xcb\x90\xbe\x7e\x62\xd3\x2a\xda\x9a\x0f\xd2\x69\x12\xab\xeb\x4e\x1f\xe4\xfe\x5a\x7e\x23\xc6\x0a\x19\x77\x92\xce\xee\x81\xe6\x56\xf6\xaa\x0d\x39\xa3\x4e\x64\xd3\x24\x41\x21\xc8\xb9\x0c\x95\xca\xa1\xee\x34\x34\x28\x75\x86\x55\x65\xc9\xb9\x09\x2c\xc2\x22\x9f\xc0\xe3\x8e\xc5\x7a\xbb\x92\xae\x55\x78\x81\xaf\x04\x00\x40\x11\x03\x0a\x61\x3a\xcd\x50\xc2\x81\x78\x11\x36\xf1\xda\x3c\x19\x64\x27\xec\x14\xaf\x90\x11\x4a\xb8\x77\x5a\xd8\x40\xb8\x34\x9a\x2d\x0a\xf6\x8d\x32\x5f\xeb\xac\xa0\xed\xa5\xa5\x09\x68\xa9\x5e\xe0\x24\xe9\x1c\xb6\xfe\x3f\x1d\x85\xdc\xc5\x5e\xb3\x2c\xcf\x01\xdd\xd3\xb8\xa7\x41\x3e\xef\x69\xfd\x37\x9f\x43\x8b\x5a\x8a\x2c\x5d\x9a\x4e\x55\xa0\x0d\x7b\x7b\xc1\x05\xf8\xc3\x3d\x10\xd4\xc6\x02\x1f\x09\xc4\x95\x3e\xfd\xeb\x78\x43\x35\x94\x31\xa3\x42\x60\x8b\x7b\xa9\x24\x4b\x72\xc5\xde\x58\x6b\xce\xd3\xe7\x5f\x69\xf4\x2c\xb3\x6c\x48\xab\x68\xae\xb0\xef\xc8\xc7\x7c\x94\x2f\xdc\x07\x08\x96\x6a\xb2\xa4\x05\x01\x9b\x9e\x2e\x50\xdb\x38\x0a\x77\x8c\x35\xc7\x07\x2d\xc7\x32\x3a\x10\x0f\x4f\x9f\x45\x5f\xff\xd1\xf4\x67\xa1\x32\xe4\x7a\x24\xe9\x8d\x35\xa4\x19\x6e\x93\xe3\x73\x8b\x08\x96\xb8\xb3\xfa\x46\x91\x7c\x27\x3f\x01\x00\x00\xff\xff\xbd\x1a\x99\xeb\x0e\x03\x00\x00" -func privateforwarderCreate_account_private_forwarderCdcBytes() ([]byte, error) { +func metadataScriptsGet_vault_displayCdcBytes() ([]byte, error) { return bindataRead( - _privateforwarderCreate_account_private_forwarderCdc, - "privateForwarder/create_account_private_forwarder.cdc", + _metadataScriptsGet_vault_displayCdc, + "metadata/scripts/get_vault_display.cdc", ) } -func privateforwarderCreate_account_private_forwarderCdc() (*asset, error) { - bytes, err := privateforwarderCreate_account_private_forwarderCdcBytes() +func metadataScriptsGet_vault_displayCdc() (*asset, error) { + bytes, err := metadataScriptsGet_vault_displayCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "privateForwarder/create_account_private_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdc, 0xae, 0x85, 0xaa, 0x7c, 0xb6, 0x13, 0x58, 0x3, 0x26, 0xd6, 0x65, 0xed, 0xe9, 0x24, 0xa8, 0x29, 0xe3, 0x4f, 0x83, 0x97, 0x77, 0xe9, 0x6f, 0xf0, 0x1b, 0x90, 0x3b, 0xc8, 0xb, 0xb3, 0x96}} + info := bindataFileInfo{name: "metadata/scripts/get_vault_display.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x78, 0x95, 0x2f, 0x6d, 0x3e, 0x77, 0x8, 0x66, 0x9b, 0x5d, 0x2d, 0xd3, 0x7e, 0xb4, 0xb0, 0x7b, 0xa4, 0xd4, 0x2c, 0x68, 0xc3, 0x3d, 0x31, 0xea, 0x37, 0x8c, 0xaf, 0x8a, 0x30, 0xd6, 0xc3, 0x8b}} return a, nil } -var _privateforwarderCreate_private_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x52\xcd\x8a\xa3\x40\x10\xbe\xf7\x53\x14\x39\xec\x1a\x48\xf4\x2e\xd9\x85\xb0\x6c\x8e\x43\x98\x09\x73\x2f\x4d\x8d\x36\x31\xdd\x52\x96\x66\x82\xe4\xdd\x87\xf6\x0f\x4d\x22\x0c\xd3\x07\x69\xaa\xbe\x9f\xae\xaf\xd4\xe7\xdc\xb2\xc0\xae\x34\x89\x8e\x32\x3a\xd8\x13\x19\xf8\x60\x7b\x86\xc5\xa4\xb6\x50\x1d\xf2\xff\x27\x9e\xf3\x29\x70\x5c\x1a\x70\x7b\xd6\x15\x0a\xbd\x52\x4c\xba\x22\xde\x59\xbe\x20\x1f\x89\x3b\xce\x5c\x7b\xa1\x54\x10\xc0\x21\xd5\x05\x08\xa3\x29\x30\x16\x6d\x0d\xc4\x4c\x28\x54\x00\x82\xa1\x0b\xe4\x2d\x19\xb8\x63\x83\x36\x80\x06\x30\x8e\x6d\x69\x04\x24\x45\x01\x27\x73\xb4\x54\x98\xdf\x02\x98\x31\xe1\xf1\x0a\x29\x56\x04\xf8\x48\xb7\xec\xaa\x65\x94\xe9\x18\xa4\x19\xac\x6f\x39\x95\xa8\x94\x46\xe9\x5e\xe6\x1d\xcb\x4c\x94\x1a\x3f\xb3\x56\x0a\x00\x20\x67\xca\x91\xc9\x2b\x74\x62\x88\x43\xd8\x96\x92\x6e\xdb\xc7\x2d\xa1\x6e\x20\xee\xf4\x26\xff\x30\xc7\x48\x67\x5a\xae\xf0\x07\x5a\x8e\x9f\x69\x73\xda\xfc\x1a\x27\xeb\x37\x7e\xf5\x64\x2b\x7e\x9f\xdf\xed\xaf\x37\xc8\xba\x13\x74\x33\x06\x34\x52\xe8\xc1\xab\x09\x54\x90\x13\x92\x10\x1e\xbd\xde\xc4\x32\x26\xb4\x47\x49\x07\xc6\x52\x0d\xd7\x8c\x04\x2a\x87\x83\xcd\x7a\x76\xdd\x7e\xbb\xb9\x17\xba\x0c\x25\x8f\x29\xd6\xb9\x26\x23\xe1\x93\x08\x46\x06\x5d\x14\x05\x56\xe4\x6d\xd6\x8d\xd5\x0a\xc4\x86\xf3\x66\x77\x8d\xd1\x00\x8f\xb2\x6d\xc2\xf5\xac\xd6\x70\xbb\xcf\xf6\xbb\xee\xfb\xe6\x87\x72\xe6\xcf\x03\xff\xc1\x14\xa3\x35\xb8\xef\x4d\xdd\xd4\x57\x00\x00\x00\xff\xff\x21\x07\xb3\xdd\xc1\x03\x00\x00" +var _metadataScriptsGet_vault_supply_viewCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x52\xc1\x8e\xd3\x30\x10\xbd\xfb\x2b\xde\xf6\x00\x89\x84\xd2\x0b\xe2\x50\x6d\xb6\x5a\x2d\x94\x13\x12\x5a\xca\xde\xa7\xce\x64\xd7\xc2\xb1\x23\x7b\xd2\x6e\x85\xf8\x77\xe4\xb8\x69\x0a\xd2\xb2\xf4\x50\xd9\x93\xf1\x9b\xf7\xde\x3c\xd3\xf5\x3e\x08\x16\x9f\x9e\xa9\xeb\x2d\x6f\xfd\x0f\x76\x0b\x35\x55\x37\x83\x7b\x34\xbb\x53\xf9\x0b\x0b\x35\x24\xf4\x60\xf8\x10\x5f\xe8\x99\xcb\xa9\xeb\x9e\xa3\xb7\x7b\x0e\x0b\xa5\x96\xcb\x25\x3e\xb3\x44\xc8\x13\x43\xbc\x90\x45\x1c\xfa\xde\x1e\xe1\xdb\xb1\xb6\xa7\xc1\xca\xdb\x08\x49\x30\x68\x4c\x60\x2d\xf6\x88\x36\xf8\x6e\xfe\xae\x14\x69\xcd\x31\x16\x64\x6d\x89\x76\x70\xe8\xc8\xb8\x82\x9a\x26\x70\x8c\x2b\xdc\xe6\x43\xb9\xc2\xf7\x8d\x79\xfe\xf0\x1e\x3f\x15\x00\x58\x16\x90\xd6\x7e\x70\x82\x1a\x8f\x2c\xb7\xf9\x32\x3d\x2c\xd5\xb9\x6d\x1c\xf3\x91\x84\x50\xe3\xd2\x93\x2a\x64\x2d\x77\xde\x49\x20\x2d\x49\x5e\x91\x6a\x43\xd0\xbc\x3d\xf6\xbc\x82\x33\xf6\x1d\xf6\x86\x0f\xf9\x9a\xfe\xaf\x5f\x36\xb0\xda\x6c\x1f\xa6\x59\x37\x45\x59\x82\xe2\x15\xfe\xaf\x7d\x3d\xb2\x4d\xbf\xf5\x1a\x3d\x39\xa3\x8b\xc5\x9d\x1f\x6c\x03\xe7\x25\xc9\xcb\x2a\x90\x1e\x8f\x84\xd0\xfa\x30\x9a\xa8\x4f\xec\x17\x7f\x2b\xbe\xe7\x16\xf5\xe4\x51\xa5\xa9\xa7\x9d\xb1\x46\x0c\xc7\x6a\xe7\x43\xf0\x87\xeb\x37\x7f\xb8\x31\x72\xb9\x29\xce\x6e\x55\xdd\x89\xec\x57\x92\xa7\xf2\x9f\xfc\x32\x1e\x08\x81\x5b\x0e\xec\x74\xca\xc3\xbc\x62\x84\x29\x34\x17\x1c\x5b\xf9\x96\xc3\x52\x9f\xe9\x4e\x0b\x19\x17\xf1\x9a\xd7\xdb\x14\xb8\x0c\x91\xbc\xbe\x9a\x91\x73\x08\x53\x17\xea\x79\xcc\x2b\xbb\xb8\x80\xcb\x48\x81\x65\x08\xee\x02\xac\xca\x47\xf5\x4b\xfd\x0e\x00\x00\xff\xff\x3c\x7c\x95\xe9\x61\x03\x00\x00" -func privateforwarderCreate_private_forwarderCdcBytes() ([]byte, error) { +func metadataScriptsGet_vault_supply_viewCdcBytes() ([]byte, error) { return bindataRead( - _privateforwarderCreate_private_forwarderCdc, - "privateForwarder/create_private_forwarder.cdc", + _metadataScriptsGet_vault_supply_viewCdc, + "metadata/scripts/get_vault_supply_view.cdc", ) } -func privateforwarderCreate_private_forwarderCdc() (*asset, error) { - bytes, err := privateforwarderCreate_private_forwarderCdcBytes() +func metadataScriptsGet_vault_supply_viewCdc() (*asset, error) { + bytes, err := metadataScriptsGet_vault_supply_viewCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "privateForwarder/create_private_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc9, 0x4e, 0xba, 0x8, 0xf3, 0x78, 0x7c, 0xcc, 0x89, 0x26, 0x9c, 0x27, 0xee, 0xbf, 0x6c, 0xac, 0xf, 0x4e, 0xa6, 0x77, 0x19, 0x5b, 0x1a, 0x91, 0xd0, 0xda, 0xff, 0xa5, 0x82, 0x37, 0x2a, 0xc6}} + info := bindataFileInfo{name: "metadata/scripts/get_vault_supply_view.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd4, 0x58, 0x26, 0x46, 0x13, 0x4a, 0x14, 0x30, 0x81, 0x47, 0x51, 0x27, 0xa, 0x1b, 0xb8, 0xda, 0x1a, 0x8e, 0x71, 0x73, 0x2, 0xb6, 0x49, 0x3e, 0x82, 0x6b, 0x6b, 0xe7, 0x57, 0x52, 0xd6, 0x81}} return a, nil } -var _privateforwarderDeploy_forwarder_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x8f\x4d\x4b\x03\x31\x10\x86\xef\xf9\x15\x73\xdc\x42\xe8\x5e\x65\x6f\x05\x11\xbc\x48\xa1\x7a\x12\x0f\x63\x32\xee\x0e\xb6\x33\x61\x32\x4b\x11\xe9\x7f\x97\xed\x17\xab\x5e\x9a\x43\x48\x78\x9f\x64\xde\xa7\x6d\x5b\xb8\xa7\xb2\xd5\xaf\x0a\x3e\x10\x3c\xeb\x27\xc9\x83\xda\x1e\x2d\xb3\xf4\x90\x54\xdc\x30\x39\xec\xd9\x87\x23\x51\x0b\x25\xfe\x60\xca\xc0\xc2\x0e\x05\x0d\x77\xe4\x64\x35\x04\x37\x94\x8a\xc9\x59\xa5\xb9\x3c\x7c\xc2\x1d\x75\xb0\x71\x63\xe9\x63\x80\xd9\x4a\x9a\xa9\x83\xd7\x97\x47\xf1\xbb\xb7\xdf\x51\x25\xc9\x64\x1b\x57\xc3\x9e\xd6\xe8\xc3\xf4\xc3\xf5\xf2\x87\xbd\x89\x2a\xe3\xfb\x96\xd3\x09\x5a\x5f\xcf\x0b\xf8\x0e\x01\xa0\x18\x15\x34\x6a\x2a\xf7\x42\xd6\xc1\x6a\xf4\x61\x95\x92\x8e\xe2\x67\x02\xe0\x94\x2d\x2f\x5a\x75\x89\x39\x37\x72\x94\x9b\xab\xc6\xb3\xd6\xb4\xc7\xff\x1e\x71\x5e\x37\xce\x5a\x2d\xa6\x29\x87\x70\x08\x10\x7e\x02\x00\x00\xff\xff\xf7\x8a\xb2\xb8\x93\x01\x00\x00" +var _metadataScriptsGet_viewsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x91\x41\x6b\x1b\x31\x10\x85\xef\xfa\x15\xaf\x7b\x28\xbb\x50\xd6\x77\x13\xc7\xa4\x69\x73\x2b\x94\x62\x72\x29\x3d\x8c\xb5\x63\x5b\x44\x2b\x2d\x9a\x91\x93\x50\xfa\xdf\x8b\xb4\xb6\x5b\x1f\x52\xba\x87\x45\x1a\xde\xbc\xf9\xe6\x69\xb1\xc0\xe6\xe0\x04\x62\x93\x9b\x14\xf6\xc0\xf6\x49\xa0\x07\x86\xe4\x69\x8a\x49\x79\xc0\xd1\xf1\xb3\x60\x97\xe2\x88\xcf\x2f\x34\x4e\x9e\x37\xf1\x89\x83\x59\x2c\x40\x89\xab\x98\x5f\x26\xb6\x45\x1b\x03\x4b\x3f\x5b\x3a\xc1\xc8\x89\xfd\x2b\xb2\xf0\x00\x17\xa0\x2c\xea\xc2\xbe\x37\xc6\x8d\xc5\x1b\xcd\x17\x56\x1a\x48\xe9\xb1\x8c\x68\x2e\xe5\xbf\xc7\xfc\xa9\x3e\xe4\xb0\x77\xdb\x53\xf9\x8d\xce\x2b\x4d\x63\x0c\x59\xcb\x22\x2d\x79\xdf\x61\x97\x03\x46\x72\xa1\xa5\x61\x48\x2c\xb2\xc4\xdd\x7c\xe8\x96\xf8\xbe\x79\x9d\xf8\x07\x7e\x1a\x00\xf0\xac\x20\x6b\x63\x0e\x8a\x15\xf6\xac\x77\xf3\xe5\xdc\xd8\x99\x8b\xec\x48\xd9\xeb\x27\x52\xc2\xea\x2a\x9c\x3e\xb1\x44\x7f\xe4\xfb\x18\x34\x91\xd5\x82\xd9\x96\x5a\x4e\x96\xcb\xac\x25\x82\xf3\x1f\x6a\xb6\xf3\xb5\xfc\x6f\xde\x5e\xb1\x7f\xd8\x3c\x9e\x67\xdd\xb6\x5d\x07\x92\x77\xf8\x3f\xf9\xba\xd2\x96\x6f\xbd\xc6\x44\xc1\xd9\xb6\xb9\x8f\xd9\x0f\x08\x51\xcb\x7a\xf3\x16\x28\xcd\x15\x08\xbb\x98\xea\xb3\xda\x13\x7d\xd3\x55\x8b\xeb\xad\xbf\xf1\x0e\xab\x73\x4e\xbd\xa5\x89\xb6\xce\x3b\x75\x2c\xfd\x36\xa6\x14\x9f\x6f\xde\x5f\x25\x52\x79\x6e\xdb\x4b\x62\xfd\x78\x02\xfe\x4a\x7a\xe8\xfe\xc9\x38\xfb\xe1\x23\x79\x0a\x96\x91\x78\xc7\x89\xcb\x49\x63\xe5\xac\xd6\xcd\xe9\x59\x12\x6b\x4e\xe1\xc2\xd8\xef\xb9\xa6\x2f\x6d\x67\x7e\x99\xdf\x01\x00\x00\xff\xff\x9a\x49\x7d\xdd\xf0\x02\x00\x00" -func privateforwarderDeploy_forwarder_contractCdcBytes() ([]byte, error) { +func metadataScriptsGet_viewsCdcBytes() ([]byte, error) { return bindataRead( - _privateforwarderDeploy_forwarder_contractCdc, - "privateForwarder/deploy_forwarder_contract.cdc", + _metadataScriptsGet_viewsCdc, + "metadata/scripts/get_views.cdc", ) } -func privateforwarderDeploy_forwarder_contractCdc() (*asset, error) { - bytes, err := privateforwarderDeploy_forwarder_contractCdcBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "privateForwarder/deploy_forwarder_contract.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x10, 0x63, 0x44, 0x17, 0x78, 0x41, 0x47, 0x73, 0xf, 0x19, 0xd3, 0x94, 0xb2, 0xd3, 0xfb, 0xbe, 0x5e, 0xe7, 0xd4, 0xa4, 0x53, 0x61, 0x2e, 0x62, 0x52, 0xcd, 0xb6, 0xd4, 0x6b, 0x79, 0xbb, 0x6e}} - return a, nil -} - -var _privateforwarderSetup_and_create_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x54\x4f\x8f\xa2\x4e\x10\xbd\xf3\x29\x2a\x73\x98\x40\xe2\xc8\xdd\xa0\xc9\xfc\x26\x33\xc7\x5f\xcc\xee\x64\xef\x65\x53\x42\x47\xec\x26\x45\xa1\x63\x8c\xdf\x7d\x43\x8b\x48\x8b\xec\xba\x9b\xe5\x44\xba\xfe\xbd\xaa\x57\xaf\x02\xbd\x2d\x2d\x0b\x7c\xd4\x26\xd3\xab\x82\x3e\xed\x86\x0c\xac\xd9\x6e\xe1\xc9\x7b\x7b\xba\x78\xbe\x7f\xe1\xb6\xf4\x1d\xfb\x4f\x9d\xdf\x92\xf5\x0e\x85\xbe\x91\x22\xbd\x23\xfe\xb0\xbc\x47\x4e\x89\xdb\x98\x31\xf3\x53\x10\xc4\x71\x0c\x9f\xb9\xae\x40\x18\x4d\x85\x4a\xb4\x35\x80\x69\x5a\x01\xc2\x0f\xac\x0b\x99\x00\x42\x79\x8e\x07\x6e\x13\xc0\xfa\x92\xc1\xc5\x23\xac\xb0\x40\xa3\x08\x14\x96\xb8\xd2\x85\x96\xc3\x04\xd0\xa4\x4d\x68\xbd\x2a\xb4\xea\x19\x9a\x58\x90\xfc\x9a\x2c\x08\xfa\xa5\x8f\x41\x00\x00\x50\x32\x95\xc8\x14\x56\x3a\x33\xc4\x33\x78\xad\x25\x7f\x55\xca\xd6\x46\x22\x38\x3a\x97\xe6\xd3\x6b\x38\x7b\x4c\x33\x92\xb7\xae\x46\xf2\x3c\xd6\xf1\xb4\xfb\x5b\x84\xa3\x3e\x37\x86\xa5\x6b\x61\x89\x92\x47\x53\x95\x93\xda\x84\x7d\x08\xcd\x17\xc7\xdd\x88\xba\xc9\xc0\x1e\x2b\xc0\x82\x09\xd3\x03\x54\x24\x50\x97\x5e\x0c\x93\xd4\x6c\xba\xa7\x53\x70\xa7\xa9\x95\x65\xb6\xfb\xe4\xb9\xcf\xf9\xd4\xb1\xb2\x08\x1b\x66\x67\x30\xb4\x7c\x17\xcb\x98\x91\x83\x0b\xf3\x39\x18\x5d\x0c\xd1\xbe\x31\x35\x60\x11\x0c\xed\xfd\x25\x73\x39\x1c\x77\x65\x2d\xa0\x05\xb4\x81\xea\x9c\xd2\x4b\xd2\x22\xac\x70\x47\xa1\x67\x68\xbe\xe4\xc5\xc3\xa5\x5c\xb5\xf7\x6d\x29\x07\x97\x3e\x8c\x26\x83\x10\xb1\xbf\x69\xc6\x8b\x88\xee\xcd\xad\x85\x54\x68\xb3\x49\x9e\x8f\x9e\xa0\xa6\x17\x2e\x4f\x0b\x1f\x6d\xdc\xf2\x16\x53\xaf\xf6\xc5\xd9\x47\x29\xc8\x19\xc9\xa3\x28\xa3\x2b\xae\x82\xa4\x5b\xf6\xeb\x8e\xc2\x7c\x64\x75\xc7\x91\xff\x12\x6c\xaf\x60\x9f\xe0\xa1\xfe\xc4\x3a\xf9\x9d\x89\x96\x1c\x05\xac\x29\x0e\x40\x5f\xa5\xad\xa8\xea\x27\x69\xdc\x2e\xca\x5e\x6b\x2a\x52\x90\x9c\x6d\x9d\xe5\xce\xf2\x5f\x6b\xd1\x46\x88\xd7\xa8\xe8\x3e\x11\xc3\x71\xdd\x34\xd8\xe6\xb9\x65\x66\x18\x77\xd5\xe1\x3f\x24\xe6\xaa\xd7\xe4\x65\xf4\x8c\xb6\x1b\xfc\x3f\xed\xbb\xa7\x90\x49\xe9\x52\x93\x91\xd9\x1d\x72\xa3\xc1\x56\x3a\xa1\x24\x2f\x5d\xb9\x89\xdb\xf8\x47\x4f\x50\x5f\xd4\x23\x0b\xff\xc8\xc5\xf3\xc6\xf6\xe7\xe7\xef\xfe\xd8\xff\xa2\x87\xc0\xd7\xf1\x29\x38\x05\x3f\x03\x00\x00\xff\xff\xa7\xc6\xef\xf9\x1c\x07\x00\x00" - -func privateforwarderSetup_and_create_forwarderCdcBytes() ([]byte, error) { - return bindataRead( - _privateforwarderSetup_and_create_forwarderCdc, - "privateForwarder/setup_and_create_forwarder.cdc", - ) -} - -func privateforwarderSetup_and_create_forwarderCdc() (*asset, error) { - bytes, err := privateforwarderSetup_and_create_forwarderCdcBytes() +func metadataScriptsGet_viewsCdc() (*asset, error) { + bytes, err := metadataScriptsGet_viewsCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "privateForwarder/setup_and_create_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf0, 0x8, 0x6, 0xa0, 0xee, 0x62, 0x7e, 0x1f, 0xc8, 0xb4, 0xf4, 0xe4, 0xf0, 0x3c, 0x15, 0xd2, 0x12, 0xf6, 0xcc, 0x38, 0x19, 0x38, 0x62, 0x89, 0x46, 0xc1, 0x4e, 0x16, 0xb, 0xb4, 0xcd, 0x7}} + info := bindataFileInfo{name: "metadata/scripts/get_views.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd2, 0xeb, 0x1, 0x21, 0x5a, 0x4e, 0xde, 0x51, 0x33, 0x58, 0xe4, 0x32, 0xf3, 0x7, 0xfc, 0xf0, 0x18, 0x22, 0xde, 0x44, 0x9f, 0x42, 0x62, 0x4, 0x10, 0x88, 0xe2, 0xce, 0x90, 0x4c, 0xc2, 0xd1}} return a, nil } -var _privateforwarderTransfer_private_many_accountsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x93\x41\x6f\xda\x4e\x10\xc5\xcf\xec\xa7\x78\xe1\x90\x3f\x48\xff\x9a\x4b\xd5\x83\x95\x36\x42\x55\xe9\xa9\x52\x94\xa4\xbd\x54\x3d\x2c\xf6\xd8\x5e\xc5\xec\x5a\xb3\x63\x20\x8a\xf8\xee\x95\xbd\x8b\x65\x4a\x11\x97\x9e\x40\xb3\x6f\xde\xbe\xdf\xcc\xda\x6c\x1a\xc7\x82\x55\x6b\x4b\xb3\xae\xe9\xd9\xbd\x90\x45\xc1\x6e\x83\xe9\x49\x6d\xaa\xa2\xf2\xcb\x5e\x6f\x9a\x53\xe1\xb8\x34\xe8\x1e\xd8\x6c\xb5\xd0\x23\x65\x64\xb6\xc4\x2b\xc7\x3b\xcd\x39\x71\xec\xb9\x74\x3c\x55\x6a\xb1\x58\xe0\xb9\x32\x1e\xc2\xda\x7a\x9d\x89\x71\x36\xfc\x2f\x88\x3d\xc4\x61\xa3\xed\x2b\x74\x9e\x33\x79\x4f\x1e\x52\xb1\x6b\xcb\x0a\x52\x91\x61\x34\xc1\x19\x1c\xad\xbd\x52\x23\xa3\x59\x6c\x5b\x6e\x5c\x6b\xe5\x9b\x6e\x52\xbc\x2d\x43\x29\xc5\xf7\x95\xd9\x7f\x78\x7f\x98\xe3\x4d\x29\x00\xe8\x83\x10\x7e\xe8\xb6\x16\x30\x79\xd7\x72\x46\x90\x4a\x0b\x2a\x57\xe7\xdd\xcd\x04\xe9\xb0\x7d\xa8\x6a\x26\xac\xc9\xd8\x72\xc8\xcb\x94\xf7\x56\x35\x09\xb6\x9d\xcf\x23\x15\x29\x6e\xc7\x23\x4b\x7a\x7f\x35\xc8\x22\x40\x1c\x89\xb1\xe5\x13\xd9\x9c\x38\xc5\xed\xa5\xa1\x25\x41\x11\x2c\x1a\xa6\x46\x33\xcd\xbc\x29\x6d\xd7\xb5\x6c\xa5\x5a\x66\x59\x87\x3b\x80\x45\xb8\xaf\x24\xd0\x60\x2a\x88\xc9\x76\x64\xae\x27\x0a\x9d\xff\x79\x78\x71\x4c\x79\xc8\x3d\xf4\x79\xaa\x8b\xe4\x88\x82\x8f\x51\x9d\xac\x1d\xb3\xdb\xdd\xfd\x85\xec\xd3\xac\x5b\x79\x8a\xf3\x93\x27\x71\xac\x4b\x7a\xd0\x52\xcd\xd5\x64\x32\xb9\xbf\x47\xa3\xad\xc9\x66\xd3\xcf\xae\xad\x73\x58\x27\x08\xbe\xe7\x21\xdd\x2e\x64\xec\x8d\x6e\xa6\x73\x75\x1a\xf0\xc2\x10\xcf\xf3\x5e\x99\xe9\x31\xfc\x15\xd9\xbf\x27\x39\x84\x1f\xda\x53\xd6\x0a\x8d\x17\x57\x38\x3e\x3e\x7e\x18\x8b\x3f\x1f\x74\xf2\x42\xaf\x7e\xac\xbf\x36\x93\xc4\x93\xcd\x23\x5f\xbf\x1c\x7f\xfc\x48\xfe\x8f\x8f\x3b\xc5\xdd\xbb\x93\xb5\x27\x3b\x23\x55\xce\x7a\x37\xd3\xfd\xb5\xe9\x59\x8a\x9f\xb1\xf0\xeb\x66\x3e\x5a\xcd\x21\xa2\x1d\xd4\xef\x00\x00\x00\xff\xff\x92\x7f\xff\x83\x78\x04\x00\x00" +var _metadataSetup_account_from_addressCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x54\x4b\x6f\xdb\x3c\x10\xbc\xeb\x57\xec\xe7\x43\x20\x03\x8e\x7c\x37\x9c\x04\xf9\xdc\xe6\xd6\xa2\x48\xdc\xdc\xd7\xd4\xca\x22\x22\x93\x02\x77\x69\x35\x08\xfc\xdf\x0b\x52\x8f\x48\x79\x34\x45\xaa\x83\x21\x73\x9f\x33\x9c\x91\x3e\xd4\xd6\x09\xcc\x6e\xbc\xd9\xeb\x5d\x45\x5b\xfb\x40\x66\x96\xbc\x79\xfc\x8d\x04\x73\x14\xbc\xd7\xd4\xf0\x2c\x49\x96\xcb\x25\x6c\x4b\xcd\x20\x0e\x0d\xa3\x12\x6d\x0d\x68\x86\xa6\x44\x01\x34\x80\x4a\x59\x6f\x04\x1a\xeb\xab\x1c\x9c\x37\xb1\x42\x2c\x30\x09\x68\x61\xaa\x0a\xf0\x75\x38\x38\xa0\xc1\x3d\x41\xd1\x4d\x03\x09\xe3\x38\x6b\xbb\x17\xde\xc4\xd6\xb1\xda\x33\x31\x1c\xc3\x02\xa1\xee\xc1\xd8\x06\x9a\x92\x1c\xf5\x6d\x43\xbf\x92\xe0\x88\xbe\x92\x58\xa0\x0d\xb0\x58\x17\xda\xa3\xc9\x43\x9a\x72\x84\x42\x31\x8d\x0e\xb5\x3c\xb6\xc9\x59\x92\x8c\x60\xa4\xca\x1a\x71\xa8\xe4\x3a\xcf\x1d\x31\xaf\xa0\x7b\x59\x40\x1f\xf9\x8e\x07\x5a\xc1\x9d\x38\x6d\xf6\x73\x78\x4a\x12\x00\x80\xda\x51\x8d\x8e\x52\xd6\x7b\x43\x6e\x05\xe8\xa5\x4c\xef\xf0\x48\xf7\x58\x79\x5a\xc0\x06\x6b\xdc\xe9\x4a\x8b\x26\x9e\xc3\xd9\x75\xcb\x50\x28\x87\xee\x59\x2e\xe1\x7f\xeb\x9c\x6d\x00\xc1\x51\x41\x8e\x8c\x8a\xe8\x06\x58\x11\x0f\xe5\x60\x4d\x3c\xab\x91\x99\xf2\x81\x6c\x94\xf1\x69\xed\x77\x95\x56\x3f\x50\xca\x61\x40\x45\x02\x8e\xd8\x56\x47\x72\xb7\x54\xc0\x05\xec\x49\xba\x45\x5e\xc2\x9e\x0f\x55\xe1\xc9\xfa\x28\x67\xbb\xb8\xe2\xfa\xec\x69\x22\x90\xd3\x65\x6a\x22\x2b\x63\x8e\xa6\x3d\xae\xae\xa0\x46\xa3\x55\x3a\xdb\x44\x55\x18\x2b\xb0\x7b\x17\xef\x54\x10\x43\xdb\xd9\x3c\x19\xf3\xf5\x93\xc3\x6d\xa2\x4c\xeb\x1d\x89\xd3\x74\x6c\x2f\xfa\x66\x1b\x44\x0b\x13\x12\x0a\xb9\x0f\x74\x7e\x41\x41\xb8\x18\x53\x92\x75\xef\x9b\x6e\x5c\x28\x4d\xc3\x99\x77\x8a\xb6\x8f\x35\xad\xc0\xe8\x6a\x11\x65\xd8\xfe\x0d\xbf\xeb\xf7\xbd\x92\xdd\x6c\x87\x51\x97\xe9\x7c\x0e\xc8\xff\xc1\xdf\xa5\x5f\x7d\xc8\x5e\xb7\x6c\x0f\x73\x80\x14\xb6\x83\xc2\xba\x18\xd8\xeb\x23\x99\x61\xe4\x9f\xe9\xdc\xb4\xfe\x40\x30\xd4\x8c\x1d\x02\x9e\xb5\xd9\xc7\x76\xad\x85\xbe\x86\x58\x1c\x38\x78\x14\xb4\x61\x9d\xbf\x5a\x66\xc2\x3b\x3d\x97\xad\xcf\x47\x97\x90\xbd\xec\x9a\x4e\xf7\x0a\x36\x02\x2d\xbd\x36\x3a\xc1\x0f\x19\xad\xe5\xb2\xce\xec\x19\xe3\x91\xd2\xf5\xf9\xf3\xb0\x05\x88\x5d\x8d\x2f\xbd\x4f\x0d\xee\x78\x16\xe9\x9b\x4c\xb4\x36\x02\xd5\xbb\xf7\x71\x20\xb6\x65\xa6\x29\xb5\x2a\x41\x1b\x55\xf9\x9c\x38\x06\xb2\xdb\x4e\x50\xa0\x8d\x90\x2b\x50\xd1\x84\x85\x58\xb8\xc1\x1a\x2e\xfa\xcd\xd5\xe8\xdb\x30\xc0\xd0\xcc\x9e\x5e\xfa\x2c\x8b\x18\x4e\x97\xe9\x87\x68\xde\x6a\x1d\xc1\x70\x99\xf6\x1b\x2c\x00\x65\x4a\xcc\xa1\x53\x63\xdb\xeb\x53\x8c\xd0\xaf\xda\x0e\x72\x71\xa4\x48\xbf\x4f\x45\x1f\xfe\x2c\x1b\xb7\x5d\xfd\xbf\x12\x32\xda\xe3\x35\x27\x7d\x70\xc4\xc9\x29\x39\x25\xf0\x3b\x00\x00\xff\xff\xc6\x61\x97\x91\x41\x07\x00\x00" -func privateforwarderTransfer_private_many_accountsCdcBytes() ([]byte, error) { +func metadataSetup_account_from_addressCdcBytes() ([]byte, error) { return bindataRead( - _privateforwarderTransfer_private_many_accountsCdc, - "privateForwarder/transfer_private_many_accounts.cdc", + _metadataSetup_account_from_addressCdc, + "metadata/setup_account_from_address.cdc", ) } -func privateforwarderTransfer_private_many_accountsCdc() (*asset, error) { - bytes, err := privateforwarderTransfer_private_many_accountsCdcBytes() +func metadataSetup_account_from_addressCdc() (*asset, error) { + bytes, err := metadataSetup_account_from_addressCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "privateForwarder/transfer_private_many_accounts.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x55, 0x3f, 0x3f, 0x6a, 0x6c, 0x28, 0x39, 0x37, 0x44, 0xea, 0xf7, 0x2c, 0xaa, 0x34, 0xb6, 0x13, 0x4b, 0x70, 0xab, 0x38, 0x36, 0x94, 0xe7, 0xdd, 0xd6, 0xf6, 0x84, 0x5, 0x69, 0xc, 0x1d, 0xc0}} + info := bindataFileInfo{name: "metadata/setup_account_from_address.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x18, 0x2e, 0xb8, 0xe0, 0x29, 0x5b, 0x76, 0x7e, 0xc7, 0x7e, 0xf3, 0x51, 0xec, 0x7e, 0xad, 0x23, 0xad, 0x97, 0xd9, 0x0, 0xf4, 0x6, 0xd7, 0x49, 0x21, 0x3c, 0xc4, 0xce, 0xf6, 0x67, 0x5e, 0x4c}} return a, nil } -var _safe_generic_transferCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x95\xc1\x6e\xe3\x36\x10\x86\xcf\xf1\x53\xcc\xfa\xb0\x2b\x01\x5e\xe5\x52\xf4\x60\x24\x4d\xdd\x00\xe9\xa1\x87\x06\x89\xdb\x3b\x2d\x8e\x24\x36\x34\x29\x70\x46\x56\x0c\xc3\xef\x5e\x90\x94\x68\x2b\x4e\xda\xec\xc9\xf4\x98\x9c\xff\x9b\x9f\x33\xb4\xda\xb6\xd6\x31\x3c\x74\xa6\x56\x1b\x8d\x6b\xfb\x82\x06\x2a\x67\xb7\x30\x9f\xc4\xe6\xb3\xd9\xf5\xf5\x35\xdc\x0b\x03\xad\x20\x02\x65\x40\x98\x3d\x10\x5b\x27\x6a\x84\x56\x70\x03\xc2\x48\x70\x58\xa2\xda\xa1\x8b\x11\x65\x88\x51\x48\xb0\x15\xfc\xd3\x11\x03\x37\x08\x12\x2b\xd1\x69\x2e\x42\xbe\x75\xa3\x08\x34\x32\xc1\xde\x76\x50\x36\xd6\x12\x86\x5d\x1c\x40\x7c\xb0\x17\x86\x81\x2d\x10\x1a\x09\x82\xa0\x47\xad\xc3\x96\x52\xb4\x62\xa3\xb4\xe2\xfd\xe5\x3e\xe5\x97\x41\x22\xc8\xac\xcc\x7e\xc8\x18\xb0\x4a\x61\x60\x83\xa1\x10\x0c\x39\x85\x01\xe1\xea\x6e\x8b\x86\xa1\x41\x87\x0b\x20\x0b\xbd\xd0\x81\x8c\x1a\xdb\x69\x19\xf2\xc4\x25\x94\x0d\x96\x2f\xa7\x13\x3b\xa1\x3b\x24\xaf\xbd\x15\x2f\x08\xd4\xb9\x58\x83\x32\x8c\x46\xa2\x3c\x97\x56\x34\xca\x2a\x13\xf0\xd8\x09\x43\xa2\x64\x65\x4d\x26\xb6\xb6\x33\xbc\x84\xbf\x1e\xd4\xeb\xcf\x3f\x2d\x80\xed\x12\x56\x52\x3a\x24\x5a\x84\xba\xd0\x3d\x0a\x6e\x96\xf0\x1c\x6d\xf7\x5f\x16\xc9\xf2\xf8\xd3\x63\xb7\xd1\xaa\xf4\xeb\x1c\x0e\xb3\x19\x00\x40\xf0\x19\xe1\x6f\x6f\x3b\x38\x24\xdb\xb9\xd2\x13\x0a\x86\xc6\x6a\x49\x27\xc3\x29\x46\x85\x43\xd8\xa0\x32\x35\x04\xba\x0a\x9d\x43\x19\x52\x69\x64\x60\xdc\xb6\x21\xd7\x12\x7e\x9d\xf4\x48\x11\xa2\x49\xf3\x37\xeb\x9c\xed\x7d\xf9\x58\xa1\x43\x53\xe2\x88\x3a\x8a\xa9\x6a\x88\x78\x29\x51\x96\xbe\x7a\x90\x16\xc9\x7c\x63\xa0\xae\x0d\xad\xe9\xe1\x7c\xed\x01\xc7\x9f\x4b\x20\xd1\x91\xa7\xa1\xfc\x27\xac\x96\xf0\xf5\x10\x49\xc6\xe0\x31\xd2\xb4\x0e\x5b\xe1\x30\x23\x55\x1b\x74\x4b\x58\x75\xdc\xac\xa2\x5e\x72\x69\xa0\xfe\x1d\x19\x04\xb8\x84\xcc\x36\x12\x84\x93\xdf\x28\x74\x3c\x4a\xd8\x85\x52\xc7\x73\x9e\x26\x44\x9e\xb0\x82\xdb\x61\x73\xb1\x09\x06\xdc\x7c\x3d\x4c\x5d\x7a\x74\x76\xa7\x24\xba\xe3\x2f\x99\x1f\xb4\xe5\xd9\xcd\xe6\xb3\xab\xab\xab\xbb\x3b\x68\x85\x51\x65\x36\xbf\x0f\xdd\x66\x2c\x43\x4c\x75\x89\x65\xfb\x48\x15\x9c\xff\x32\xcf\x13\x51\x5a\x10\xea\xaa\xb8\x70\xea\x7f\x21\x93\x81\x3f\x0e\xf9\x51\xa6\x4f\xd0\x4f\xa9\x53\xa3\xc1\xcd\xf7\x64\x6f\xd1\x2b\x6e\xa4\x13\x7d\x9a\x96\xf8\x19\x4b\x1f\xee\x1b\x5f\xb1\xec\x18\xe1\x30\xb9\x21\x37\xa9\xbf\x46\x1e\x5a\x20\x63\x9b\x17\x35\xf2\x7d\x7a\x50\xfe\xcb\x8e\xf3\x71\xcb\x07\xfb\xb2\xfc\xcb\x44\x69\xe8\x5d\x94\x01\x7f\xbd\x6f\x91\xe0\xf6\x5c\xdf\xcb\x3d\x5f\x6e\xca\xf2\xf3\x56\xfc\xd3\xe8\x7d\x9a\xc0\x71\x66\xfa\x06\x4d\x30\x2f\xbd\xb4\x8a\xa0\x57\x5a\xc7\xf9\x38\x8d\x98\x9f\x69\xe1\x6a\x64\x94\xf0\xb0\x2e\x52\x62\x55\xbd\x87\x57\x94\xd6\xb0\x50\x86\xfe\xc0\x7d\x36\x75\xdf\xb3\xfa\x3d\x59\x9e\x9f\x19\x3a\x3e\x2c\x6f\xf0\xc2\x5f\xc7\x87\x03\x33\x5e\x7c\x62\x3f\xbd\xe1\x93\xc4\xe7\x4e\x49\x6c\x2d\x29\x1e\xda\xf0\xe6\xfb\x14\xee\x64\xd8\x11\x50\x13\xbe\x21\x7c\xbf\xfb\x3f\x9f\x73\x68\xaa\xe3\xbf\x01\x00\x00\xff\xff\x4c\xf3\x0f\xb7\x27\x07\x00\x00" +var _metadataSetup_account_from_vault_referenceCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x53\xc1\x6e\xdb\x30\x0c\xbd\xfb\x2b\x88\x1c\x3a\x07\x48\x9d\x7b\x90\xb4\xe8\xb2\x75\xa7\x01\x45\x97\xf5\xce\xd8\x74\x2c\xd4\x91\x0c\x89\xb6\x57\x14\xf9\xf7\x41\x92\xe5\xc8\x59\x8b\x02\x9d\x0f\x81\x42\x91\xd4\x7b\x8f\x8f\xe2\xd8\x28\xcd\x30\xbb\x6f\xe5\x41\xec\x6b\xda\xa9\x67\x92\xb3\xe4\xcd\xf0\x4f\x62\x2c\x90\xf1\x49\x50\x6f\xce\x39\xf6\xef\x23\x19\x55\x77\xa4\x67\x49\xb2\x5c\x2e\x61\x57\x09\x03\xac\x51\x1a\xcc\x59\x28\x09\xc2\x40\x5f\x21\x03\x4a\xc0\x3c\x57\xad\x64\xe8\x55\x5b\x17\xa0\x5b\xe9\x2a\x58\x81\x21\x06\xc1\x86\xea\x12\xda\xc6\x06\x8e\x28\xf1\x40\x50\x0e\x18\x80\x2d\x08\x93\xf9\xee\x65\x2b\x5d\x6b\x57\xdd\x1a\x32\xd0\x59\x58\xb6\xee\x59\xaa\x1e\xfa\x8a\x34\x85\xb6\xb6\x5f\x45\xd0\x61\x5b\xb3\x2b\x10\x12\x0c\x2b\x6d\xdb\xa3\x2c\x6c\x5a\xae\x09\x99\x5c\x1a\x1d\x1b\x7e\xf1\xc9\x59\x92\x44\x34\x52\x2c\x0a\x4d\xc6\xac\xe0\xce\x1f\x16\xd0\xb4\xfb\x5a\xe4\x0f\xc8\xd5\x0a\x1e\xc6\xf3\x1c\x5e\x93\x04\x00\xa0\xd1\xd4\xa0\xa6\xd4\x88\x83\x24\xbd\x02\x6c\xb9\x4a\x7f\x61\x47\x4f\x58\xb7\xb4\x80\x2d\x36\xb8\x17\xb5\x60\x41\x66\x0e\x57\x77\x5e\x1b\x5b\x0e\xc3\xb7\x5c\xc2\x57\xa5\xb5\xea\x01\x41\x53\x49\x9a\x64\xee\x78\x8d\x84\x1c\x13\x2a\x40\x49\x17\x6b\xd0\x18\x2a\x46\x99\x91\xe3\xe8\x19\xee\xf8\x40\x4d\x0c\x7a\x18\xdf\x23\x95\xb0\x81\x03\xf1\x00\x24\x10\x9e\x8f\xd9\xf6\xcb\xf2\x08\x75\xb6\x77\xe8\xd6\x57\xaf\xb1\x0f\xb2\x70\x38\xdd\xa4\xe7\x37\xa7\x6d\x6e\x6f\xa1\x41\x29\xf2\x74\xb6\x75\x56\x90\x8a\x61\xff\x01\x55\x3b\xe3\x11\x2d\xcc\xe6\x49\xac\xd3\x6f\x63\xe7\x87\x3c\x2d\xd6\xc4\x5a\x50\xe7\x47\x7b\xbf\xb3\x28\x61\x42\xbe\x64\x17\xdb\xc0\xfb\x66\xcf\x0e\xc4\xbe\x34\xed\x22\x96\xab\x58\xb8\x29\x96\x1f\xc4\xe1\x41\x0b\xfc\x1b\x32\x7a\xf0\xa5\x56\x47\xff\x73\xc6\x73\x09\x67\xac\xd8\x0c\xe0\xb2\x38\x18\x74\x83\x74\xb6\xab\x28\x4c\xdf\xeb\x53\x88\x42\x7e\x61\x10\xc7\xa6\xa6\x23\x49\x8e\xa4\x2b\x02\x84\x0b\xd5\xb6\xde\xf8\x08\x92\xfa\xd8\xfa\xd0\x1a\x21\x0f\xae\x81\xdf\x8d\xef\xf6\xce\xc1\x18\x97\x0f\x84\x34\xa2\xa0\x4b\xa6\x13\x3e\x74\x2e\x5b\x5f\x47\x3c\xb2\xcb\xae\xe9\x14\x97\xdd\x12\x10\x1c\xe6\x3f\xf8\x79\xcc\xf0\x1b\x95\x0d\x5b\x9c\x19\xec\x28\x5d\x5f\x9f\x1f\x5b\x00\xab\x55\x2c\x66\x48\x9d\x1a\xf1\x4d\x25\xbc\x63\x61\xb4\xf9\x0b\x94\x4a\x47\x52\xf6\x95\xc8\x2b\x10\x32\xaf\xdb\x82\x8c\xbb\x18\x0d\x0f\x42\x32\xe9\x12\x73\x9a\xa8\xe0\x0a\xb7\xd8\xc0\x26\x20\x9f\x2c\x51\xa0\x21\x8c\x69\x69\x7d\xf5\x3a\xb1\x62\xe6\x38\x9c\x6e\xd2\x0f\xd9\xbc\xd5\xda\x91\x31\x55\x1a\x10\x2c\x00\x79\x2a\xcc\x71\xb0\xba\xef\xf5\x29\x45\xe8\x4f\xa3\x46\xbb\x68\xca\x49\xbc\x2f\x45\xb8\xfe\xac\x1a\x8f\x43\xfd\xff\x0a\x12\xe1\xf8\x57\x93\x70\x19\x69\x72\x4a\x4e\x09\xfc\x0d\x00\x00\xff\xff\xb9\xe0\xf8\xc0\x30\x07\x00\x00" -func safe_generic_transferCdcBytes() ([]byte, error) { +func metadataSetup_account_from_vault_referenceCdcBytes() ([]byte, error) { return bindataRead( - _safe_generic_transferCdc, - "safe_generic_transfer.cdc", + _metadataSetup_account_from_vault_referenceCdc, + "metadata/setup_account_from_vault_reference.cdc", ) } -func safe_generic_transferCdc() (*asset, error) { - bytes, err := safe_generic_transferCdcBytes() +func metadataSetup_account_from_vault_referenceCdc() (*asset, error) { + bytes, err := metadataSetup_account_from_vault_referenceCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "safe_generic_transfer.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe7, 0x43, 0xff, 0xd2, 0xb1, 0x4c, 0xd0, 0x65, 0x16, 0x78, 0xc7, 0x6a, 0xb1, 0x54, 0x83, 0x87, 0x59, 0x2d, 0x90, 0x42, 0x4e, 0x45, 0xd4, 0x4d, 0x2b, 0x54, 0xf2, 0x49, 0x52, 0x91, 0x7, 0x14}} + info := bindataFileInfo{name: "metadata/setup_account_from_vault_reference.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf6, 0xf7, 0xf3, 0x7, 0x11, 0xf1, 0x3e, 0x5, 0x7, 0xcb, 0xee, 0xf9, 0x81, 0x4d, 0xb5, 0x12, 0x22, 0x58, 0x73, 0x23, 0x35, 0x9, 0xea, 0xb9, 0xb8, 0xaf, 0x71, 0x41, 0x9e, 0xd, 0x5, 0x70}} return a, nil } -var _scriptsGet_balanceCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x64\x91\x3f\x6f\xc2\x30\x10\xc5\x77\x7f\x8a\xa7\x0c\x6d\x58\x92\xa5\xea\x80\x4a\x11\x45\x65\x46\x15\xed\x7e\x49\x2e\x60\xd5\xb1\x23\xe7\xdc\x52\x21\xbe\x7b\x05\xc6\x94\xa8\x9e\xce\x77\xbf\xf7\x74\x7f\xca\x12\x9b\x9d\x1e\x30\xd4\x5e\xf7\x02\xcf\xd4\x0c\x90\x1d\xa3\x22\x43\xb6\x66\xb4\x9a\x4d\xa3\xca\x12\xae\x05\x59\x50\x5d\xbb\x60\xe5\x7e\xc0\xeb\x9e\xba\xde\xf0\xc6\x7d\xb2\xc5\x4b\xa4\x95\xd2\x5d\xef\xbc\x60\x15\xec\x56\x57\xa9\xda\x7a\xd7\x21\x1b\xe5\xb2\x44\x8e\x6c\x22\x78\x9b\xca\x94\xea\x43\x85\x36\x58\x74\xa4\x6d\x4e\x4d\xe3\x79\x18\xa6\x58\xc4\x60\x32\xc5\xfb\x4a\xef\x1f\x1f\x70\x50\x00\x60\x58\x52\x8f\x98\x61\xcb\xb2\x88\x9f\x24\x9c\x5c\xa9\x2f\x0a\x46\xde\xb8\xc5\x2c\x09\x8a\x2d\xcb\x92\x7a\xaa\xb4\xd1\xf2\x93\xdf\xb6\x51\x7c\x9c\xe8\x75\xa8\x8c\xae\xd7\x24\xbb\x68\x73\x7a\x45\xe5\xbc\x77\xdf\x4f\x77\xff\xf1\xc3\x68\xe2\xe2\xb2\xa3\xe3\x73\xfe\xa7\x9e\xcf\xd1\x93\xd5\x75\x9e\x2d\x5d\x30\x0d\xac\x13\x44\xc3\xb4\x52\x78\x6e\xd9\xf3\x29\x12\x77\xbe\xcc\xd9\x3b\x9b\xa8\xb3\x89\x67\x09\xde\x5e\x87\x29\x2e\x67\x53\x47\xf5\x1b\x00\x00\xff\xff\x86\x1f\x84\xe5\xda\x01\x00\x00" +var _mint_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\xcd\x6e\xdb\x4c\x0c\xbc\xeb\x29\xf8\xe9\x10\x48\xf8\x12\xf9\x52\xf4\x60\xd8\x09\xf2\xd3\xdc\x02\x14\x89\x9b\x3b\x25\x51\xf6\xb6\xd2\xae\xc0\x5d\xd9\x31\x82\xbc\x7b\xb1\x3f\x92\xa5\x38\x36\xaa\x43\x02\xef\x92\x33\xc3\x21\xb9\xa2\x69\x15\x1b\x88\x1f\x3b\xb9\x16\x79\x4d\x2b\xf5\x87\x64\x1c\xf5\xc7\x3f\xde\xb0\x69\x8f\x4e\x27\xc1\x4f\x64\xb0\x44\x83\xaf\x82\x76\x3a\x8e\xa2\xd9\x6c\x06\xab\x8d\xd0\x60\x18\xa5\xc6\xc2\x08\x25\x41\x68\xd8\x6d\xd0\x80\xd9\x10\x34\x42\x1a\x62\xb8\x2d\x0a\xd5\x49\x03\x9d\x26\x0d\x46\xb9\x63\x90\xb4\x03\x63\x51\x75\xc0\xa1\x3d\xb4\xac\xb6\xa2\x24\x97\xcb\x54\x88\x56\x90\x34\x80\x65\xc9\xa4\x35\xa0\x2c\x01\x1b\x87\x14\x40\x2e\xdd\x99\x8d\x1e\x21\x21\x93\x17\x54\x11\x33\x95\x36\xd6\x46\x0c\x28\x95\x95\x64\xb3\x85\x5c\x47\xd1\x48\x7a\x32\x50\xce\xe1\xd6\x47\x5f\x06\xc2\x39\xfc\x7a\x14\x6f\xdf\xbf\xa5\xf0\x1e\x45\x00\x00\x96\xe8\x99\x2a\x62\x92\x05\xf5\x14\xc1\x42\x70\x66\xc1\x93\x2f\xfe\x99\xb4\xea\xb8\x20\x50\xf9\x6f\x2a\x8c\xcb\xae\xc9\x78\xc5\x3e\x66\x0e\x17\x63\xf7\x33\x7f\x7a\x86\xa8\xef\x4a\x60\x7a\xa6\x82\xc4\x96\x18\x54\x35\xb5\x6e\x4a\xd6\x87\xcd\xe1\xe2\x7d\xd2\xd7\xac\xbf\xf9\x38\x70\xae\x9c\xa9\x06\x6b\xd0\x5d\xdb\xd6\x7b\x87\xed\x4c\x86\x9c\x2a\xc5\xbe\x49\x79\xc7\x72\x20\xf1\x81\x77\xee\xb6\x37\xcc\x03\xb6\x4c\x2d\x32\x25\x5a\xac\xa5\xe5\xc7\xce\x6c\x92\x3b\xc5\xac\x76\xaf\x58\x77\x94\xc2\x45\x98\x11\x6b\x30\x84\x4f\x53\x5d\x65\x63\x50\x58\xc2\xc4\x27\xa7\xef\xc5\x05\x44\x43\xd6\x6c\x06\x1e\x19\x10\xf8\xb3\x71\x58\x36\x42\x8e\x3b\x31\xf0\x8c\xda\x01\x4b\xf0\x42\x33\x6d\x14\xe3\x9a\xb2\xdc\x01\x2e\xbe\xea\xd2\x75\x52\xb1\x6a\xe6\x53\x61\xb7\x96\xe6\xc5\x27\xff\x44\xb3\x49\x07\x2e\xfb\xdd\xdc\x40\x8b\x52\x14\x49\xfc\xe2\x68\xec\xca\x48\x65\x0e\x73\xec\x65\xc6\xe9\xa1\x28\x6b\xef\x16\xbb\xda\x3c\xa0\xc1\xcf\x36\x30\x69\x55\x6f\xe9\x5e\x49\xc3\x58\x18\xbb\x9d\x09\x87\xa9\x5b\xed\x5b\x9a\x83\x14\xf5\x25\x6c\x05\xed\xfc\x4f\xfb\x77\x71\x7a\xb3\xb3\xc7\xd5\x6b\xcf\x75\x9d\xa4\x29\xa0\xfe\x0f\xfe\x2d\xfc\xe6\x44\xa1\xf7\xaa\xab\x4b\x57\xe4\xba\xaf\x04\x2c\x80\x13\x05\x95\x62\x57\x7c\x11\x2a\x88\xbd\x5f\x5f\x34\x68\x98\xf4\xa5\x05\x0a\x33\x73\xd8\xdb\x34\x2b\xb0\xc5\x5c\xd4\xc2\x08\xd2\x43\xdb\x4e\x4d\xfb\x75\x32\x78\x9a\x71\x38\x3c\xd7\xae\x43\x15\x1e\x19\xfa\xa4\xe3\x41\x73\x8e\x84\x3a\xc2\x56\xd1\x1b\x15\x9d\xa1\xfe\x05\x09\xb3\x7a\xcf\x84\xc6\xbf\x94\xfd\x23\x36\x6e\xba\x7b\x41\x4b\x87\x06\x8b\xab\xa3\x51\xcd\xec\xbd\xab\x4a\x27\xfd\x4b\xe5\xff\xa7\x13\x96\x07\x6a\x95\x16\x6e\xc4\x9a\x5e\xa2\x13\x4f\x5b\xe2\x33\x3e\x67\xa5\x4f\x0c\x43\xbe\xb8\x1a\xe9\x99\x14\xd7\x2a\x6d\x46\xab\x7b\x6a\x4d\x61\xb9\xfc\x62\xad\xff\x1f\x5e\xd9\xf8\xe8\xd9\x69\x3a\x6d\x20\x27\x10\xb2\x60\x42\x4d\x25\xe4\x7b\xbf\xca\x2e\x25\x0e\x22\x3e\xfe\x06\x00\x00\xff\xff\x0d\x2e\x19\xab\xde\x06\x00\x00" -func scriptsGet_balanceCdcBytes() ([]byte, error) { +func mint_tokensCdcBytes() ([]byte, error) { return bindataRead( - _scriptsGet_balanceCdc, - "scripts/get_balance.cdc", + _mint_tokensCdc, + "mint_tokens.cdc", ) } -func scriptsGet_balanceCdc() (*asset, error) { - bytes, err := scriptsGet_balanceCdcBytes() +func mint_tokensCdc() (*asset, error) { + bytes, err := mint_tokensCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/get_balance.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf5, 0x57, 0xbd, 0xcd, 0x3e, 0x2e, 0x5b, 0x5, 0xd, 0x3d, 0x3d, 0xdd, 0x7e, 0x9, 0x75, 0x67, 0x29, 0xcd, 0x32, 0x13, 0x3c, 0x9, 0xd4, 0x3b, 0x68, 0xa6, 0x10, 0x15, 0xd, 0x15, 0x67, 0x95}} + info := bindataFileInfo{name: "mint_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd0, 0x3d, 0x6c, 0x6f, 0x34, 0x31, 0xf6, 0x60, 0x31, 0xf, 0x89, 0x21, 0xb3, 0x7, 0xc0, 0x7d, 0x62, 0x7a, 0x5d, 0xa9, 0xc, 0xd3, 0xee, 0x4a, 0xcf, 0x22, 0x4b, 0x2a, 0xea, 0x2a, 0xa4, 0x84}} return a, nil } -var _scriptsGet_supplyCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\xce\x31\xae\xc2\x30\x10\x04\xd0\x7e\x4f\x31\x4a\xf5\x7f\x83\x1b\x44\x41\x0f\x17\x20\x1c\xc0\x24\xb6\x62\x61\x7b\x57\xeb\xb5\x14\x84\xb8\x3b\x52\x2a\xd2\xce\x8c\x46\xcf\x39\x8c\x4b\x6a\x68\x93\x26\x31\x68\xf0\x73\x83\x2d\x01\xc6\xe6\x33\x5a\x17\xc9\x2f\xc4\x14\xf2\x4c\xce\x81\xe3\x56\x5e\x56\x5f\x24\x87\x91\x9f\xa1\xa2\x15\xaf\x86\x89\xab\xa9\x9f\x8c\x28\x15\x61\xb5\xfd\x26\x2a\x17\x0c\xbf\xd1\x40\x24\xfd\x81\xd8\x2b\x8a\x4f\xf5\xef\xff\x8c\xfb\x35\xad\xa7\x23\xde\x04\x00\x1a\xac\x6b\xdd\xbd\x1c\x36\xd3\x6d\x23\xd1\x87\xbe\x01\x00\x00\xff\xff\x06\xc5\x37\x4e\xbb\x00\x00\x00" +var _privateforwarderCreate_account_private_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x54\x4f\x4f\xdb\x4e\x10\xbd\xfb\x53\xcc\x2f\x07\x7e\x8e\x64\x92\x3b\x0a\xd0\x36\x25\x12\xaa\x8a\x50\x49\xb9\x4f\x9c\xc1\x5e\x75\xd9\xb5\x76\xc7\x36\x11\xca\x77\xaf\x76\xed\xf5\x1f\x92\xb4\x50\x1f\x10\x19\xcf\xbc\x79\x6f\xe6\x8d\xc5\x73\xa1\x0d\xc3\x64\x55\xaa\x4c\x6c\x24\xad\xf5\x2f\x52\x93\x28\x84\x6f\x5e\xf0\xb9\x38\x88\xde\x1b\x51\x21\xd3\x0f\x4a\x49\x54\x64\x56\xda\xd4\x68\xb6\x64\xfa\x8c\x11\xdc\x77\x62\xdc\x22\xe3\xa3\xa0\xda\x4e\xa2\x68\x3e\x9f\xc3\x3a\x17\x16\xd8\xa0\xb2\x98\xb2\xd0\x0a\x84\x85\xd2\xd2\x16\x58\x43\x6a\x08\x99\x00\x5d\xc0\xfc\x6f\x61\x25\x75\x0d\x98\xa6\xba\x54\x0c\xb5\xe0\x1c\x10\x8a\x86\x02\x3c\x85\xde\x51\x34\x44\x7b\x8d\x22\x00\x00\xd7\xe9\x8e\x6a\xf8\xdc\x16\x73\x8e\x0e\x41\x4a\xc8\xb5\xdc\x02\xe7\x43\x00\x57\x20\x89\x41\x51\xdd\xe6\x5f\x00\x96\x9c\xc7\x0f\xac\x0d\x66\x94\xc0\x52\x2b\x36\x98\xb2\x4d\xe0\x1b\xed\x6c\x02\xb7\x6a\xa3\x5f\x12\x58\x62\x81\x1b\x21\x05\x0b\xb2\x53\x38\x6b\xab\x1b\x0a\x85\xa1\x02\x0d\xc5\x56\x64\x8a\x4c\x8b\xf8\x45\x1b\xa3\xeb\x47\x94\x25\xf5\xf9\x53\x78\xf5\x15\xee\xb1\x24\x9f\x66\x3d\x11\xb8\x0c\x12\xe2\x02\x77\x0e\xa6\x81\x9b\xfa\x82\x7d\xd3\x89\x5e\x28\x2d\x99\x82\xf6\x20\xa7\xc2\x52\xf2\x57\x64\x84\x4b\x18\xae\x73\x66\xc8\x6a\x59\x51\x10\xe5\xb6\x13\xbb\x58\x69\x52\x5a\xef\x0a\xba\x00\x25\x64\x02\x95\xa0\xba\xf9\xe9\xfe\x2e\x4e\x6f\x76\xb6\x5a\x3f\x86\x5e\x57\xf1\x74\x0a\x68\xff\x83\xf7\xa5\x5f\x77\x8c\xdd\x73\x7d\x0d\x05\x2a\x91\xc6\x93\xa5\x2e\xe5\x16\x94\x66\xc8\x82\x12\x70\x00\x9e\x94\x5b\x9d\x5f\x61\xda\x2a\x98\x4c\x7b\xe5\xf3\x39\x3c\x60\xe5\x4c\x64\x28\x2b\x25\x9a\xb6\x9a\xb5\x2f\x51\xd4\x39\xea\xd4\xcc\x67\xb6\x59\xfb\xcc\x62\x45\xf1\xe2\x7c\x34\xbb\xc6\xa2\x37\xcf\x05\xef\xbc\x88\xd8\xa3\x0f\xc6\xf4\x69\x94\xee\x73\xdc\x4c\x12\x60\x7d\xd1\xaf\x24\xf4\xb8\x47\xce\xc7\xe4\x6f\xad\x2d\x1d\xfb\x70\x63\xbd\xc7\x76\xc0\x68\x32\x62\x16\x2a\xf3\x5a\x86\x9d\xc0\x77\x1a\xed\xdf\xb4\x08\x03\x80\xcb\x03\xad\xe9\xc0\xc1\x9d\x70\xe1\x38\x2c\xce\x5e\x47\x3b\x9c\x05\x46\xfb\xab\x78\xb4\xb5\xa3\xa2\xba\x8c\xb1\xba\x9f\x96\x3c\xf5\x70\xc5\x81\xe3\xe8\xfa\x0f\x4f\x7c\x28\xab\x8b\xc2\xe2\x1c\x4e\x7d\x90\xda\x3d\xdd\x51\xdd\x85\x62\x43\xa9\x28\x04\xb9\xeb\x3e\x1c\xcd\x11\x07\x0d\x79\xf6\x4d\x59\x77\x5f\xa4\x56\xee\x7b\x7d\xd4\x61\x34\x5e\x38\x49\xfd\xcd\x8b\x87\xbf\x39\x65\x68\x90\xc6\xe4\x1d\x16\x84\xb3\x3e\x3e\xc1\x25\x16\x1f\xb4\xc4\x49\xd2\xdd\x7f\x6f\xcc\xe1\x9e\x7f\x50\x3a\xc2\x98\x0e\x55\xdf\x97\x1b\x29\x6c\xee\x75\x7e\x48\xf9\x1f\x65\x16\x0d\xea\x98\xfb\x70\x4e\xc9\xe8\x0d\xf2\xfb\xf7\xe7\x09\xa7\xc7\x6e\x62\x1f\xed\x7f\x07\x00\x00\xff\xff\xf5\x1b\x9e\xbf\x86\x07\x00\x00" -func scriptsGet_supplyCdcBytes() ([]byte, error) { +func privateforwarderCreate_account_private_forwarderCdcBytes() ([]byte, error) { return bindataRead( - _scriptsGet_supplyCdc, - "scripts/get_supply.cdc", + _privateforwarderCreate_account_private_forwarderCdc, + "privateForwarder/create_account_private_forwarder.cdc", ) } -func scriptsGet_supplyCdc() (*asset, error) { - bytes, err := scriptsGet_supplyCdcBytes() +func privateforwarderCreate_account_private_forwarderCdc() (*asset, error) { + bytes, err := privateforwarderCreate_account_private_forwarderCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/get_supply.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbc, 0x3d, 0xd7, 0x2a, 0x1b, 0x2a, 0xd5, 0xeb, 0x39, 0x29, 0x29, 0x35, 0x13, 0xe0, 0x15, 0x56, 0xe1, 0x9c, 0xfa, 0x75, 0x51, 0x75, 0x93, 0x6b, 0x36, 0xd0, 0x9c, 0x42, 0xcf, 0xfc, 0x87, 0x98}} + info := bindataFileInfo{name: "privateForwarder/create_account_private_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc6, 0xe5, 0xb, 0x42, 0xd1, 0x1d, 0x59, 0x77, 0x2, 0x91, 0xe3, 0xb5, 0x15, 0x41, 0xd8, 0x35, 0x45, 0xf5, 0x8c, 0xf2, 0x8b, 0x98, 0x2f, 0x5e, 0xc0, 0x2, 0x91, 0x4a, 0x37, 0x9d, 0xf9, 0x81}} return a, nil } -var _scriptsGet_supported_vault_typesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x53\x4f\x6b\xdb\x4e\x10\xbd\xeb\x53\x3c\x7c\xf8\x45\x82\x1f\xf2\xdd\xb4\x0d\x69\xa1\xf4\x18\x92\xb4\x67\xad\x56\x23\xef\x92\x95\x46\xcc\x8e\x22\x8c\xf1\x77\x2f\x2b\xd9\x8d\x65\x12\x9f\xcc\x68\xde\x9f\x7d\x33\xe3\xbb\x81\x45\xf1\x73\xec\xf7\xbe\x0e\xf4\xc2\xaf\xd4\xa3\x15\xee\xb0\x59\xd5\x36\x59\xb6\xdd\x6e\xf1\xe2\x7c\x44\xb4\xe2\x07\x8d\x10\xd2\x51\xfa\x08\x75\x84\x38\x0e\x89\x88\x9a\x35\xd5\x5d\x84\x1e\x06\x42\x7d\x98\xbb\x06\xe1\x37\xdf\x50\x83\x4a\x8d\xec\x49\x2b\x98\xa6\x11\x8a\xb1\x9c\xd9\x6f\xab\x88\x8e\xc7\xd0\xc0\x71\x68\x66\xbc\x35\x83\xa9\x7d\xf0\x7a\xc0\xe4\xbc\x75\xb0\xdc\xb7\x2c\x5d\xc4\xe4\xd5\xad\xa5\xcb\x27\xb2\xe4\xdf\x48\x20\x14\x55\xbc\x4d\xe6\x92\x99\x59\x6a\x72\x3e\x10\xbc\xa2\x61\x8a\xfd\x9d\xa2\x33\xaa\x24\x98\x1c\xa9\x23\xb9\x56\x12\x6a\x49\x22\x94\xd1\x9e\xf9\xa1\x73\x4c\x2c\x30\xb0\x63\x54\xee\x20\x17\xb1\xe0\x5f\x09\xcb\x6b\x56\x76\x9e\x27\xaf\xd6\xd5\x6c\xa4\xa9\x12\xb2\x9a\xab\x17\x8f\x55\x89\x5f\x3c\x51\x22\x38\x87\xf0\x68\xd4\x55\x50\x0a\x21\x26\x53\x42\xb7\x01\x44\x65\xa1\x98\x0d\x63\x9d\x7c\xa1\x33\xbe\xcf\x17\xe8\x0e\x0f\x4b\x7e\xff\xe3\x9d\x6b\x87\xc7\xb1\x0e\xde\xa6\xff\xc5\x0e\xc7\x97\xc3\x40\x3b\x7c\x67\x0e\x27\x1c\xb3\x0c\x00\xb6\x5b\x3c\x58\x9b\x72\xbf\x91\x6a\x59\xd6\xe3\x5b\x68\x2f\x63\x9a\xc1\x81\xf4\x0a\xf2\x44\x2d\xbe\x62\x4f\xfa\x60\x2d\x8f\xbd\x9e\x9d\x15\x73\xeb\xed\xaf\xdc\x93\xfe\xf8\x07\xfd\xf2\xdf\xf1\xe3\x39\x9e\xbe\xe5\xef\xcf\xf9\x84\xa9\x66\x11\x9e\xf2\x02\x1f\x7e\xbe\xbf\xc7\x60\x7a\x6f\xf3\xcd\xef\xde\x2c\x73\xc4\x82\x58\x6d\x56\x5a\xa5\xab\x9d\x89\x63\xbd\x2c\xf1\x67\xbe\x96\x7b\x19\x8c\xba\x4d\x69\xb9\xb7\x46\xaf\x8c\x96\xca\xcf\x2a\xbe\xdf\xe7\x45\x51\x5c\x62\x7e\x9a\x2f\xe7\xe6\x70\xde\xcc\x18\x74\x56\x8a\xe5\xdc\xb8\xdc\xd7\x3a\xd5\x94\xd5\xf3\x05\xf2\x27\x21\xd2\x20\x63\x5e\x64\xa7\xbf\x01\x00\x00\xff\xff\x4f\x63\x8b\x60\xcb\x03\x00\x00" +var _privateforwarderCreate_private_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x54\x4f\x6f\xe2\x3e\x10\xbd\xe7\x53\xbc\x1f\x87\xfe\x12\x89\x86\x3b\xa2\xad\x56\xec\x56\xda\xc3\xae\xaa\x2d\xe2\x3e\x98\x29\xb1\xd6\xb5\x23\x7b\x12\xb6\xaa\xfa\xdd\x57\x4e\x48\x48\x5a\x90\xe8\xfa\x80\x60\xc6\x7e\xf3\xfe\xd8\xe8\xe7\xd2\x79\xc1\xe4\xbe\xb2\x3b\xbd\x31\xbc\x72\xbf\xd9\x4e\x92\xae\xfc\xed\x0f\x3d\x97\x1f\xaa\x0f\x5e\xd7\x24\xfc\x8b\x15\xeb\x9a\xfd\xbd\xf3\x7b\xf2\x5b\xf6\xc7\x1d\x23\xb8\x1f\x2c\xb4\x25\xa1\xb5\xe6\x7d\x98\x24\xc9\x6c\x86\x55\xa1\x03\xc4\x93\x0d\xa4\x44\x3b\x0b\xe5\x99\x84\x03\x08\x96\xf7\x28\xdb\x01\xf0\x87\x09\xd0\x16\x64\x41\x4a\xb9\xca\x0a\xa4\x20\x41\x84\xd9\x3a\x0e\xf6\x7f\x01\x19\xcf\xb4\x7d\x41\x41\x35\x83\x3e\x1e\x77\x3e\x56\xab\x8d\xd1\x0a\x12\x29\xf5\xad\x88\xb2\xa9\xa4\x41\x7a\x0f\xb3\xa6\xca\x48\x92\x0c\x69\xbe\x26\x09\x00\x94\x9e\x4b\xf2\x9c\x06\xbd\xb3\xec\xe7\xa0\x4a\x8a\xf4\x7b\x08\x15\x3f\x8a\xf3\xb4\xe3\x25\x95\xb4\xd1\x46\xcb\xcb\xd2\x59\xf1\xce\x18\xf6\x53\x3c\x44\x06\xa1\x38\x36\xa7\x78\xa4\x9a\xd7\x64\x2a\xce\x70\xf5\xa5\x95\x97\x75\x53\xe2\x32\x2c\xa8\x23\x8f\xaf\x24\x84\x1b\x0c\x03\xc9\x3d\x07\x67\x6a\x6e\x46\x90\x92\xe8\x6f\x1a\x6b\x95\x57\xbc\x7a\x29\x79\x0e\xab\xcd\x14\xb5\xe6\x7d\xfb\x33\x7e\x2e\xce\x67\x93\xdf\xaf\xd6\xdd\xac\xdb\x34\xcb\x40\xe1\x3f\x5c\xb6\xfd\xae\x67\x1c\xd7\xdd\x1d\x4a\xb2\x5a\xa5\x93\xa5\xab\xcc\x16\xd6\x09\x76\x9d\x12\x44\x80\x86\x14\x9e\x9c\x87\x14\x0c\x75\x50\x30\xc9\x8e\xca\x67\x33\x34\x8e\x82\xd0\x5d\x34\x1c\x9d\x83\x90\xdf\xb1\x88\xb6\xbb\x06\x61\xe8\xcb\x21\xb8\xa1\x85\x5d\xdc\x03\x80\x1b\xb4\xe9\xe5\xaa\xab\x69\x0e\x79\x68\xf3\xcb\x75\x1c\xbd\xb8\x7a\x1d\xa9\xcf\x3b\x22\x6f\xb7\xe9\x48\x6f\x9f\x50\x77\xfe\x81\xa4\xe8\x77\x64\x43\x4d\xcb\xe6\xa2\x37\x9c\xfb\x77\x83\x2e\xb4\x11\xe7\xa7\xbe\xbd\xb8\xc6\xb9\x27\x97\xb7\x0f\xe7\x27\xef\xfb\x52\xea\x59\xe9\x52\xb3\x95\xf9\x09\xdd\x23\x32\xf1\xf6\x9d\xa1\x02\x71\x38\x88\xe9\x4f\x1c\x0c\xeb\x3c\x0a\x54\x73\xba\xb8\xee\x79\x4e\x21\x6e\x7e\x9e\xe9\xbb\xc6\xe3\xd1\xa9\xec\x54\xe8\xc3\xac\xdd\xa7\xfc\x5a\x52\x79\x59\xba\x67\xa9\xf6\xdf\xde\xe5\x1c\xd7\x3f\xe8\x1b\x61\x8c\xc4\x1e\xfe\x11\x1a\x79\x9f\x12\x7c\x4a\x5d\xd9\x82\x8d\x29\x0f\x5d\x99\x8e\x3a\x24\x97\x87\xd5\xf0\x54\x27\x6e\xf5\x5b\xf2\x96\xfc\x0d\x00\x00\xff\xff\xfa\xff\xed\x29\x44\x06\x00\x00" -func scriptsGet_supported_vault_typesCdcBytes() ([]byte, error) { +func privateforwarderCreate_private_forwarderCdcBytes() ([]byte, error) { return bindataRead( - _scriptsGet_supported_vault_typesCdc, - "scripts/get_supported_vault_types.cdc", + _privateforwarderCreate_private_forwarderCdc, + "privateForwarder/create_private_forwarder.cdc", ) } -func scriptsGet_supported_vault_typesCdc() (*asset, error) { - bytes, err := scriptsGet_supported_vault_typesCdcBytes() +func privateforwarderCreate_private_forwarderCdc() (*asset, error) { + bytes, err := privateforwarderCreate_private_forwarderCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/get_supported_vault_types.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x86, 0x41, 0x9, 0x4e, 0xa9, 0xac, 0x75, 0xc, 0x1d, 0x13, 0xf3, 0xf8, 0x1a, 0xc, 0xec, 0x9a, 0x27, 0x4f, 0x77, 0x1c, 0xd1, 0x65, 0x9f, 0x27, 0xd2, 0x91, 0x3e, 0x83, 0xa9, 0x98, 0xc2, 0xfb}} + info := bindataFileInfo{name: "privateForwarder/create_private_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x26, 0x48, 0x67, 0xa0, 0x21, 0xff, 0x4a, 0x17, 0x0, 0xac, 0xe9, 0xbd, 0x40, 0xab, 0xae, 0x68, 0xc0, 0x8a, 0xb3, 0x89, 0xf9, 0x1c, 0x88, 0x82, 0xff, 0xe5, 0xff, 0x76, 0x8a, 0xc6, 0x2e, 0xce}} return a, nil } -var _scriptsMetadataGet_token_metadataCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x90\xc1\x6e\xf2\x30\x10\x84\xef\x7e\x8a\x51\x0e\xbf\xc2\x85\x07\x40\x3f\x45\x08\x95\x5b\x25\x84\x10\xf7\x4d\xb2\x09\x56\x1d\x3b\x72\xd6\xd0\x0a\xf1\xee\x55\x88\x13\xd2\xaa\x25\x97\xd8\xeb\xf9\x46\xb3\xa3\xeb\xc6\x79\xc1\xeb\x07\xd5\x8d\xe1\x83\x7b\x67\x8b\xd2\xbb\x1a\xc9\x74\x94\xa8\xa8\xdb\x06\x5b\xe9\x2c\x4e\xdf\x58\xa8\x20\xa1\xa3\xe6\x4b\x1b\xa9\xbf\x05\xa3\xc7\x6f\xd8\x0f\xa5\x6a\x42\x86\x32\x58\xd4\xa4\x6d\x4a\x45\xe1\xb9\x6d\x17\x58\xf7\x87\xd9\xe2\x49\x8e\xf9\xf6\xd0\xfd\x71\x55\x00\x60\x58\x40\x79\xee\x82\x15\x2c\x51\xb1\xac\xfb\xcb\xe0\x39\x53\xa3\xec\x4c\xc1\xc8\x9e\x4b\x2c\x07\xe2\xfe\xd4\x7d\xf3\x8a\x65\x43\x0d\x65\xda\x68\xf9\x4c\xa7\xcd\xcc\x8f\x1d\xb6\x0b\x99\xd1\xf9\x8e\xe4\x34\x7b\x40\x99\xf3\xde\x5d\xfe\xff\xbb\x7e\xcf\xb7\xe7\xd6\x99\x33\xfb\xdb\x4b\xfa\x10\xaf\x56\x68\xc8\xea\x3c\x4d\x36\x2e\x98\x02\xd6\x09\x7a\x1e\x04\xcf\x25\x7b\xb6\x39\x43\x1c\xe4\xc4\x7d\x54\xf8\x68\x94\x4c\x96\x28\xe5\xbe\xfc\xf2\x59\x41\x15\x4b\xdf\x51\x7a\xd6\x7c\x19\xe2\x2c\xc6\x02\xa2\x9d\x67\x09\xde\x46\x47\x75\x53\x5f\x01\x00\x00\xff\xff\xb0\x79\xad\x83\x2a\x02\x00\x00" +var _privateforwarderDeploy_forwarder_contractCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x8f\xc1\x4a\x03\x31\x10\x86\xef\x79\x8a\x39\xc9\x2e\x84\xee\x55\xf6\x56\x14\xc1\x8b\x14\xaa\x27\xf1\x30\x26\xe3\xee\x60\x3b\x09\x93\x59\x8a\x48\xdf\x5d\xb6\xdd\x2e\xab\x5e\x9a\x43\x48\xc8\xf7\x67\xfe\xaf\x69\x1a\xb8\xa7\xbc\x4b\x5f\x05\xac\x27\x78\x4e\x9f\x24\x0f\x49\x0f\xa8\x91\xa5\x83\x90\xc4\x14\x83\xc1\x81\xad\x3f\x11\x25\x53\xe0\x0f\xa6\x08\x2c\x6c\x90\x51\x71\x4f\x46\x5a\x9c\x33\x45\x29\x18\x8c\x93\x54\x97\xe0\x13\xee\xa9\x85\xad\x29\x4b\xe7\x1d\x2c\x56\x48\x91\x5a\x78\x7d\x79\x14\xbb\x7d\xfb\xfd\x54\x48\x22\xe9\xd6\x92\x62\x47\x1b\xb4\x7e\xfc\x61\xbe\xfc\x61\xaf\xa2\xf2\xf0\xbe\xe3\x70\x86\x36\xf3\xb9\x86\x6f\xe7\x00\xb2\x52\x46\xa5\xaa\x70\x27\xa4\x2d\xe0\x60\x7d\xb5\x8e\xf1\x6e\x72\xa8\xe1\x66\x1d\x42\x1a\xc4\xa6\x00\xc0\x19\x5d\x5d\x2c\xcb\x0a\x63\xac\xe4\xe4\xba\x34\xf7\x93\xe5\xb8\xfb\xff\x5a\x7e\xd9\xde\x2f\x4a\xd6\xe3\x94\xa3\x3b\x3a\x70\x3f\x01\x00\x00\xff\xff\xb6\x45\x50\xb4\xa2\x01\x00\x00" -func scriptsMetadataGet_token_metadataCdcBytes() ([]byte, error) { +func privateforwarderDeploy_forwarder_contractCdcBytes() ([]byte, error) { return bindataRead( - _scriptsMetadataGet_token_metadataCdc, - "scripts/metadata/get_token_metadata.cdc", + _privateforwarderDeploy_forwarder_contractCdc, + "privateForwarder/deploy_forwarder_contract.cdc", ) } -func scriptsMetadataGet_token_metadataCdc() (*asset, error) { - bytes, err := scriptsMetadataGet_token_metadataCdcBytes() +func privateforwarderDeploy_forwarder_contractCdc() (*asset, error) { + bytes, err := privateforwarderDeploy_forwarder_contractCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/metadata/get_token_metadata.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2e, 0x89, 0xb8, 0x68, 0xb4, 0x7b, 0x3a, 0xf1, 0x23, 0xb6, 0xba, 0xd6, 0x20, 0xb4, 0xe5, 0x36, 0x8d, 0xa, 0xda, 0x17, 0xe9, 0x2, 0x38, 0x9c, 0x1b, 0x23, 0x3f, 0xf3, 0xca, 0xe2, 0x63, 0x66}} + info := bindataFileInfo{name: "privateForwarder/deploy_forwarder_contract.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x16, 0x7f, 0x10, 0x12, 0xa4, 0xc2, 0xb6, 0x67, 0x4e, 0x42, 0xbd, 0x4e, 0xe5, 0x57, 0xd4, 0x8, 0xc8, 0x9d, 0x79, 0xd0, 0x13, 0x4e, 0x7e, 0x14, 0xe3, 0x37, 0x17, 0x7a, 0x3a, 0xb, 0x3b, 0x67}} return a, nil } -var _scriptsMetadataGet_vault_dataCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\xcd\x6e\xc2\x30\x10\x84\xef\x7e\x8a\x51\x0e\x55\xb8\xf0\x00\xa8\x14\x21\x5a\x6e\x95\x10\x42\xdc\x37\xc9\x26\x58\x75\xec\xc8\x59\x43\x2b\xc4\xbb\x57\xe4\x87\xa4\x88\x92\x53\xb2\x99\x59\x7f\x33\xb2\x2e\x2b\xe7\x05\x1f\xdf\x54\x56\x86\x77\xee\x8b\x2d\x72\xef\x4a\x44\xe3\x51\xa4\x3a\xdd\x3a\xd8\x42\x27\xdd\xf4\x93\x85\x32\x12\xda\x6b\x3e\xd5\x9d\xeb\x7f\xc1\x6d\xc7\x23\xdb\x9d\x52\x55\x21\x41\x1e\x2c\x4a\xd2\x36\xa6\x2c\xf3\x5c\xd7\x33\x2c\xdb\x97\xc9\xec\x09\xc7\x74\xbd\xdb\x53\x30\xf2\x4e\x42\x38\x2b\x00\x30\x2c\xa0\x34\x75\xc1\x0a\xe6\x28\x58\x96\xed\x47\xbf\x78\xa2\x6e\xb2\xe3\xd5\xba\xe5\x1c\xf3\xde\xd1\xfc\xba\x3e\xd3\x82\x65\x45\x15\x25\xda\x68\xf9\x89\xc7\xf5\x4c\x9b\x13\x37\x21\x31\x3a\xdd\x90\x1c\x26\x83\x29\x71\xde\xbb\xd3\xeb\xcb\xf9\x2f\xe4\x96\x6b\x67\x8e\xec\x2f\x6f\xf1\x20\x5e\x2c\x50\x91\xd5\x69\x1c\xad\x5c\x30\x19\xac\x13\xb4\x7e\x10\x3c\xe7\xec\xd9\xa6\x0c\x71\x90\x03\xb7\xa8\xf0\xdd\xa2\xe8\x3e\x44\x93\x7f\xfe\xac\xa8\x82\x65\xd4\x55\xdc\x47\x7f\xc4\xd3\xde\x8b\xcc\x71\xdd\x40\xe9\x6b\xf2\x92\xad\x60\x5c\xf6\x51\xf3\xa9\xc7\xf0\x2c\xc1\xdb\x81\x44\x5d\xd4\x6f\x00\x00\x00\xff\xff\x7c\x3d\xc8\xc1\x6a\x02\x00\x00" +var _privateforwarderSetup_and_create_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x55\x4f\x6f\xda\x30\x14\xbf\xe7\x53\xbc\x71\x40\x89\x94\xc2\x1d\x01\xdd\xc6\x5a\x69\x87\x4d\xd5\x8a\xb8\x3f\x9c\x07\x58\x0d\x76\x64\xbf\xc0\x50\xc5\x77\x9f\xec\x90\x10\x97\xb0\xd2\xfa\x50\x15\xc7\x7e\xbf\x3f\xef\x8f\x23\xb9\x2d\xb4\x61\xe8\x3d\x96\x6a\x2d\x97\x39\xcd\xf5\x0b\xa9\x5e\xb3\xfd\xf0\x17\xb7\xc5\xc5\xee\x93\x91\x3b\x64\xfa\x43\x82\xe4\x8e\xcc\xa3\x36\x7b\x34\x19\x99\x5e\x77\xb8\x5f\xc4\x98\x21\xe3\x42\xd2\xde\xf6\xa2\x68\x38\x1c\xc2\x7c\x23\x2d\xb0\x41\x65\x51\xb0\xd4\x0a\x30\xcb\x2c\x20\x2c\xb0\xcc\x39\x05\x84\xa2\xc2\x00\x73\x02\x81\x55\x8d\xe2\xef\x23\x2c\x31\x47\x25\x08\x04\x16\xb8\x94\xb9\xe4\x43\x0a\xa8\x32\x77\xb5\x5c\xe6\x52\xb4\x3e\xb8\xbb\xc0\x9b\x73\xb0\x28\x6a\x43\xbf\x46\x11\x00\x40\x61\xa8\x40\x43\xb1\x95\x6b\x45\x66\x04\x58\xf2\x26\xfe\x69\x6d\x49\xcf\xac\x0d\xae\x69\xd6\x04\x9c\x69\xc5\x46\xe7\x39\x99\x14\x9e\x1c\x9a\xdd\xcc\x5a\x34\x9e\x71\x47\x0b\xcc\x4b\x4a\xa0\xff\x4d\x08\x5d\x2a\x4e\xe0\xd5\x83\xb8\x95\x13\xc3\xce\xe9\xfc\x81\x8c\x30\x81\xb6\xc9\x03\x43\x56\xe7\x3b\xf2\x08\x28\xd8\x79\x16\xbb\xbd\xd2\x08\x9a\x1f\x0a\x1a\x81\x92\x79\x0a\x3b\x49\xfb\xea\xa7\xfb\x3b\xbe\xee\xf7\xe0\x71\xbe\xa8\xb1\xa6\x71\x92\x00\xda\x2f\x70\xdb\xf1\xfb\x86\xb1\x5b\xf7\xf7\x50\xa0\x92\x22\xee\xcd\x74\x99\x67\xa0\x34\xc3\xba\x56\x02\x2e\x80\x27\xd5\x78\x2d\x4e\x0a\x7a\x49\xd4\xc4\x91\x2b\xa8\xdc\x1d\x34\xc9\x91\x64\x07\x6b\xe2\x71\xff\x5a\x51\x0d\x9a\xff\xa6\xf1\xd5\x33\x6f\x3e\xf8\x9c\x88\x27\xe4\x4d\x32\x10\x1b\x12\x2f\x71\xdb\x7f\xb7\x86\xc3\xa6\xc2\x9a\xc2\x82\x3d\x5a\xc0\xdc\x10\x66\x07\xb0\xc4\x50\x16\xc1\x1d\x43\x5c\x1a\xd5\x6c\x1d\xbb\x74\xd9\xaa\x54\x2a\xd4\x71\x3f\x48\xad\x37\x76\x1a\xaf\x8c\xde\x8e\xce\x05\x50\x5f\xf1\x6c\x61\x32\x81\x15\xe6\x96\x2e\xe9\xce\x0c\x39\xb6\x08\x8a\xf6\x41\xc9\x54\x3d\xe3\x6b\xbf\x28\x19\x24\x83\x54\x70\x0a\x1a\x04\x79\x43\xd1\xe2\x8e\xe2\xe0\x80\x5b\xe3\xbb\x80\xb3\xf0\xa8\x0f\xdb\x82\x0f\x1e\x26\xf6\xbc\x5b\x95\xf7\xb5\x4b\x62\x92\xa4\x17\x81\x59\x5f\x11\x1d\x9c\x4c\xba\xec\x6d\xab\x3f\x35\x77\xa5\xf9\xdc\x74\x2e\x05\x8a\x28\xa3\xec\xbd\x62\x5b\x6a\x63\xf4\x7e\xdc\x7f\x0d\x9a\xa0\x62\x7e\x9c\xc6\x67\x8a\xdb\x53\x5f\x34\x89\x51\x32\x7f\x93\x96\xa6\x93\x67\x58\xc0\xa4\x13\xae\x76\x5b\xba\x41\x72\x81\xfa\xbd\x1a\x62\x29\x74\x93\xb9\x30\xd1\xad\xf7\x4d\x0c\x8d\x6c\xa5\x3e\x60\x56\x54\x83\x2b\xae\x05\xa4\x80\xdc\x4e\x51\xa0\xff\x4a\x5a\xfc\x78\x04\x84\xba\xf1\xda\x19\x61\x34\x6b\x62\x96\x6a\xed\xe7\xc1\x65\xc9\x06\x03\xb1\x1e\xcd\xad\x00\x9f\x31\xb4\x26\xd2\x65\xde\x2d\xd5\x17\x70\x3a\x4f\x86\xf1\x1d\x5c\x9d\x3d\x55\x8b\xfc\xa6\x7d\xb3\x15\x1b\x12\xb2\x90\xa4\x78\xd4\xa1\xab\x05\xd2\xd5\x91\xe3\xbb\x06\x36\xf5\x4d\x73\xeb\xd0\x7b\x6e\xcd\x91\xce\x24\xb5\x73\xa3\x7d\x4e\x9a\x58\x50\x3f\x31\xdd\xfa\x6f\x2e\xef\x5b\x86\xf8\x45\x5e\x3e\x21\xf0\xca\xcc\x18\x0e\xeb\xe7\xd8\xcb\xfb\x90\xe0\xff\xb5\x48\x00\xd7\x76\x25\x1c\x73\xae\x7f\x3e\xfe\x44\x45\xa1\x8e\x63\x74\x8c\xfe\x05\x00\x00\xff\xff\x68\x6d\x8c\xbf\x97\x09\x00\x00" -func scriptsMetadataGet_vault_dataCdcBytes() ([]byte, error) { +func privateforwarderSetup_and_create_forwarderCdcBytes() ([]byte, error) { return bindataRead( - _scriptsMetadataGet_vault_dataCdc, - "scripts/metadata/get_vault_data.cdc", + _privateforwarderSetup_and_create_forwarderCdc, + "privateForwarder/setup_and_create_forwarder.cdc", ) } -func scriptsMetadataGet_vault_dataCdc() (*asset, error) { - bytes, err := scriptsMetadataGet_vault_dataCdcBytes() +func privateforwarderSetup_and_create_forwarderCdc() (*asset, error) { + bytes, err := privateforwarderSetup_and_create_forwarderCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/metadata/get_vault_data.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd1, 0x5d, 0x35, 0x37, 0x9c, 0x20, 0x9d, 0x73, 0xe, 0x3d, 0x27, 0x8c, 0xc3, 0x42, 0xe, 0xda, 0x6e, 0x97, 0xb7, 0xef, 0x97, 0xc1, 0x94, 0x44, 0x1, 0x48, 0xae, 0x3b, 0xc1, 0xc9, 0x9, 0xfd}} + info := bindataFileInfo{name: "privateForwarder/setup_and_create_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9f, 0xdc, 0xa7, 0xd7, 0x2c, 0x81, 0x40, 0x8e, 0x48, 0xde, 0xea, 0x9e, 0x9f, 0xb2, 0x76, 0x7, 0xff, 0xe4, 0x77, 0x6d, 0x40, 0x8c, 0x2d, 0x7f, 0x40, 0x9e, 0xd7, 0x2b, 0x8d, 0xb2, 0xba, 0x71}} return a, nil } -var _scriptsMetadataGet_vault_displayCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\xc1\x6e\xc2\x30\x10\x44\xef\xf9\x8a\x51\x0e\x55\xb8\xf0\x01\xa8\x14\x21\x5a\x6e\x95\x10\x42\xdc\x37\xc9\x26\x58\x75\x6c\xcb\x5e\x43\x11\xe2\xdf\x2b\x48\x42\x68\x45\xc9\x29\x5e\xcf\xac\xde\x8c\xac\x1a\x67\xbd\xe0\xe3\x9b\x1a\xa7\x79\x63\xbf\xd8\xa0\xf2\xb6\x41\x7a\x3f\x4a\x93\x4e\xb7\x8c\xa6\x56\x79\x37\xfd\x64\xa1\x92\x84\xb6\x8a\x0f\xa1\x73\xfd\x2f\xb8\xed\x78\x64\xfb\xa3\x4c\x5c\xcc\x51\x45\x83\x86\x94\xc9\xa8\x2c\x3d\x87\x30\xc1\xbc\xfd\x19\x4d\x9e\x70\x8c\x97\x9b\x77\x15\x9c\xa6\x23\x4e\x09\x00\x68\x16\x50\x51\xd8\x68\x04\x53\xd4\x2c\xf3\xf6\xd0\xaf\x1d\x25\x37\xd9\x9e\xa2\x96\x35\x57\x98\xf6\x8e\xeb\xd5\xe5\x1b\xd7\x2c\x0b\x72\x94\x2b\xad\xe4\x98\xdd\x97\x33\xde\x5e\x6c\xab\x98\x6b\x55\xac\x48\x76\xa3\xc1\x94\x5b\xef\xed\xe1\xf5\xe5\xf4\x1b\x71\xcd\xc1\xea\x3d\xfb\xf3\x5b\x36\x88\x67\x33\x38\x32\xaa\xc8\xd2\x85\x8d\xba\x84\xb1\x82\xd6\x0f\x82\xe7\x8a\x3d\x9b\x82\x21\x16\xb2\xe3\x16\x15\xbe\x5b\x94\xde\x85\xa8\xa4\xcf\x3f\x7d\x56\x53\xcd\x72\x6b\x2a\xeb\x83\x3f\xa2\x69\xdf\x44\x69\x39\x5c\x91\xd4\x25\x77\xc3\x46\x30\x14\xbd\x57\x7c\xe8\x11\x3c\x4b\xf4\x66\xa0\x48\xce\xc9\x4f\x00\x00\x00\xff\xff\x0a\x42\x8f\xe8\x64\x02\x00\x00" +var _privateforwarderTransfer_private_many_accountsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x54\xcd\x6e\x9b\x40\x10\x3e\x87\xa7\x98\xf8\x90\x82\x94\xe2\x4b\xd5\x03\xca\x8f\xd2\xb4\xee\x29\x52\x94\xb8\xee\xa1\xea\x61\x02\x63\x58\x05\xef\xa2\xd9\xc1\x24\x8a\xfc\xee\xd5\xb2\x8b\x83\x9b\x5a\x6e\xa5\xfa\x60\x60\x34\xfb\xcd\xf7\x33\x5a\xb5\x6a\x0c\x0b\x4c\x66\xad\x2e\xd5\x43\x4d\x73\xf3\x48\x7a\x12\x0d\xe5\x2f\x4f\xb8\x6a\xde\x54\x6f\x59\xad\x51\xe8\x8e\x72\x52\x6b\xe2\x99\xe1\x0e\xb9\x20\x7e\xed\xd8\x81\xbb\x21\xc1\x02\x05\x17\x8a\x3a\x3b\x89\xa2\xe9\x74\x0a\xf3\x4a\x59\x10\x46\x6d\x31\x17\x65\xb4\x7f\x5f\x12\x5b\x10\x03\x2b\xd4\xcf\x80\x45\xc1\x64\x2d\x59\x90\x8a\x4d\x5b\x56\x20\x15\x29\x86\xc6\x4f\x07\x0e\xe3\x6d\x14\x8d\x80\xe2\x70\xec\x6a\x65\x5a\x2d\x37\xd8\x64\xf0\x72\xe5\x4b\x19\x7c\x9b\xa9\xa7\x8f\x1f\x36\x09\xbc\x44\x11\x00\x40\x4f\x84\x60\x81\x6d\x2d\xc0\x64\x4d\xcb\x39\x81\x54\x28\x50\x99\xba\x70\x93\x09\xc4\x69\xb0\xbe\x8a\x4c\xf0\x40\x4a\x97\x5b\xbe\x4c\x45\x0f\x55\x93\xc0\xda\xe1\xdc\xd1\x32\x03\x6c\xa5\x8a\x77\x4c\x48\xbf\x2b\xa9\x0a\xc6\x2e\x81\x93\xb1\xab\x69\x3f\x3c\xda\x62\x04\x75\xc1\x53\xa5\xcb\x7b\xd2\x05\x71\x06\x27\xfb\x5c\x4f\x7d\x87\x87\x68\x98\x1a\x64\x8a\xad\x2a\xb5\x3b\xd5\x13\xf9\x64\x98\x4d\xb7\xc0\xba\xa5\x04\x4e\xae\xf2\xdc\x59\xb3\x35\x61\x87\xfd\x67\x14\x84\x73\xd8\x61\xe8\x8c\xa9\xd7\x74\x6d\xb4\x30\xe6\xe2\x62\x8c\x07\xb3\xe6\xcf\x0d\x65\xa0\x55\x7d\x0a\x6b\x45\x9d\xff\x74\xff\x67\xfb\x57\x20\x9d\xcd\x17\xc3\xac\x8b\x38\x49\x00\xed\x31\xfc\x5d\xfb\xe5\x96\xb1\xfb\x5d\x5e\x42\x83\x5a\xe5\xf1\xe4\xda\xb4\x75\x01\xda\x08\x94\x83\x12\x70\x00\x3d\x29\x58\x1a\xee\x93\xcc\x83\x82\x49\xf2\xaa\x7c\x3a\x85\xaf\x24\x80\xc0\xb4\x24\x26\xed\xf2\x37\x7d\xb7\xb7\xf0\x9d\x05\x2b\x86\xa9\xf0\xa8\xdb\x73\x96\xea\x65\x3a\x04\x0e\xe7\xa1\x3b\x75\xbd\x58\x52\xfa\xd0\x5b\x7e\xf6\xaf\x7b\x70\x11\x2f\xd9\xac\xb2\xd7\x2c\x06\xc0\x5b\x94\x2a\x89\x8e\x8e\x8e\xfe\xa4\xd9\x0f\x7b\xab\xc0\x74\x5e\x40\x0f\x7d\x3c\x56\xdd\xb3\xdf\xb3\x6a\x7b\xc5\x1c\xda\xc0\x81\xfc\x81\xb6\xfb\xff\xae\x68\xe3\x1f\xf4\x44\x79\x2b\x34\xde\x6b\x97\x7c\xb8\x10\x40\x69\xf8\xfd\x6e\x48\x1f\xe9\xd9\x8e\xfb\x0f\x79\x93\x5a\xd2\x45\xd0\xd7\xc7\x66\x87\xfb\xe6\x34\xdc\x13\x19\x9c\xbd\xdf\xd9\x8d\xb4\x0b\x81\xc7\xd8\x8f\xcd\xde\xb0\xf8\x11\x0a\x3f\x8f\x93\x51\x44\x9b\x20\x6d\x13\xfd\x0a\x00\x00\xff\xff\xfe\x05\x59\x4b\xa4\x05\x00\x00" -func scriptsMetadataGet_vault_displayCdcBytes() ([]byte, error) { +func privateforwarderTransfer_private_many_accountsCdcBytes() ([]byte, error) { return bindataRead( - _scriptsMetadataGet_vault_displayCdc, - "scripts/metadata/get_vault_display.cdc", + _privateforwarderTransfer_private_many_accountsCdc, + "privateForwarder/transfer_private_many_accounts.cdc", ) } -func scriptsMetadataGet_vault_displayCdc() (*asset, error) { - bytes, err := scriptsMetadataGet_vault_displayCdcBytes() +func privateforwarderTransfer_private_many_accountsCdc() (*asset, error) { + bytes, err := privateforwarderTransfer_private_many_accountsCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/metadata/get_vault_display.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2b, 0x88, 0xc5, 0xf0, 0xf3, 0x55, 0x38, 0xcc, 0xbc, 0x76, 0xcb, 0xd1, 0x4d, 0x6, 0xc7, 0x35, 0xf1, 0x9f, 0x3c, 0x68, 0x4e, 0xb0, 0x5f, 0x41, 0x46, 0x28, 0x24, 0xe0, 0x82, 0xc1, 0xe4, 0xad}} + info := bindataFileInfo{name: "privateForwarder/transfer_private_many_accounts.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8d, 0xde, 0xed, 0x59, 0xfa, 0x7b, 0x94, 0xe8, 0xfa, 0x8b, 0xe5, 0xca, 0xbb, 0x8f, 0xf8, 0x15, 0x7f, 0xfd, 0xf9, 0xfc, 0x8f, 0x43, 0x7b, 0x71, 0xc2, 0x7f, 0x53, 0xb5, 0xf6, 0xfa, 0xc8, 0x53}} return a, nil } -var _scriptsMetadataGet_vault_supply_viewCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x92\x41\xef\x9a\x40\x10\xc5\xef\xfb\x29\x46\x0e\x2d\x5c\xf0\xd2\xf4\x60\x44\x63\x4c\xed\xa9\x89\xb1\xd6\xfb\x02\x83\x6e\xba\xec\x6e\x76\x67\x55\x62\xfc\xee\x0d\x2c\x02\x6d\xea\x9f\xd3\x32\xfb\xde\x6f\x98\x37\x88\xda\x68\x4b\xf0\xed\xce\x6b\x23\xf1\xa8\x7f\xa3\x82\xca\xea\x1a\xa2\x69\x29\x62\xbd\x6e\xe7\xd5\x59\xe4\x7d\xf5\x07\x12\x2f\x39\xf1\x93\xc0\x9b\xeb\x5d\xef\x05\x03\xe3\x7f\xb6\x7f\x94\x6c\x3e\x9f\xc3\x77\x24\x07\x74\x41\x20\x4d\x5c\x82\xf3\xc6\xc8\x06\x74\xd5\xd5\xae\xdc\x4b\xfa\xec\x80\xba\x2f\x2e\x85\xc5\x82\x64\x13\x68\xc3\x3d\x63\xc6\xe7\x50\x79\x05\x35\x17\x2a\xe6\x65\x69\xd1\xb9\x05\x6c\xc2\x21\x59\xc0\xaf\x9d\xb8\x7f\xfd\x02\x0f\x06\x00\x20\x91\x80\x17\x85\xf6\x8a\x20\x83\x33\xd2\x26\xbc\xbc\x8c\x09\x1b\x64\x1d\xfe\x80\x15\x64\x2f\x47\x77\xd5\x3e\xe9\x19\x69\xcb\x0d\xcf\x85\x14\xd4\xc4\xd3\x18\xd3\x53\x6b\xdb\xfb\x5c\x8a\x62\xcf\xe9\x92\x8c\xa6\x5c\x5b\xab\x6f\xcb\x4f\x8f\xbf\x92\x48\x0f\xe8\xb4\xbc\xa2\x7d\xae\xe2\x51\xbc\x5e\x83\xe1\x4a\x14\x71\xb4\xd5\x5e\x96\xa0\x34\x41\xf0\x03\x07\x8b\x15\x5a\x54\x45\x1b\xdb\x98\x04\xd8\x1e\x14\x4d\x86\xa8\xe8\x67\xc8\x34\x1b\xe6\x49\x7b\x5d\xdb\x3d\x3e\x36\x06\x97\xef\x17\x9a\x1e\xdb\xbd\x04\xc4\x2a\x4e\x92\xd9\x48\x0e\xbb\x6a\x55\x90\x8d\x6d\xb8\x9b\x7d\xf0\x03\x4d\x71\x81\x64\x91\xbc\x55\x13\x58\x1a\x8e\xec\xc9\xfe\x04\x00\x00\xff\xff\x64\xda\x15\x73\xb7\x02\x00\x00" +var _safe_generic_transferCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x94\xc1\x6e\xe3\x36\x10\x86\xcf\xf1\x53\xcc\xe6\x90\x95\x80\xac\x72\x29\x7a\x30\xb2\xdd\xa6\x0b\xa4\x87\x1e\x1a\x64\xd3\xed\x79\x2c\x8e\x24\x36\x34\x29\x70\x46\xd1\x1a\x81\xdf\xbd\x20\x29\xd1\x56\x9c\x00\xd9\x93\xe9\x11\x39\xff\x37\x3f\x67\xa8\xb7\xbd\xf3\x02\xe7\xb7\x83\x6d\xf5\xc6\xd0\x83\x7b\x24\x7b\xbe\x5a\x5d\x5d\x5d\xc1\x57\xb4\xd0\x23\x33\x68\x0b\x68\x77\xc0\xe2\x3c\xb6\x04\x3d\x4a\x07\x68\x15\x78\xaa\x49\x3f\x91\x4f\x11\x6d\x59\x08\x15\xb8\x06\xfe\x1b\x58\x40\x3a\x02\x45\x0d\x0e\x46\xaa\x98\xef\xa1\xd3\x0c\x86\x84\x61\xe7\x06\xa8\x3b\xe7\x98\xe2\x2e\x09\xa2\x31\x38\xa2\x15\x10\x07\x4c\x56\x01\x32\x8c\x64\x4c\xdc\x52\x63\x8f\x1b\x6d\xb4\xec\x4e\xf7\xe9\xb0\x8c\x12\x51\xe6\xc6\xee\xa6\x8c\x11\xab\x46\x0b\x1b\x8a\x85\x50\xcc\x89\x16\xd0\xb7\xc3\x96\xac\x40\x47\x9e\x2e\x81\x1d\x8c\x68\x22\x19\x77\x6e\x30\x2a\xe6\x49\x4b\xa8\x3b\xaa\x1f\x0f\x27\x9e\xd0\x0c\xc4\x41\x7b\x8b\x8f\x04\x3c\xf8\x54\x83\xb6\x42\x56\x91\x3a\x96\xd6\x3c\xcb\x6a\x1b\xf1\xc4\xa3\x65\xac\x45\x3b\x5b\xe0\xd6\x0d\x56\xd6\xf0\xcf\xad\xfe\xf1\xeb\x2f\x97\x20\x6e\x0d\x37\x4a\x79\x62\xbe\x8c\x75\x91\xbf\x43\xe9\xd6\xf0\x2d\xd9\x1e\xfe\x5c\x66\xcb\xd3\xa7\xbb\x61\x63\x74\x1d\xd6\x25\x3c\xaf\x56\x00\x00\xd1\x67\x82\xef\xc1\x76\xf0\xc4\x6e\xf0\x75\x20\x44\x81\xce\x19\xc5\x07\xc3\x39\x45\xd1\x13\x6c\x48\xdb\x16\x22\x5d\x43\xde\x93\x8a\xa9\x0c\x09\x08\x6d\xfb\x98\x6b\x0d\xbf\x2f\x7a\xa4\x8a\xd1\xac\xf9\x87\xf3\xde\x8d\xa1\x7c\x6a\xc8\x93\xad\x69\x46\x9d\xc5\x74\x33\x45\x82\x14\xd6\x75\xa8\x1e\x94\x23\xb6\x1f\x05\x78\xe8\x63\x1f\x06\xb8\x50\x7b\xc4\x09\xe7\x32\x48\x72\xe4\x7e\x2a\xff\x9e\x9a\x35\x5c\x3c\x27\x92\x39\xb8\x4f\x34\xbd\xa7\x1e\x3d\x15\xac\x5b\x4b\x7e\x0d\x38\x48\x57\x24\xbe\xef\xe1\xf2\x4a\xb8\xb8\x49\xf2\xd9\xb4\xa9\x88\x3f\x49\x00\xc1\xe7\x0a\xc4\x25\xa0\x98\xe8\x23\xc7\x01\x20\x05\x4f\xb1\xf2\xf9\x5c\x80\x8b\x91\x7b\x6a\xe0\xf3\xb4\xb9\x9a\x66\xa5\xda\x44\xdd\xeb\xc8\xb0\xf4\xef\x5f\x2d\x9d\xf2\x38\x96\x70\xf1\xbc\xfc\x72\xe7\xdd\x93\x56\xe4\xf7\xbf\x15\x8d\x77\xdb\xf5\x51\x37\x94\xab\xb3\xb3\xb3\x2f\x5f\xa0\x47\xab\xeb\xe2\xfc\x6b\xec\x50\xeb\x04\x92\xce\x29\xbb\x1b\x13\x7a\xbc\xad\x0f\xe7\x65\xc6\xce\x0b\x26\xd3\x54\x27\xee\xbe\x59\xc9\x4b\xd8\x6c\xfe\xcf\xc3\xbe\x95\xe9\x1d\x55\x2c\xe9\x73\x93\xc2\xf5\xa7\x7c\x17\xd5\x38\x19\x9c\x27\x2d\xfd\x26\x0b\xa6\x5e\xa1\x1f\x54\x0f\x42\xf0\xbc\xb8\x4e\xbf\xf0\xa1\x25\x99\xfa\xa5\x10\x57\x56\xf9\x25\xd2\xc4\xef\x30\xe5\x78\x60\xcb\x0f\x0b\x99\xa9\xe9\x49\x45\xf6\x87\x5d\x4f\x0c\x9f\x8f\xc5\xab\x96\xe4\xdb\xe9\xa6\xa2\x3c\x6e\xda\xbf\xad\xd9\xe5\xd1\x9d\x87\x6d\xec\xc8\x46\xe7\xf2\x13\xad\x19\x46\x6d\x4c\x1a\xac\xc3\x6c\x86\xc7\x00\x7d\x4b\x42\x0a\x6e\x1f\xaa\x9c\x58\x37\xaf\xe1\x55\xb5\xb3\x82\xda\xf2\x5f\xb4\x2b\x96\xd6\x07\xd6\xb0\xa7\x28\xcb\x23\x37\xe7\x17\xe9\x05\x5e\xe8\x94\xb7\x47\x6b\xbe\xf5\xcc\x7e\x78\xfc\x17\x89\x8f\x9d\x52\xd4\x3b\xd6\x32\xf5\xe0\xf5\xa7\x25\xdc\xc1\xb0\x3d\x90\x61\x7a\x41\xf8\xfa\x08\xbc\x3f\xe7\xd4\x51\xfb\xff\x03\x00\x00\xff\xff\x9a\x18\x8b\x27\x4d\x07\x00\x00" -func scriptsMetadataGet_vault_supply_viewCdcBytes() ([]byte, error) { +func safe_generic_transferCdcBytes() ([]byte, error) { return bindataRead( - _scriptsMetadataGet_vault_supply_viewCdc, - "scripts/metadata/get_vault_supply_view.cdc", + _safe_generic_transferCdc, + "safe_generic_transfer.cdc", ) } -func scriptsMetadataGet_vault_supply_viewCdc() (*asset, error) { - bytes, err := scriptsMetadataGet_vault_supply_viewCdcBytes() +func safe_generic_transferCdc() (*asset, error) { + bytes, err := safe_generic_transferCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/metadata/get_vault_supply_view.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa9, 0xf4, 0x97, 0x7, 0x1a, 0x5a, 0xb3, 0x78, 0x62, 0xda, 0xea, 0x72, 0xcd, 0x10, 0xe3, 0x91, 0x7b, 0xcd, 0x30, 0xb, 0x80, 0x58, 0xac, 0xef, 0x93, 0xab, 0x5f, 0xe9, 0x99, 0x1c, 0x8f, 0xc7}} + info := bindataFileInfo{name: "safe_generic_transfer.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x16, 0x8d, 0x46, 0x21, 0xb0, 0x65, 0x20, 0xf1, 0x62, 0x4d, 0xa3, 0x39, 0x31, 0xa, 0xe8, 0x61, 0x55, 0xfd, 0xbc, 0x95, 0xf3, 0xf9, 0x3c, 0x7e, 0x40, 0x8a, 0x4d, 0x32, 0x5e, 0xa0, 0x0, 0x47}} return a, nil } -var _scriptsSwitchboardCheck_receiver_by_typeCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x91\xc1\x6e\xe3\x20\x18\x84\xef\x7e\x8a\x91\x0f\x2b\x73\xf1\x03\x44\xd9\x64\x93\x55\x7b\x8e\x92\xb4\x77\xc0\xbf\x6d\x14\x0c\x08\xff\x34\xb5\xa2\xbc\x7b\x95\xda\x6d\xdd\x4a\x39\xf4\xf6\xc3\xcc\xc0\xc7\x60\xba\xe0\x23\xe3\x31\xb9\xc6\x28\x4b\x47\x7f\x22\x77\x38\x1b\xd6\xad\xf2\x32\x56\xa8\xa3\xef\x90\xdf\x93\xf3\x6c\xca\x3f\xbc\xca\x2e\x4c\xfa\x94\x99\x6f\xe5\x59\x16\x92\x42\x9d\x1c\x3a\x69\x5c\xd1\x7f\x1d\xb1\xc0\xa6\xaa\x22\xf5\xbd\x58\x60\xeb\xbd\xc5\x25\xb3\xc4\x98\x39\xf6\x54\xe3\x2f\x1a\xe2\x8d\xd6\x3e\x39\x9e\xa7\x45\x06\x00\x65\x43\xfc\x5f\x06\xa9\x8c\x35\x3c\x2c\xff\x5c\xee\xf1\x96\xb3\x79\x97\x94\x35\xfa\xba\x2a\xee\x9a\x47\xc7\x4e\x72\x3b\x5d\xa3\x7c\x8c\xfe\x5c\x08\xbc\x2f\xd7\x6b\x04\xe9\x8c\x2e\xf2\x27\x27\x95\x25\xb0\xc7\xe8\x80\xfe\x84\xc1\xd9\x70\x8b\x48\x3d\x47\xa3\x99\x2a\xf0\x10\x08\xbe\xc6\x6f\x18\xa7\x46\x4b\xed\x9d\x96\xdf\xde\x5f\xb2\x3f\x70\x34\xae\x29\x84\xf8\x90\x91\xcb\xb1\xa8\x5c\x8c\xdc\x91\x38\x45\xf7\xa3\xd2\x52\xb7\xa4\x4f\x7b\xd2\x64\x5e\x28\x6e\x87\xe3\x10\xa8\xb8\xc1\x2d\x70\x1b\x97\xff\xe6\xff\x57\x3e\xcb\x64\x79\x55\x08\x91\x5d\xdf\x02\x00\x00\xff\xff\xfb\xcb\x2f\x00\x32\x02\x00\x00" +var _scriptsGet_balanceCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x52\x4d\x8f\xd4\x30\x0c\xbd\xe7\x57\x3c\x7a\x80\x46\x42\x9d\x0b\xe2\x30\x5a\x76\xb4\x2c\xcc\x0d\x89\x43\xd9\xbb\x9b\xba\x3b\x11\x69\x52\x25\xee\xcc\xa2\xd5\xfe\x77\x94\x7e\x89\x91\x00\xad\x0f\x91\xe3\x3c\xc7\xef\xd9\xde\xed\x50\x9f\x6c\x42\x32\xd1\x0e\x82\xc8\xd4\x26\xc8\x89\xd1\x90\x23\x6f\x18\x9d\x65\xd7\xaa\xdd\x0e\xa1\x03\x79\x90\x31\x61\xf4\xf2\x2e\xe1\xeb\x13\xf5\x83\xe3\x3a\xfc\x64\x8f\xcf\x33\x5a\x29\xdb\x0f\x21\x0a\x8a\xe3\xe8\x1f\x6d\xb3\x3c\x17\x5b\xf8\xcf\xa4\xe2\xef\xe0\x6f\x2c\xd4\x92\xd0\x83\xe5\x4b\x2a\x94\x22\x63\x38\xa5\x92\x9c\xd3\xe8\x46\x8f\x9e\xac\x2f\xa9\x6d\x23\xa7\xb4\xc7\xdd\xec\xe8\x3d\x7e\x1c\xed\xd3\xc7\x0f\x78\x56\x00\xe0\x58\x70\xa6\xd1\xc9\x17\x12\xc2\xa7\x2b\xb2\x55\xe4\x14\xdc\x99\xef\x83\x97\x48\x46\x72\xa1\x32\xc7\xc6\x68\xb8\xfe\x35\xf0\x1e\xde\xba\xf7\x38\x5b\xbe\xcc\xd7\x7c\xde\xfc\x9b\x64\x75\xac\x1f\xd6\x5a\xb7\xa5\xd6\xa0\xf4\x06\xaf\x83\x1f\x26\xb6\xd9\x0e\x07\x0c\xe4\xad\x29\x8b\xfb\x30\xba\x16\x3e\x08\x1e\x57\x15\xc8\xc9\x13\x21\x74\x21\x4e\xf3\x31\x0b\xfb\x42\xab\xe9\x8f\xc8\x32\x46\x9f\x53\xee\xe6\x11\xad\x3d\xd2\x95\xa1\x81\x1a\xeb\xac\x58\x4e\x55\x13\x62\x0c\x97\x9b\xb7\xcf\x57\x04\xab\x65\x80\x2f\xb7\xe5\xc6\x28\xdb\xd6\xc3\xaa\x5f\x24\x7c\x27\x39\x6d\x10\x7d\xa8\x96\x3d\xf9\xaf\x8e\xb9\xe6\xba\x24\x88\xdc\x71\xe4\xec\x49\x98\xb4\x4c\xed\x28\xb4\x7a\x51\xbf\x03\x00\x00\xff\xff\xa7\x99\xe9\xa6\x8f\x02\x00\x00" -func scriptsSwitchboardCheck_receiver_by_typeCdcBytes() ([]byte, error) { +func scriptsGet_balanceCdcBytes() ([]byte, error) { return bindataRead( - _scriptsSwitchboardCheck_receiver_by_typeCdc, - "scripts/switchboard/check_receiver_by_type.cdc", + _scriptsGet_balanceCdc, + "scripts/get_balance.cdc", ) } -func scriptsSwitchboardCheck_receiver_by_typeCdc() (*asset, error) { - bytes, err := scriptsSwitchboardCheck_receiver_by_typeCdcBytes() +func scriptsGet_balanceCdc() (*asset, error) { + bytes, err := scriptsGet_balanceCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/switchboard/check_receiver_by_type.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2a, 0x6a, 0x82, 0xa3, 0xd9, 0xd7, 0x0, 0x73, 0xa9, 0xff, 0x8d, 0x6b, 0x2b, 0x4b, 0xa6, 0x55, 0x22, 0xfd, 0x77, 0x7, 0x8f, 0xbd, 0xb6, 0xdd, 0x72, 0xa1, 0x29, 0xeb, 0xcc, 0xd3, 0x61, 0x83}} + info := bindataFileInfo{name: "scripts/get_balance.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x74, 0xb1, 0xe6, 0x91, 0x19, 0xf, 0xfc, 0xd5, 0xd0, 0x29, 0x4e, 0x6d, 0x98, 0x41, 0x6f, 0x26, 0x51, 0x25, 0x3a, 0x95, 0xff, 0xe1, 0x7c, 0xc4, 0x2d, 0xfe, 0x9a, 0x6, 0x79, 0x82, 0x55, 0x8}} return a, nil } -var _scriptsSwitchboardGet_vault_typesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x91\x31\x0b\xdb\x30\x14\x84\x77\xfd\x8a\xc3\x43\xb1\x17\x7b\x0f\x4d\x43\x08\xb4\x6b\x48\x43\x97\x52\x88\x2c\x3f\xdb\xa2\xb6\x64\xa4\xa7\x86\x10\xf2\xdf\x8b\xac\xa6\x71\x4a\x02\xf5\x64\xa4\xef\xde\xe9\xdd\xe9\x71\xb2\x8e\xf1\x39\x98\x4e\xd7\x03\x1d\xed\x4f\x32\x68\x9d\x1d\x91\x3d\x9d\x65\xe2\x15\xf9\xf5\xac\x59\xf5\xb5\x95\xae\x79\x25\x5a\x5c\x67\x42\x54\x15\x8e\xbd\xf6\xf0\xca\xe9\x89\xe1\x48\x36\x1e\xdc\x13\x3c\x5b\x47\x0d\x7e\xc9\x30\x30\x94\x9c\x64\xad\x07\xcd\x9a\x7c\x9a\x29\xe1\x17\x36\xd6\x44\x4d\x1c\x36\x49\xef\xa9\x81\x54\xca\x06\xc3\x62\x0a\x35\xda\x60\x30\x4a\x6d\xf2\x3f\x87\x2b\x6c\x9b\xc6\x91\xf7\xc5\x0a\xdf\x8f\x97\x89\x7e\xe0\x2a\x04\x00\x0c\xc4\x51\xc9\x58\xa3\x23\xde\x26\xfc\x2e\x2b\x12\x53\x55\xf8\x12\x31\x38\x6a\xc9\x91\x51\x04\xb6\xe9\xc5\x8b\x07\x29\x6b\x5a\xeb\x46\x6d\xba\x78\xbb\x58\x79\x1f\xea\x41\xab\xbf\x6e\x0b\xcd\x81\x5a\xac\x67\xfb\xb2\x23\xde\xdd\x37\xbe\xe4\xef\xd2\x2b\xd3\xac\xbd\xe4\xbe\x98\x07\xc6\xaf\xac\xad\x73\xf6\xfc\xf1\xc3\x5b\xd5\xe2\xff\xfa\x3f\x50\x72\xb9\x7d\xca\x1f\x26\x9b\x0d\x26\x69\xb4\xca\xb3\x9d\x0d\x43\x03\x63\x19\xc9\xf7\x39\x95\xc5\x76\xd9\x23\xbe\x03\x71\x70\x73\x61\x70\xe4\x63\xbd\xb6\xc5\xa9\x23\xfe\x16\xbb\x8e\x85\xf8\xbc\x38\xcd\xb4\x4b\xe8\x73\x4a\xe5\x3f\xa8\x10\x37\xf1\x3b\x00\x00\xff\xff\xfb\x2b\x45\x36\xb2\x02\x00\x00" +var _scriptsGet_balance_genericCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\x90\xc1\x6a\xf3\x30\x10\x84\xef\x7a\x8a\xc1\x87\x1f\x1b\x7e\x9c\x4b\xe9\x21\x94\x86\xb4\x90\x73\x0e\x69\xef\x6b\x79\x13\x2f\x55\x24\xa3\x5d\x25\x85\x90\x77\x2f\x71\xe2\x42\x75\x1a\x2d\xec\xcc\xce\xb7\x58\x2c\xb0\x1b\x44\xa1\x3e\xcb\x68\xc8\x4c\xbd\xc2\x06\x46\x47\x81\xa2\x67\xa4\x3d\x08\x27\x2a\xc1\x40\x86\xf3\x40\xc6\x27\xce\x18\xc9\x06\x77\xdb\x16\xc5\x48\xaa\xdc\x43\x22\x48\x41\x11\x94\x0f\xe5\xc8\xd1\x9c\x93\xe3\x98\xb2\xa1\xda\x94\x78\x90\x2e\xf0\x2e\x7d\x71\xac\x9c\x23\xef\x59\xb5\xa6\x10\x1a\xec\x4b\xc4\x91\x24\xd6\xd4\xf7\x99\x55\x97\x58\xdf\xc5\xff\x29\x64\x89\x6d\xe9\x82\xf8\x2d\xd9\xd0\x2c\xf1\xb1\x91\xef\xe7\x27\x5c\x1c\x00\x64\xb6\x92\x23\x0e\x6c\x6b\xef\x53\x89\x36\x7b\x34\xad\xa7\x91\x3a\x09\x62\xc2\xda\x76\x29\xe7\x74\x7e\xf9\x77\xf9\x73\x47\xfb\x76\xaf\x78\x7d\xad\x27\xb7\xf9\x4d\xd5\xe6\x4f\xb3\x6a\x1f\x24\x7e\x47\xab\x15\x46\x8a\xe2\xeb\xea\x3d\x95\xd0\x23\x26\xc3\x3d\x01\x0f\x47\x64\xde\x73\xe6\x9b\xb2\x34\xd1\xfc\xbc\x01\xac\x1a\x77\x75\x3f\x01\x00\x00\xff\xff\xfd\x31\xef\x2e\x72\x01\x00\x00" -func scriptsSwitchboardGet_vault_typesCdcBytes() ([]byte, error) { +func scriptsGet_balance_genericCdcBytes() ([]byte, error) { return bindataRead( - _scriptsSwitchboardGet_vault_typesCdc, - "scripts/switchboard/get_vault_types.cdc", + _scriptsGet_balance_genericCdc, + "scripts/get_balance_generic.cdc", ) } -func scriptsSwitchboardGet_vault_typesCdc() (*asset, error) { - bytes, err := scriptsSwitchboardGet_vault_typesCdcBytes() +func scriptsGet_balance_genericCdc() (*asset, error) { + bytes, err := scriptsGet_balance_genericCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/switchboard/get_vault_types.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x69, 0xfb, 0xd8, 0x58, 0x9d, 0x15, 0x34, 0x8a, 0xe2, 0xfb, 0x58, 0x75, 0x8d, 0xe6, 0x9e, 0x1b, 0x57, 0xc3, 0x55, 0x9e, 0x21, 0x35, 0x9a, 0xd7, 0x46, 0x47, 0xcd, 0x80, 0x37, 0x2b, 0xc0, 0x1a}} + info := bindataFileInfo{name: "scripts/get_balance_generic.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2d, 0xa3, 0x96, 0x52, 0x3b, 0x55, 0x1, 0x52, 0xb1, 0xd3, 0xc5, 0x4e, 0xc, 0x93, 0x75, 0x63, 0x15, 0xb1, 0x7f, 0xf8, 0xe2, 0xcb, 0xbb, 0x4, 0xbb, 0x7, 0xd6, 0xaf, 0x8a, 0x60, 0x76, 0x78}} return a, nil } -var _scriptsSwitchboardGet_vault_types_and_addressCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x91\xcf\xca\xdb\x30\x10\xc4\xef\x7a\x8a\xc1\x87\x62\x5f\xec\xfb\x47\xbf\x86\x10\x68\xaf\x21\x0d\xed\x35\xb2\xbc\xb6\x45\x6d\xc9\x48\xab\x86\x10\xf2\xee\x45\x56\xfe\x38\x90\x40\x7d\x32\xab\xfd\xcd\xec\xee\xe8\x71\xb2\x8e\xf1\x3d\x98\x4e\xd7\x03\xed\xed\x1f\x32\x68\x9d\x1d\x91\x3d\xd5\x32\xf1\xaa\xf3\xe7\x51\xb3\xea\x6b\x2b\x5d\xf3\x0a\x5a\x3c\x67\x42\x54\x15\xf6\xbd\xf6\xf0\xca\xe9\x89\xe1\x48\x36\x1e\xdc\x13\x3c\x5b\x47\x0d\xfe\xca\x30\x30\x94\x9c\x64\xad\x07\xcd\x9a\x7c\xd2\x94\xf0\x0b\x1b\x6b\x22\x13\xc5\x26\xe9\x3d\x35\x90\x4a\xd9\x60\x58\x4c\xa1\x46\x1b\x0c\x46\xa9\x4d\x7e\x2d\x7e\x60\xdd\x34\x8e\xbc\x2f\x3e\x70\xde\x9f\x26\xba\x17\x2e\x38\x0b\x01\x00\x03\x71\x94\x60\x7c\xa2\x23\x5e\x27\xee\xc6\x17\xa9\xa7\xaa\xf0\x23\xb6\xc1\x51\x4b\x8e\x8c\x22\xb0\x4d\xa3\x2f\x26\x53\xd6\xb4\xd6\x8d\xda\x74\xf1\x75\xb1\xfb\x36\xd4\x83\x56\x77\xb7\x05\xb3\xa3\x16\x9f\xb3\x7d\xd9\x11\x6f\x6e\xab\x9f\xf2\x77\x67\x2c\x93\xd6\x56\x72\x5f\xcc\x82\xf1\x2b\x6b\xeb\x9c\x3d\x7e\xfd\xf2\x96\x5a\xfc\x9f\xff\xa7\x29\xb9\x5c\xbe\xe5\x0f\x93\xd5\x0a\x93\x34\x5a\xe5\xd9\xc6\x86\xa1\x81\xb1\x8c\xe4\xfb\x7c\x95\xc5\x76\xd9\xe3\x7c\x3b\xe2\xe0\xe6\xe4\xe0\xc8\xc7\x9c\x6d\x8b\x43\x47\xfc\x2b\x86\x1e\x93\xf1\xbf\x35\xf7\xd7\x70\xf2\xe2\x30\x83\x2e\x51\xcf\x07\x2b\xdf\x53\x42\x5c\xc4\xbf\x00\x00\x00\xff\xff\x3b\x85\x5a\x09\xd1\x02\x00\x00" +var _scriptsGet_supplyCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\xce\x3d\x6a\xc3\x40\x10\xc5\xf1\x7e\x4e\xf1\x50\x25\x35\xd9\x26\xa4\x48\x9f\x5c\xc0\xf2\x01\x86\xd5\x08\x2d\xde\x2f\x66\x46\x20\x63\x7c\x77\x83\x2a\xbb\x7e\x8f\x3f\xbf\x10\x30\x6f\xc9\x60\x51\x53\x77\xa8\xf0\x62\xf0\x4d\xe0\xcd\x39\xc3\xf6\xde\xf3\x1d\x6b\x92\xbc\x50\x08\x68\xeb\x39\xfe\x1d\x5c\x7a\x96\xb9\xdd\xa4\xc2\x0a\xab\x23\xb6\xea\xca\xd1\x89\x52\xe9\x4d\x1d\xc3\xfb\x69\x20\xe2\x18\xc5\x6c\xe4\x9c\x27\xac\x7b\x45\xe1\x54\xc7\xe9\x17\xd7\xff\x74\xfc\x7c\xe3\x41\x00\xa0\xe2\xbb\xd6\x8f\xfe\xd7\x29\xb9\x9c\x10\x7a\xd2\x2b\x00\x00\xff\xff\xd2\xfd\xa1\x6d\xb1\x00\x00\x00" -func scriptsSwitchboardGet_vault_types_and_addressCdcBytes() ([]byte, error) { +func scriptsGet_supplyCdcBytes() ([]byte, error) { return bindataRead( - _scriptsSwitchboardGet_vault_types_and_addressCdc, - "scripts/switchboard/get_vault_types_and_address.cdc", + _scriptsGet_supplyCdc, + "scripts/get_supply.cdc", ) } -func scriptsSwitchboardGet_vault_types_and_addressCdc() (*asset, error) { - bytes, err := scriptsSwitchboardGet_vault_types_and_addressCdcBytes() +func scriptsGet_supplyCdc() (*asset, error) { + bytes, err := scriptsGet_supplyCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/switchboard/get_vault_types_and_address.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbb, 0x85, 0x7a, 0x8d, 0xe8, 0x53, 0x96, 0x74, 0xb7, 0x16, 0xcf, 0x4b, 0x9e, 0xba, 0x84, 0x74, 0xf3, 0xc9, 0xee, 0x30, 0x27, 0x8d, 0x28, 0xff, 0xe2, 0xe3, 0xb1, 0x25, 0x3e, 0x9, 0x9a, 0xad}} + info := bindataFileInfo{name: "scripts/get_supply.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdd, 0x3c, 0xc, 0x52, 0x8e, 0x74, 0x2e, 0x22, 0x44, 0xf5, 0xa0, 0x5, 0xc1, 0x1c, 0xd1, 0x7c, 0x1f, 0x2c, 0xff, 0x1, 0x86, 0x2b, 0xa5, 0xab, 0x70, 0xa3, 0x21, 0x31, 0xd1, 0x71, 0x8a, 0x8b}} return a, nil } -var _scriptsTokenforwarderIs_recipient_validCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x90\x51\x6a\xc3\x30\x10\x44\xff\x7d\x8a\xc1\x1f\xc5\x86\xe2\x03\x98\xb6\x21\x2d\xe4\x3b\x94\xf6\x00\xb2\xb4\x76\x44\x64\xad\x58\xaf\x08\x21\xe4\xee\xa5\x36\x2d\x24\x24\x44\x5f\x62\x79\x3b\x33\x3b\x7e\x4c\x2c\x8a\x2f\xde\x53\xdc\xb0\x1c\x8c\x38\x1f\x07\xf4\xc2\x23\xca\xab\x69\x59\x14\x29\x77\xe8\x73\xc4\x68\x7c\xac\x8c\x73\xd2\x62\xed\x9c\xd0\x34\x3d\x43\x2f\xe9\xad\xd1\x5d\x8b\x6d\xee\x82\xb7\xbf\xff\xba\xc5\x3b\x73\xc0\xa9\x00\x80\x40\x8a\x7e\x61\x49\x3e\xa9\xc7\x2b\x06\xd2\xb5\xb5\x9c\xa3\xce\xca\xf5\xcc\xdd\x78\xcd\x40\xfa\x61\x92\xe9\x7c\xf0\x7a\x7c\x79\x3a\x5d\xc5\x6c\x36\x7f\xba\x8b\xf9\xf9\xad\xba\x11\xed\xbe\x7c\xc7\x22\x7c\xa8\xee\x02\xab\x15\x92\x89\xde\x56\xe5\x77\x34\x5d\x20\x28\x63\xd9\xc1\xc3\x28\x10\x9a\x54\xbc\x55\xe8\x31\xd1\x52\xb3\x81\xfd\xbf\xa6\xac\x8b\xd9\x56\x48\xb3\xc4\x8b\x86\x1a\xbb\x23\xbb\xaf\xea\xe2\xfc\x13\x00\x00\xff\xff\xb3\xce\xc9\xb2\xb4\x01\x00\x00" +var _scriptsGet_supported_vault_typesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x93\x4f\x6f\x9b\x40\x10\xc5\xef\x7c\x8a\x27\x1f\x1a\x90\x2a\x7c\xb7\xda\x46\xe9\xa1\xea\x31\x4a\xd2\x9e\x59\x96\xc1\xbb\xca\xc2\xa2\x99\xc1\xc8\xb2\xfc\xdd\xab\x05\xbb\x31\x56\xeb\x93\xb5\x9a\xf7\x7e\x8f\xf9\xe3\xbb\x21\xb2\x62\xf3\x63\xec\xf7\xbe\x0e\xf4\x16\xdf\xa9\xdf\x64\xd9\x76\xbb\xc5\x9b\xf3\x02\xb1\xec\x07\x15\x30\xe9\xc8\xbd\x40\x1d\x41\xc6\x21\xa9\xa8\xc1\x4a\xf6\x20\xd0\xe3\x40\xa8\x8f\x73\xd5\xc0\xf1\xe0\x1b\x6a\x50\xa9\xe1\x3d\x69\x05\xd3\x34\x4c\x22\xe5\xec\x7e\xff\x0a\x71\x71\x0c\x0d\x5c\x0c\xcd\xac\xb7\x66\x30\xb5\x0f\x5e\x8f\x98\x9c\xb7\x0e\x36\xf6\x6d\xe4\x4e\x30\x79\x75\x6b\x74\xf9\x42\x96\xfc\x81\x18\x4c\xa2\xec\x6d\x0a\x97\xc2\xcc\xa8\xc9\xf9\x40\xf0\x8a\x26\x92\xf4\x0f\x8a\xce\xa8\x12\x63\x72\xa4\x8e\xf8\x96\xc4\xd4\x12\x0b\x34\xa2\xbd\xf8\x43\x13\x00\x91\x61\x60\x47\xd1\xd8\x81\xaf\xb0\xe0\xdf\x09\xcb\xd7\xac\xe2\xbc\x4e\x5e\xad\xab\xa3\xe1\xa6\x4a\xca\x6a\x7e\xbd\x66\xac\x4a\xfc\x8c\x13\x25\x83\x4b\x13\x9e\x8d\xba\x0a\x4a\x21\x48\x0a\xc5\x74\xdf\x00\xd1\xc8\x24\x99\xb1\x96\x44\x72\x13\x42\x91\xf2\xa1\x33\xbe\xcf\x17\x8b\x1d\x9e\x96\x3e\x7e\xc6\x87\xe7\x0e\xcf\x63\x1d\xbc\x4d\xff\x8b\x1d\x4e\x6f\xc7\x81\x76\xf8\x1e\x63\x38\xe3\x94\x65\x00\xb0\xdd\xe2\x69\x76\xbd\x47\xb6\x91\xd7\x63\x5c\x6c\xaf\xe3\x9a\xc5\x81\xf4\x46\xf2\x42\x2d\xbe\x62\x4f\xfa\x64\x6d\x1c\x7b\xbd\x24\x2b\xca\xbf\x25\x9e\xa4\xac\x23\x73\x9c\xbe\x7c\x3a\xfd\x7b\x80\xe7\x6f\xf9\x47\xfe\x62\xa6\xa4\xdf\xe3\x23\x06\xd3\x7b\x9b\x6f\x7e\xf5\x66\x99\x0a\x16\xa7\xd5\x9e\xa4\xc5\xb8\xd9\x00\x19\xeb\x65\x25\xff\x07\x43\xcb\xb1\xc3\x60\xd4\x6d\x4a\x1b\x7b\x6b\xf4\x86\x5e\x6a\x7c\x55\xf6\xfd\x3e\x2f\x8a\xe2\xda\xac\x97\xf9\x0e\xee\xce\xe0\x60\xc6\xa0\x33\x49\xca\xb9\x70\xb9\x96\x75\x6f\xca\x3d\xe9\xeb\x55\xf2\x3b\x29\xd2\x38\x24\x2f\xb2\x73\xf6\x27\x00\x00\xff\xff\x60\x93\xa8\xaa\x87\x03\x00\x00" -func scriptsTokenforwarderIs_recipient_validCdcBytes() ([]byte, error) { +func scriptsGet_supported_vault_typesCdcBytes() ([]byte, error) { return bindataRead( - _scriptsTokenforwarderIs_recipient_validCdc, - "scripts/tokenForwarder/is_recipient_valid.cdc", + _scriptsGet_supported_vault_typesCdc, + "scripts/get_supported_vault_types.cdc", ) } -func scriptsTokenforwarderIs_recipient_validCdc() (*asset, error) { - bytes, err := scriptsTokenforwarderIs_recipient_validCdcBytes() +func scriptsGet_supported_vault_typesCdc() (*asset, error) { + bytes, err := scriptsGet_supported_vault_typesCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "scripts/tokenForwarder/is_recipient_valid.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb6, 0xad, 0x9e, 0x22, 0xd4, 0xc2, 0x63, 0x91, 0x2a, 0xff, 0xe3, 0x37, 0x70, 0xe5, 0xa, 0x40, 0x70, 0xa3, 0xb5, 0x5f, 0x14, 0xc3, 0x8, 0x79, 0xd4, 0xb9, 0xf6, 0x7, 0xd7, 0x51, 0x7a, 0xc8}} + info := bindataFileInfo{name: "scripts/get_supported_vault_types.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe0, 0xc7, 0x62, 0xe7, 0x3d, 0xbc, 0xf3, 0x6f, 0xd, 0x82, 0x27, 0x6a, 0x8b, 0x4b, 0x9d, 0x4c, 0xcd, 0xb9, 0xe, 0x3b, 0x55, 0xa9, 0xd5, 0x69, 0x23, 0x2d, 0xfa, 0x9f, 0x6c, 0x4d, 0xa, 0xa9}} return a, nil } -var _setup_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x53\xc1\x6a\xdc\x30\x10\xbd\xfb\x2b\x5e\x73\x28\xbb\x90\xae\xef\x21\x0d\xa4\x25\xbd\x15\x42\x1a\x72\x9f\xb5\xc7\xb6\x88\x56\x32\xa3\x71\x36\x26\xec\xbf\x17\x69\xbd\xc6\x6a\x96\x16\x4a\xa9\x6f\x7a\x7a\x7a\x33\xef\x79\xa6\x2c\xf1\xd8\x99\x00\x15\x72\x81\x2a\x35\xde\xc1\x04\x10\x94\x77\xbd\x25\x65\x34\x5e\xe2\x71\x71\xaf\x1e\x64\xad\xdf\x17\x65\x09\x72\xa3\x77\x9c\xa0\xba\x06\xe1\x89\x06\xab\x10\x0e\x7e\x90\x2a\xe1\xda\xb1\x11\x50\x55\xf9\xc1\x29\x42\x04\x48\xe3\x53\xed\x78\x44\x45\x0e\x43\xe0\x78\x00\xbf\xd2\xae\xb7\xfc\xe8\x9f\xd9\x15\x85\xd9\xf5\x5e\x14\xdf\x06\xd7\x9a\xed\x84\xa2\x11\xbf\xc3\x45\x86\x5d\x9c\x98\x77\x8b\xe7\x13\x71\x09\xcd\xbc\xef\xac\x54\x93\xd2\x93\xe1\x7d\x98\x88\x19\x76\x51\x14\x4b\xbb\xab\x35\xde\x8a\x02\x00\x7a\xe1\x9e\x84\x57\xc1\xb4\x8e\xe5\x0a\xb7\x83\x76\xb7\x47\x63\x33\x27\x7e\x65\x89\x07\xd6\x41\x1c\x98\xc4\x8e\x30\x4d\xf2\x77\xca\x80\xac\x30\xd5\x23\x82\x7a\xe1\x98\x75\xd6\x79\x4a\x70\x96\x32\x0d\x8e\xd5\x36\x5b\x2f\xe2\xf7\xd7\x1f\x97\xe4\x4d\x22\xdf\xac\xa2\x89\x2b\xbc\xbf\xf9\xa1\x5e\xa8\xe5\x7b\xd2\x6e\x8d\x0f\x9f\xe1\x8c\xc5\xdb\xac\x1d\x3f\x49\x7d\xce\xd0\x21\x33\xf1\x55\x38\x4e\x00\xc1\xf1\xfe\x4c\x93\x20\x57\xa3\x1f\x14\x46\x61\x5c\xb2\x43\x2d\xcf\x02\x53\xdf\x81\x5e\x78\x95\xd5\xbc\xfe\x94\x75\x5a\xa5\x2a\x77\xbb\x5e\xc7\x24\xbb\x5a\x5f\x66\x74\xf5\x7f\xb0\x36\xb3\xd7\xe7\xbb\xef\x87\xad\x35\x15\x2a\xea\x69\x6b\xac\xd1\x71\x1a\xcb\xc9\x45\x9c\x47\x78\x67\x47\xf0\x6b\xef\x03\x87\xa5\x48\xa4\xd5\xdc\xfb\x60\x14\xcd\xe0\xa6\x05\xe8\xc4\x0f\x6d\x97\x2e\x1f\xb8\x62\xf3\xc2\x02\xe3\x94\xa5\xa1\xea\x5d\x00\xd6\xb8\xe7\x73\xbf\xed\x2d\x1b\xe3\xcd\x49\xe8\x70\x93\xa7\x95\x3d\x3c\x91\xee\x93\xa5\x68\xfe\x97\xac\x48\x5a\xd6\xff\x90\xd7\x14\x55\x82\xbf\x90\x25\x57\x71\x1a\x87\x07\x0e\xde\x66\x71\x84\xbf\xcc\x63\x52\xbd\xcc\xf7\x75\x73\x2a\xf0\xdb\x98\x92\xde\xbf\xca\xe8\xb8\x17\x87\xe2\x67\x00\x00\x00\xff\xff\xd1\xd3\xfa\x7f\x2b\x05\x00\x00" +var _setup_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x94\x41\x6f\xdb\x3c\x0c\x86\xef\xfe\x15\x6f\x73\xe8\x67\x03\x69\x72\x2f\xd2\xf6\xdb\xb2\x16\xd8\x61\x40\xd1\x06\xb9\x33\x0e\xd3\x08\x53\x24\x41\xa2\x93\x06\x45\xff\xfb\x20\x39\x76\xec\xce\xc5\x76\x9c\x0f\x01\x44\x51\xe4\xcb\x87\x64\xa6\x53\x2c\xb6\x2a\x40\x3c\x99\x40\xa5\x28\x6b\xa0\x02\x08\xc2\x3b\xa7\x49\x18\x1b\xeb\xe3\xb1\x73\x2f\x16\xa4\xb5\x3d\x64\xd3\x29\xc8\x1c\xad\xe1\x64\x5a\xaf\x41\x58\x52\xa5\x05\x9e\x83\xad\x7c\x99\xec\xb2\x65\xe5\x41\x65\x69\x2b\x23\x08\xd1\x40\x12\x9f\xca\x96\x8f\x28\xc9\xa0\x0a\x1c\x0f\xe0\x57\xda\x39\xcd\x0b\xfb\x93\x4d\x96\xa9\x9d\xb3\x5e\x30\x7a\xa8\xcc\x8b\x5a\x9d\xcc\xa3\xd6\x7c\xdf\x71\x3e\x5b\x97\x8a\x0f\x4f\x1c\xac\xde\xb3\x1f\x0d\x87\xf8\xc1\x42\x6b\x12\x8a\xae\x61\x94\x65\xdd\xca\xf2\x02\x6f\x59\x06\x00\xce\xb3\x23\xcf\x79\x50\x2f\x86\xfd\x35\xa8\x92\x6d\xfe\xd5\x7a\x6f\x0f\x4b\xd2\x15\x8f\xf1\x3d\x84\x8a\x9f\xc5\x7a\x7a\xe1\x39\x39\x5a\x29\xad\xe4\x38\xb7\x46\xbc\xd5\x9a\xfd\x18\x8f\xd5\x4a\xab\xb0\x3d\x5f\x8e\xf1\x4c\x7b\x4e\xef\x0b\x5c\x7e\xa9\x91\xb4\x29\xe3\xa7\x59\xb0\x8f\x08\xbf\x91\x10\x6e\xd0\xad\x72\xe2\xeb\xc2\x52\x0a\x2a\x25\x16\x90\x37\xa4\x17\x47\xc7\xd7\x30\x4a\x8f\xb1\x57\x7c\xa8\x8f\xf1\x77\xf6\x79\xf1\x93\x87\xc5\xb2\xc9\x75\x9b\x17\x05\x28\x5c\xe0\xef\xdc\xef\x5a\xc5\xf1\xbb\xbb\x83\x23\xa3\xca\xbc\xc7\x1f\x6b\xcb\x01\xc6\xd6\xe3\xa0\xf7\x8c\x4e\x80\xa4\x72\x54\x9c\x2b\x9f\x4e\xf1\xc4\x52\x79\x03\x26\xaf\x8f\x50\x9b\x34\x13\xcd\xdc\x90\xf6\x4c\xeb\x23\x82\x58\xcf\x71\x3e\xbb\x64\xea\xa9\x6b\x43\xa9\x0d\xea\xb6\x4d\x42\xdd\x9e\xc9\x2a\x35\x6e\x76\xd9\xc3\x99\x1e\xdd\xe6\x1b\x6f\x77\xd7\x67\xe8\xcd\x9b\x47\x92\x6d\x81\x8b\x9b\xc8\x14\x6f\xbd\x72\x7d\xd2\xd9\x9a\xde\x07\xda\x87\xd9\x55\xbf\x77\xa5\x67\x12\xbe\xdf\x39\x39\xa6\xbc\x79\x72\xeb\xb4\xe9\xff\x21\x6d\x45\x1f\xd0\x3c\x05\x01\xc1\xf0\x61\x00\x00\xc8\xac\xe1\x2a\x81\x12\x28\x83\x53\x21\x6d\x80\x0f\x4c\x02\xed\x39\x9f\x5d\x25\x1d\x63\x88\xfd\x8c\xc1\xb0\x02\x17\x67\xbb\x44\xd9\xce\xf6\x69\xd5\x4f\x4a\xe2\x8e\x83\x5f\x9d\x0d\x1c\x3a\x66\x65\x84\xfd\x86\x4a\x0e\xbf\x23\x9b\x93\xc3\x4d\x23\xb2\x8d\xab\x38\xb4\x8a\x55\xdc\xb8\xe1\x26\xf6\xfa\x33\x58\x47\xeb\x51\x7c\x04\xd2\xcb\xe5\xea\x9d\xcd\x1b\x49\x63\x90\x74\xc9\xec\x4e\x1b\xf1\x67\x34\xf3\x61\x34\xff\x05\x3c\x71\xc9\x2a\x2e\xc8\xa6\x32\xe9\x7f\x87\xa2\x57\x8f\x88\x3f\xb9\xfc\x5b\x50\x3a\xaa\x3e\x72\x69\xae\x6a\x2e\xf5\x5a\xbc\x67\xbf\x02\x00\x00\xff\xff\xfa\xdc\x38\x5a\x5e\x06\x00\x00" func setup_accountCdcBytes() ([]byte, error) { return bindataRead( @@ -562,11 +542,11 @@ func setup_accountCdc() (*asset, error) { } info := bindataFileInfo{name: "setup_account.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9e, 0x15, 0xa6, 0xb4, 0xe3, 0x94, 0x35, 0x36, 0xea, 0x97, 0xd0, 0x1a, 0xdb, 0xf6, 0x88, 0x5a, 0x71, 0x39, 0xa1, 0x41, 0xca, 0x9a, 0x62, 0xd4, 0x1b, 0xf1, 0x6c, 0x42, 0x62, 0xb9, 0xa0, 0x8b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb3, 0x82, 0x3c, 0xc7, 0xdc, 0x85, 0xf8, 0xad, 0xef, 0xa0, 0x18, 0x66, 0xb, 0x3, 0xc9, 0x2a, 0xa4, 0xeb, 0x9e, 0xc0, 0x4, 0x3d, 0xa, 0xfe, 0x31, 0xb1, 0xdd, 0x76, 0x84, 0xbe, 0x13, 0x5c}} return a, nil } -var _switchboardAdd_vault_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x4d\x6f\x9b\x40\x10\xbd\xf3\x2b\x9e\x38\xa4\x44\xaa\xf0\xdd\x4a\x1a\x45\x51\xdb\x5b\x15\x25\x51\xef\xc3\x32\xc0\x2a\xb0\x8b\x76\x07\x7f\x28\xf2\x7f\xaf\x16\x6c\xba\xb4\x8e\x13\x0e\x16\x86\x99\xb7\xef\xbd\x79\x83\xee\x7a\xeb\x04\x3f\x06\x53\xeb\xa2\xe5\x17\xfb\xca\x06\x95\xb3\x1d\xd2\xc5\xb3\x34\x39\x57\xf9\xbc\xd5\xa2\x9a\xc2\x92\x2b\xcf\x35\x45\xaf\xe7\xfe\xef\x3b\xea\xfa\xe5\x41\xf1\xa3\x34\x49\x56\x2b\xbc\x34\xda\x43\x1c\x19\x4f\x4a\xb4\x35\xd0\x1e\x04\xe1\xae\x6f\x49\x18\x95\x75\xe1\x6f\xf4\x5e\x1a\x92\xd0\xa8\xec\xd0\x96\x28\x18\x83\xe7\x12\xc5\x1e\x64\xf6\xd6\x30\xc4\x82\xca\x12\x04\xc3\x5b\x54\x47\x8e\x90\x91\xc4\x86\x86\x76\x6a\xa6\x9e\x0a\xdd\x6a\xd9\x87\x7a\x69\x58\x3b\xf8\x48\xa1\x63\x6f\x07\xa7\x38\x89\x4f\x7e\x4b\x12\x00\x68\x59\xc0\x91\x8e\xdf\x01\xf4\x61\x06\x5c\xe3\xef\xfd\xcd\xd5\xdb\xc2\xa5\xfc\x89\x15\xeb\x0d\xbb\xc3\xb7\x19\x2a\x3a\xf6\x89\xab\x35\x70\xf5\x9e\xb1\x79\x74\x3f\x51\xe9\x1d\xf7\xe4\x38\xf3\xba\x36\xec\xd6\xb8\x1f\xa4\xb9\x57\xca\x0e\x46\xae\x4f\x74\xc3\xb5\x5a\xe1\x27\x4b\xd0\x79\x62\x1e\x1b\x12\xbb\x31\x8e\x29\xd4\x4d\x90\x5f\x3c\x68\xc2\x9b\xb1\x3c\xb7\x55\x7e\x41\x3f\x6e\x31\xd7\x8e\xf5\x23\x50\x5e\xb3\x7c\xde\x97\x4b\x57\x16\x67\x68\x6e\x7c\x1c\x8a\x56\xab\x47\x92\xe6\x7a\x46\x88\xe5\x3f\x34\xac\x5e\xa1\xab\x51\x9b\x3b\x36\xc5\xc2\x79\xa7\xbd\xf8\xb9\x85\xbc\x67\x27\xd9\x47\x62\x73\x15\x70\xb3\xeb\xaf\x4b\xcd\x1d\x7b\x4f\x35\xaf\x91\x3e\x8f\xea\x51\x5a\xf6\x30\x56\xd0\xd0\x86\x41\xa7\xd5\xc0\xb4\x1b\x67\xf8\xa4\xe7\x65\x84\x29\x12\x1c\x57\xec\xd8\x28\x3e\x86\xf7\xe8\xb1\x8f\xb3\xb4\x9c\xd7\x32\x64\xb8\x3d\x4d\xa5\xb0\xce\xd9\xed\xcd\xa7\x22\xb7\x1c\x4d\x16\x92\xb2\x7e\xf7\x1b\x91\x3f\x8b\x75\x54\xf3\x38\x91\xa5\x39\x77\x77\xe8\xc9\x68\x95\xa5\x0f\xe3\x0a\x07\x5b\x26\x1e\x4b\x61\x11\xe7\xa3\x1b\xe3\xcf\x61\x8a\x35\xef\x58\x0d\xc2\xff\xa4\xfc\xbe\x2c\x47\x43\xfe\xdb\xef\xc5\x76\x0f\x5e\x9b\x3a\x7c\x25\x7e\xf1\x76\x1c\x28\x3a\x96\xc6\x5e\xf4\x2c\x8f\xca\x33\x15\x6d\xfb\x47\x11\x59\x52\x3f\x24\x7f\x02\x00\x00\xff\xff\xde\x10\x3c\x68\x87\x05\x00\x00" +var _switchboardAdd_vault_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x57\x4d\x73\x22\x37\x10\xbd\xf3\x2b\x3a\x1c\xc8\x8c\x8b\x0c\x77\xca\x1f\xd9\x25\xbb\xa9\x1c\x92\x6c\xad\x1d\xdf\x1b\x4d\xc3\xa8\x76\x90\xa6\x24\x0d\x98\x72\xf1\xdf\x53\xd2\x7c\x49\x30\x83\xb1\xd7\x65\x0e\xf6\x00\xad\xee\xf7\xba\xa5\xf7\x10\xdf\x14\x52\x19\x18\x7f\x2d\xc5\x9a\x2f\x73\x7a\x90\x3f\x48\x8c\x47\xbd\x1f\xdf\xef\xb8\x61\xd9\x52\xa2\x4a\xbb\x88\x2f\x4f\xb8\x29\xce\xaf\xfb\x9b\x0c\xa6\x68\xf0\x91\xd3\x4e\x8f\x47\xa3\xd9\x6c\x06\x0f\x19\xd7\x60\x14\x0a\x8d\xcc\x70\x29\x80\x6b\x40\x30\xb4\x29\x72\x34\x04\x2b\xa9\xec\x5b\xef\x7b\x93\xa1\x01\x26\xcb\x3c\x85\x25\x41\xa9\x29\x85\xe5\x1e\x50\xec\xa5\x20\x30\x12\x30\x4d\x01\x41\xd0\x0e\x56\x75\x6d\x30\xb6\x38\x6c\xb1\xcc\x8d\xab\xc9\xb0\xc0\x25\xcf\xb9\xd9\xdb\x05\x26\x23\xae\x40\x77\x9c\x40\x91\x96\xa5\x62\x64\x83\x47\x7e\xed\xe7\xd1\x08\x00\x20\x27\x03\xe4\xd1\x7d\xb4\x99\x17\x6d\xd2\x39\x74\xcf\xd7\x93\xe7\xa0\x05\xc9\x77\x62\xc4\xb7\xa4\x0e\xb7\x6d\x2a\xaf\xf4\x77\x5a\xcd\x01\xb0\x34\x59\x34\xd4\xf1\xe4\xdf\x9d\x20\x15\xc3\x64\x30\xc0\x7b\xae\xf0\x16\x8a\x0a\x54\x14\x69\xbe\x16\xa4\xe6\x55\xfe\xcf\x52\x29\xb9\x7b\xc4\xbc\xa4\x29\xfc\xa5\x75\x49\xf7\x46\x2a\x5c\x53\x07\x7e\x21\x85\x51\x32\xcf\x49\x4d\xe1\x5b\xb9\xcc\xb9\xce\xba\x2f\xa7\x70\x8f\x5b\xaa\xd7\xff\x27\x8a\xe3\xef\x63\x98\x7c\x62\x4c\x96\xc2\xc4\x4d\xdf\x1a\xc2\x6e\x12\x7f\xa0\x41\xb8\x01\x7f\xdb\x24\xb6\xf1\xf9\x96\x5c\x5d\x64\xc6\xee\x93\xa8\x19\xc6\xc3\xbe\xa0\x39\x08\x9e\x4f\x61\xcb\x69\x57\xbd\xb5\x7f\xaf\x87\xf7\x58\xf2\xf5\xe1\xb1\xa9\x75\x1b\xc5\x31\xa0\xfe\x05\x2e\x0b\xbf\x6b\x11\xdb\xd7\xdd\x1d\x14\x28\x38\x8b\xc6\x0b\xb7\xf3\x84\x34\xb0\x6e\x98\x80\x4d\xe0\x40\xb9\xed\x6a\x32\x02\x56\x33\x18\xc7\x1d\xf3\xd9\x55\x40\x16\x5c\x29\x1b\xb9\xe2\xeb\x52\xa1\xdb\x60\x57\xb3\x2e\xdc\x7f\x84\x45\x1d\x46\x80\xa2\x2f\x0d\x5f\x81\x20\x4a\x29\x6d\x17\xf1\x15\x54\xf3\x4e\x74\x35\xd7\x64\xe9\x26\x7e\x3d\x09\x5a\xee\x96\xdf\x46\x2b\x25\x37\xf3\x6e\x30\xcd\x9a\x6f\x68\xb2\x18\x6e\x6e\x6c\xdf\xe1\x39\x68\x89\x05\xa5\xc8\x9e\xd1\xea\xb4\xf5\x80\x42\x91\x82\xc6\x2d\x01\x37\xc0\x05\xd4\x39\x83\x2c\x47\x10\x6d\x74\x74\xfd\x5b\x80\x90\xb9\x2a\x5f\x36\x85\xd9\xbb\xb4\x91\x43\xe9\xcd\xff\xf7\x3e\x42\x71\x3c\x05\x23\x87\x28\x9d\x30\xc9\x09\x15\xd0\x13\xd7\x86\x8b\x75\x77\x7e\x39\x69\xb0\x72\x83\x42\x0a\xce\x30\x87\x02\x4d\xa6\xfb\x18\x30\x6f\x49\x52\x36\xc7\x21\xea\xca\x6f\xea\x9d\x76\x5a\xff\xd2\x0c\xaa\x96\x8e\x5e\x06\xee\x04\xd7\x7d\x9f\x40\xa3\x32\x01\x93\x60\x49\x7b\x0e\x17\x58\xc0\x4d\x2f\x86\x66\x28\xdc\xa6\x3e\x11\xb2\xcf\x98\xa3\x60\x34\x0d\xcf\x53\xd5\xfe\xc3\x6d\x74\x41\xdf\x2d\x84\x86\xd3\x5b\x51\x74\x72\x7a\x49\xc5\xd9\xac\xd1\xb1\xe1\xc6\xf4\x61\x08\x66\xb1\xc0\x62\x0a\x68\xfc\xad\xf5\xba\xd9\x36\xd9\x3c\xee\xc7\x09\xfb\x47\x7d\x68\x9f\x7c\x69\xf8\x93\x8c\xd3\x9c\xda\x91\x7c\xb7\xf3\x9d\xce\x9e\x70\x17\x57\x41\xfa\x55\x03\x56\xf2\xdc\xe6\xd2\x94\xaf\x92\x33\xbe\x36\x30\xa0\x35\x99\x73\x63\x09\xda\x61\x5f\x2f\xb1\x0c\x64\x2f\x23\xf6\xc3\x4a\x99\x05\xde\x84\xfb\xac\xdc\x91\xed\x06\x88\x5a\x93\x32\x61\xcd\x97\x68\x25\xcc\x16\x89\xe2\x29\x04\xcb\x36\xa4\x35\xae\x69\x0e\xe3\x7b\x47\x1a\x52\x49\xda\x09\x7f\x66\x25\x0d\x1b\xc1\x83\x4a\xf1\x7a\xc0\x8d\xdb\x7c\x7d\xe4\xae\xc0\xf3\x69\xd0\x64\xca\xe2\x12\xf9\xf7\xdd\xfd\x55\xaa\x7f\xc9\xcf\x85\xc6\x07\x86\x63\x5f\x6d\x0b\x3e\xdc\x37\xfb\xc1\x20\x9e\xca\x1b\xbc\x4f\xa2\x5a\xf6\x2f\x62\xf0\x61\x2e\x30\x88\xa6\x39\x27\x4e\x95\xd8\x6b\xad\x61\x30\xed\x50\xba\xd6\x27\x5a\x7f\x98\x04\x03\x3a\xeb\x16\xef\x28\xd5\x27\x9a\x60\x5f\x97\x8c\xec\x64\xe1\xa9\xa3\x78\xbf\xa6\xab\x36\xbc\x11\xef\xc0\x11\xa9\x72\x1e\xbb\xde\x07\x70\xfb\x59\xef\x3a\x71\x9b\x77\xdd\x94\x4d\x95\xbe\xee\xbf\x50\xae\xaf\xcc\xe1\xd8\xe0\x10\x14\xad\x48\x91\x60\x54\xdf\xd9\x6a\x18\xda\x1f\x78\x68\x65\xe1\xbd\xaa\xdb\x03\x47\xca\xf8\x7e\xb7\xad\x9e\xe1\x5f\xae\xa7\xc1\xd2\xb8\xf7\xc6\x51\x01\x0e\x3b\xe1\x91\x1c\x57\xfd\x1b\x55\x0d\x74\xff\xe8\x89\x58\x69\xc8\xbf\x80\xcd\x66\xf0\x29\x4d\xab\x5b\xca\xf1\x3d\x38\xb8\x05\x97\xda\x8a\x20\xa6\xe9\x3f\xb4\xab\x7e\x57\x6e\xc8\x64\xf2\x6c\x93\x13\x2f\x3c\x62\xde\x8d\xf8\x25\x13\x0e\xa1\x1f\x46\xff\x07\x00\x00\xff\xff\x9a\xb6\x11\x2f\x8f\x10\x00\x00" func switchboardAdd_vault_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -582,11 +562,11 @@ func switchboardAdd_vault_capabilityCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/add_vault_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xaf, 0x1b, 0x91, 0x9c, 0x2d, 0x7, 0x8c, 0xba, 0x72, 0x99, 0x5d, 0xd0, 0xd8, 0x0, 0xf0, 0xd, 0x43, 0x69, 0x1e, 0xcd, 0x9, 0x7d, 0x70, 0xf7, 0x1e, 0xb2, 0x37, 0x90, 0xe8, 0x12, 0x64, 0x58}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb5, 0xcb, 0xd4, 0x4, 0x63, 0x88, 0xd, 0x95, 0x8e, 0xa0, 0xb1, 0x41, 0x92, 0xbc, 0x5, 0xb7, 0x91, 0xb9, 0x40, 0xac, 0xe3, 0xc6, 0x26, 0xe6, 0xae, 0xb, 0x30, 0xcd, 0x6e, 0x1b, 0xe6, 0xa0}} return a, nil } -var _switchboardAdd_vault_wrapper_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\xcd\x6e\xa4\x3c\x10\xbc\xf3\x14\xad\x39\xe4\x63\xa4\x88\xb9\x8f\xf2\xf3\x45\xd1\x66\x6f\xab\x28\x89\x76\xcf\x8d\x69\xc0\x0a\xd8\xa8\xdd\x84\x8c\xa2\xbc\xfb\xca\x86\xb0\xf6\xee\x64\x14\x0e\x23\x06\x77\x97\xab\xaa\xcb\xd6\xfd\x60\x59\xe0\x6e\x34\x8d\x2e\x3b\x7a\xb2\xcf\x64\xa0\x66\xdb\xc3\x26\xf9\xb6\xc9\x8e\x55\x3e\x4e\x5a\x54\x5b\x5a\xe4\xea\x58\x53\xb4\xbc\xf6\x7f\x7b\xc5\x7e\x48\x37\x8a\x3f\x6d\xb2\x6c\xb7\x83\xa7\x56\x3b\x10\x46\xe3\x50\x89\xb6\x06\xb4\x03\x04\xa1\x7e\xe8\x50\x08\x6a\xcb\xfe\x6f\xb4\x2e\x2d\x8a\x6f\x54\x76\xec\x2a\x28\x09\x46\x47\x15\x94\x07\x40\x73\xb0\x86\x40\x2c\x60\x55\x01\x82\xa1\x09\x5e\x70\xec\x04\x26\xc6\x61\x20\x0e\x5d\x38\x60\xa9\x3b\x2d\x07\x5f\x28\x2d\x69\x06\x17\x49\x63\x72\x76\x64\x45\x59\xbc\xe5\x5b\x96\x01\x00\x74\x24\x20\x9e\xf9\x9d\xe5\x09\xb9\x22\xbe\x5d\xd1\xf6\xf0\xe7\xfd\xe2\xec\x2d\xf1\xa6\x78\x20\x45\xfa\x85\xf8\xfd\x6a\xc5\x89\xf6\x7c\xa0\x7a\x0f\x70\xf6\x99\x9d\x45\xf4\x3e\xf3\x18\x98\x06\x64\xca\x9d\x6e\x0c\xf1\x1e\x6e\x46\x69\x6f\x94\xb2\xa3\x91\xed\x07\x57\xff\xec\x76\xf0\xdd\x53\x6e\x69\xa6\xed\xcd\x9c\x79\xc7\x36\x84\xc1\xf8\x9a\x19\xee\x3f\x07\x38\x63\xad\x38\x8e\xba\xba\xf8\x4c\x38\x5c\xc2\x5a\x18\x8a\x03\x4a\xd1\x90\x7c\xdd\x90\x53\x4f\x1e\x47\x66\x6d\xbc\x1f\xcb\x4e\xab\x7b\x94\x76\xbb\x22\xc4\xba\x6f\x5b\x52\xcf\xa0\xeb\x20\x8c\x97\xa6\x58\x35\xbd\x6a\x27\x6e\x6d\x41\xe7\x88\x25\x3f\xa9\xb4\x50\x1e\x34\xdf\x9e\xa7\x82\x7b\x72\x0e\x1b\xda\xc3\xe6\x31\x48\x87\xca\x92\x03\x63\x05\x5a\x7c\x21\x40\x98\x2c\x3f\x6b\xd3\x40\xbd\x58\xb0\x0c\xe3\x08\xab\xcd\x71\x31\x7e\x88\x08\x4c\x35\x31\x19\x45\x4b\x70\x17\xa7\x5d\x1c\xa5\x74\x64\x69\xc6\xe0\xf2\x63\x36\xa5\x65\xb6\xd3\xc5\x97\x12\x97\x0e\x28\xf7\x61\xd9\x7f\x7a\x31\x14\x8f\x62\x19\x1b\x0a\x73\x49\x5d\xba\xbe\x86\x01\x8d\x56\xf9\xe6\x36\x9c\x5b\xef\xcf\xcc\x23\x15\x16\x71\x5e\xdc\x08\x3f\xef\x73\xaa\xe9\x95\xd4\x28\xf4\x57\xc8\x6f\xaa\x2a\x18\xf2\xcf\xd9\x4e\x4e\xf6\xe8\xfc\x10\xb0\xaa\x7e\xd0\xf4\x33\x5c\x0b\x3d\x49\x6b\x4f\x7a\x56\x44\xe5\xbf\xe6\x4b\x24\x57\xd1\x99\x3f\x99\x97\x73\x90\xc3\x40\x7b\x78\x3a\x0c\x74\xf1\x7f\x12\xe3\x00\x78\x95\x6f\x53\x85\xef\xd9\xef\x00\x00\x00\xff\xff\x36\x7e\xb8\x46\xa3\x05\x00\x00" +var _switchboardAdd_vault_wrapper_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x55\x4b\x6f\xe3\x36\x10\xbe\xeb\x57\x7c\xf5\x21\x95\x80\x85\x7c\x37\xb2\x49\xb7\x69\xb7\xa7\x3e\xb0\x6b\xa4\xe7\x31\x35\x96\xd8\xc8\xa4\x40\x8e\xac\x18\x0b\xff\xf7\x82\x94\xf5\xda\xc4\x46\x0f\xd5\xc1\x96\xe4\x79\x7d\x8f\xa1\xf5\xa1\xb1\x4e\xb0\xfa\xdc\x9a\x52\xef\x6a\xde\xda\x17\x36\xab\xe4\xdd\xd7\x5f\x3b\x2d\xaa\xda\x59\x72\xc5\x14\xf1\xeb\x2b\x1d\x9a\xdb\x79\xbf\xb3\x50\x41\x42\xcf\x9a\x3b\xbf\x4a\x92\xf5\x7a\x8d\x6d\xa5\x3d\xc4\x91\xf1\xa4\x44\x5b\x03\xed\x41\x10\x3e\x34\x35\x09\x63\x6f\x5d\x78\x9c\xfd\x2e\x15\x09\x94\x6d\xeb\x02\x3b\x46\xeb\xb9\xc0\xee\x04\x32\x27\x6b\x18\x62\x41\x45\x01\x82\xe1\x0e\x47\x6a\x6b\x41\xe7\xa8\x69\xd8\x41\x51\x43\x3b\x5d\x6b\x39\xc5\xbe\x62\x21\x15\x6b\x07\x3f\x81\x81\x63\x6f\x5b\xa7\xf8\x32\x19\x9f\xd0\xc5\x46\xff\xb4\x5e\x60\x98\x8b\x90\xa6\x2a\x32\x25\x87\x6c\x28\x6b\xc4\x91\x12\x18\x3a\xc4\x37\x27\x90\x63\xf4\xe0\xb5\x29\xb1\x77\xf6\x30\x6b\x07\x09\x34\x4c\x69\x11\x4b\x4c\xeb\xc8\x48\x08\xf2\x6d\x13\x89\xeb\xb4\x54\x6f\x07\x0c\xa5\x92\x39\x19\xdf\x92\x04\x00\x6a\x96\xbe\xf4\x17\x56\xac\x8f\xec\x9e\x46\xb0\x1b\x4c\xf7\xf7\x77\xdf\x16\x7a\xe4\x43\xf8\xf9\x61\x2c\x33\xeb\xf6\x85\xf7\x1b\x80\x5a\xa9\xd2\x6b\xf2\xe7\x7f\x76\x86\x5d\x86\xbb\xab\x01\xb3\xfb\x7e\xd6\xc6\x71\x43\x8e\x53\xaf\x4b\xc3\x6e\xd3\xd7\xff\xd9\x3a\x67\xbb\x67\xaa\x5b\xce\x70\xf7\x49\x29\xdb\x1a\xc9\x06\x78\xc3\x6c\x51\xd0\x5f\x48\x08\x1f\x31\xb7\x5b\x1e\x74\xab\x8f\xfc\x74\xe1\x35\xf8\x2b\x1d\xb4\xdc\x9e\x1a\xde\xc0\xe8\xfa\x03\x8e\x9a\xbb\xfe\x31\x7c\xde\x5f\xf7\x66\xfe\x79\xfb\x3c\xf4\x7a\x48\xb3\x0c\xe4\x7f\xc0\x7f\x0b\x7f\x1c\x27\x0e\xd7\xe3\x23\x1a\x32\x5a\xa5\xab\xa7\x68\x24\x63\x05\xe5\x80\x04\xa1\x40\x1c\x2a\xda\x7c\x6e\xa8\x55\x36\x21\x5f\xaf\xf1\x1b\xcb\xcc\x3e\x7b\xeb\x3a\x72\xc5\xc2\xd3\xd1\x69\x31\xa6\xe7\xf5\x47\x0f\xea\x59\x1c\xeb\x78\xae\xf7\xf9\x15\x97\xe0\xe3\x25\x2f\x1f\x4b\x6a\xf6\x79\xc9\x72\xc3\x33\xe9\x02\xea\x28\x4e\xee\x2e\x11\x7f\x91\x54\x4b\x1c\x4f\x15\xab\x17\xe8\x7d\x1c\x74\x08\x9b\xa3\xe0\x57\xed\xc5\x8f\x29\xe4\x3d\x3b\x59\xf6\xb9\x05\x23\x57\xa1\x41\x9a\x7d\x58\x64\x1c\xd8\x7b\x2a\x79\x83\xd5\xd7\x88\x11\x85\x65\x1f\xa5\xa8\xe8\xc8\x20\x74\xd6\xbd\xc4\x6d\xbd\x00\xbd\xf0\xfc\xce\x80\xab\xb1\xf0\x5b\x81\x08\x8e\xf7\xec\xd8\x28\x1e\xd6\xbd\xe7\xd4\x2f\x56\x78\x81\x63\xb9\x6d\x93\x0a\x5e\xac\xa3\x92\xf3\x5d\xdc\x8b\xfb\xff\x6f\x07\xbf\x13\x2d\x5c\xc1\x39\x1b\x5c\x4f\xee\x47\x09\x62\x2e\x52\xb3\x77\xcd\xdd\x0f\xbc\x64\x62\x06\x72\xf0\xf5\xb9\xff\xe2\x57\x56\xad\xf0\x7c\xcf\xd7\x6b\x7c\x2a\x8a\x7e\x19\x26\x5f\x0c\x7c\xce\xce\xea\xd6\x07\xc9\xa8\x28\xfe\xe0\x2e\x6e\x1f\x0e\x2c\x95\xbd\x49\x70\x3e\x0b\xff\xbb\xff\x5f\x58\xf2\xa1\x66\xe7\xe6\x2d\xa3\x2d\x0d\x26\xd3\x99\xf2\xd3\xe2\x5c\x8a\x8d\x1e\xd2\xec\x7b\xd7\x9c\x93\xe4\x9c\xfc\x1b\x00\x00\xff\xff\xc1\x6f\x30\xb6\x72\x07\x00\x00" func switchboardAdd_vault_wrapper_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -602,11 +582,11 @@ func switchboardAdd_vault_wrapper_capabilityCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/add_vault_wrapper_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xac, 0xe9, 0x7a, 0x55, 0xa, 0x8a, 0xf4, 0x72, 0xbd, 0xd7, 0x2f, 0x41, 0xe6, 0x48, 0xd, 0x3e, 0x1e, 0x4, 0xd7, 0x8, 0x57, 0x68, 0x93, 0x92, 0x3c, 0xe0, 0xf6, 0xec, 0xfd, 0x79, 0x1, 0xaa}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x30, 0xd2, 0xdf, 0xb, 0x44, 0x27, 0x54, 0x20, 0x57, 0x1f, 0x45, 0x36, 0x1b, 0x68, 0x11, 0x8, 0x75, 0xac, 0x18, 0xa, 0xa8, 0x0, 0x79, 0xcb, 0x6f, 0xb6, 0x55, 0x99, 0xe6, 0x55, 0x61, 0x23}} return a, nil } -var _switchboardBatch_add_vault_capabilitiesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x53\x41\x6b\xdb\x4c\x10\xbd\xeb\x57\x3c\x7c\xf8\x70\x20\xc8\x77\xf3\xa5\xc1\x2d\x6d\x6f\x25\x24\xa1\x97\x10\xc8\x68\x77\x64\x2d\x95\x77\x97\xdd\x91\x1d\x53\xf2\xdf\xcb\x4a\x8a\xbc\x0a\x76\xa9\x0e\x66\xad\xd9\x37\x7a\x6f\xde\x1b\xb3\xf3\x2e\x08\xbe\x75\x76\x6b\xaa\x96\x1f\xdd\x2f\xb6\x0f\x07\x23\xaa\xa9\x1c\x05\x8d\x3a\xb8\x1d\x16\x97\xca\x8b\x62\xc4\x7f\x7d\xa5\x9d\x1f\xeb\x23\x26\x7f\xb5\x28\x8a\xd5\x0a\x8f\x8d\x89\x90\x40\x36\x92\x12\xe3\x2c\x4c\x04\x41\x78\xe7\x5b\x12\x46\xed\x42\xfa\x9b\xd5\xa5\x21\x81\x72\x5d\xab\x51\x31\xba\xc8\x1a\xd5\x11\x64\x8f\xce\x72\x6a\x28\x0e\xa4\x35\x22\xef\x39\x50\x0b\xcb\x07\xd4\x23\x53\x48\x4f\x65\x4f\x5d\x2b\xf1\x1a\x15\xb7\xce\x6e\x8d\xdd\xf6\x18\x28\x0e\x42\xc6\xe2\x65\xa3\x75\xe0\x18\x5f\xd2\xeb\xbe\x63\xc3\x26\x20\x66\x03\x08\x1c\x5d\x17\x14\x97\x45\xce\x6c\x49\x03\x70\x8d\xb1\xc3\x15\x7e\x17\x05\x00\xb4\x2c\xe0\x4c\xfa\xcf\xc4\xe0\x8e\xa4\x59\xe3\xae\xab\x5a\xa3\xd2\x79\xba\xb9\x7f\xaf\xc6\x35\x9e\x4e\xf5\xe7\xe9\x42\x46\xe5\x9e\xeb\x35\xf0\xdf\x25\x2f\xca\xec\x3c\x50\xf1\x81\x3d\x05\x5e\x46\xb3\xb5\x1c\xd6\xd8\x74\xd2\x6c\x94\x72\x9d\x95\x89\x6e\x7a\x56\x2b\x7c\x67\x49\xda\xdf\x99\xe7\xd3\x83\x27\x69\x06\x4f\xd3\x0d\xe5\xac\x04\x52\x32\xa1\x23\xb7\x75\x79\x56\x31\x6e\x66\xb9\x28\xef\x59\xb1\xd9\x73\xf8\x30\x07\x20\x67\xb2\xb1\x1a\x51\x5c\x60\x18\x81\xb1\xfd\x37\x29\x04\x3a\xc2\xd5\xf0\x3d\xb2\x67\x14\x87\x74\x1c\x4c\xdb\xa6\x70\x78\x8a\x29\x1e\xe2\x12\x20\xef\x97\x7b\xb9\x63\x69\x9c\x9e\x33\x3f\x39\x80\x1b\x3c\x3d\x5f\x2a\x96\xe4\x3d\x5b\xbd\xbc\xac\xf6\xea\x8c\x98\x34\x56\x42\xe0\x9a\x03\x5b\xc5\x23\x3d\x0c\x86\xc4\x9c\xdb\xfc\xbb\x73\xd7\x71\x33\x22\xca\xca\x85\xe0\x0e\xff\xff\x53\x06\x3e\x4d\x2d\xcf\x3d\xcb\x64\xe8\xfa\xe2\xde\x97\x0f\xe2\x02\x6d\xb9\x17\x86\xbf\x76\xba\xbd\x85\x27\x6b\xd4\x72\xf1\xa5\xdf\x54\xeb\x04\x03\xcf\xb9\xf0\x4c\xd3\x62\x98\x55\xff\xf3\x36\xe4\x90\x5f\x59\x75\xc2\xa7\x58\xa6\x28\x68\x3d\x44\x8e\x3c\x55\xa6\x35\x72\x9c\x06\x98\x99\xda\xc5\xb4\xd6\xa4\xf5\x0f\x3e\xf4\x66\xcc\x6d\x3e\x33\xcf\x32\xbb\x1c\x3f\x1f\xfb\xa8\x2e\xfd\xb0\x84\x1f\x6c\xbf\xc6\xb4\xe8\xe3\xe1\xaa\x78\xa7\xfd\xf6\x27\x00\x00\xff\xff\xc4\xdc\x11\x4a\x3c\x05\x00\x00" +var _switchboardBatch_add_vault_capabilitiesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x94\x41\x6f\x9b\x4c\x10\x86\xef\xfc\x8a\xf7\xf3\x21\x02\x29\xc2\x77\x2b\x4e\x94\xe4\x6b\x7a\x6a\x1b\xb5\x96\x2f\x51\xa4\x0c\x30\x36\xab\xe2\x5d\xb4\x3b\x98\x58\x55\xfe\x7b\xb5\x80\xf1\x52\xd9\x52\x0f\xe5\x80\x16\x76\x66\xf6\x9d\x99\x67\x56\xed\x6a\x63\x05\xb3\xa7\x46\x6f\x55\x56\xf1\xca\xfc\x64\xfd\xa3\x55\x92\x97\x99\x21\x5b\xcc\xa2\xa3\xc5\xa7\x77\xda\xd5\x83\xc1\xe9\xef\xc4\xef\x0b\x0b\x15\x24\xb4\x56\xdc\xba\x59\x14\xcd\xe7\x73\xac\x4a\xe5\x20\x96\xb4\xa3\x5c\x94\xd1\x50\x0e\x04\xe1\x5d\x5d\x91\x30\x36\xc6\xfa\xcf\x60\x5f\x4a\x12\xe4\xa6\xa9\x0a\x64\x8c\xc6\x71\x81\xec\x00\xd2\x07\xa3\x19\x62\x40\x45\x01\xc7\x7b\xb6\x54\x41\x73\x8b\xcd\xa0\x00\xe2\x25\x74\x67\xee\xa9\xa9\xc4\x5d\x23\xe3\xca\xe8\xad\xd2\xdb\xce\x0f\x39\x5b\x21\xa5\xf1\x76\x5f\x14\x96\x9d\x7b\xf3\xbf\xa5\x64\x65\xe1\x4e\x19\xc3\xb2\x33\x8d\xcd\x39\xf5\xb1\xa2\x50\x5a\x4c\xbd\xe3\x02\x43\x84\x04\xbf\xa2\x08\x00\x2a\x16\x70\x50\xa0\xb5\x57\xf0\x4c\x52\x2e\xf0\xdc\x64\x95\xca\xfd\x7a\xb4\xdc\x1f\x77\xdd\x02\x2f\xa7\xfd\xd7\xd1\x20\x90\xf3\x9d\x37\x0b\x80\x1a\x29\xe3\x4b\x3d\x4a\xbf\xb5\x9a\x6d\x82\xab\x8b\x06\xc1\xba\xd7\x5b\x5b\xae\xc9\x72\xec\xd4\x56\xb3\x5d\xf4\xf1\x1f\x8c\xb5\xa6\x5d\x53\xd5\x70\x82\xab\xfb\x3c\x37\x8d\x96\x31\xc5\x89\xf8\xff\x49\x08\x4b\x84\x4c\xa4\xbe\x6e\xd5\x9e\x1f\x8d\x16\x4b\xb9\x78\x08\xe2\x63\x2d\x57\x87\x9a\x17\xd0\xaa\xba\xc6\x5e\x71\xdb\x7f\xfa\xf7\xcd\x65\x80\xd2\xa7\xd5\xfa\x78\xd6\x6d\x9c\x24\x20\xf7\x1f\xfe\xce\xfc\x6e\x54\xec\x9f\xbb\x3b\xd4\xa4\x55\x1e\xcf\x1e\x3b\xac\xb4\x11\x6c\x8f\x99\xc0\x07\xe8\x44\x75\x2c\x4a\xc9\xc8\x87\x0c\x66\xc9\x29\xf3\xf9\x1c\x9f\x59\xba\xed\xa1\xcf\x3d\x6f\x43\x90\x9a\xa4\xc4\xc6\x9a\xdd\x24\xc0\xe8\xed\xb8\xda\xa4\x67\xf9\xc0\xf2\x54\xd0\xd4\x72\xce\x6a\xcf\x76\x84\x05\x08\x05\xdc\xeb\x02\x4e\x8c\x65\x28\x81\xd2\xdd\x51\x64\x2d\x1d\x60\x36\xa8\x3b\x8c\x3a\x21\xae\x9f\xa1\x56\x55\x95\x1f\xa1\x9a\x9c\x1f\xa2\x9e\xf5\x30\x5e\x08\xfd\x8e\xa5\x34\xc5\x54\xf0\x09\x53\x2c\xf1\xf2\x7a\x69\x33\xa5\xba\x66\x5d\xc4\x97\x93\x4c\xce\x24\xe3\xab\x49\xb0\xbc\x61\xcb\x3a\xe7\x41\x1e\x7a\x20\x5d\xa8\x6d\x7a\xee\x74\x34\xb0\x1c\x3c\x52\x5f\x18\xda\x72\x9a\x75\x10\xdf\xfc\xbb\x81\xb9\x8d\x27\x30\xf9\x26\x2f\x70\xd9\xb1\x97\x11\x74\x10\x48\xce\x12\xd8\x0b\x9d\x56\x20\x48\x6e\xd6\x17\xad\x7b\x7d\xf4\x1c\xf2\x3b\xe7\x8d\x70\x38\x90\x9e\x8a\xa2\xe8\xa1\xa3\x9a\x32\x55\x29\x39\x8c\xb5\x0c\xfa\xdb\x38\x7f\x0d\x52\x51\x7c\xe5\xb6\xeb\xcb\xd9\x8e\x4f\x8b\x9b\x06\xe6\xee\xe1\xe0\x73\x8a\xeb\xfe\xd6\xfa\x03\x81\x6b\x8c\x37\xe3\xb0\x18\x46\xe7\x23\x8a\x3e\xa2\xdf\x01\x00\x00\xff\xff\xf3\xcc\x85\x32\x64\x06\x00\x00" func switchboardBatch_add_vault_capabilitiesCdcBytes() ([]byte, error) { return bindataRead( @@ -622,11 +602,11 @@ func switchboardBatch_add_vault_capabilitiesCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/batch_add_vault_capabilities.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x29, 0x7f, 0x18, 0x77, 0xaf, 0x95, 0x78, 0xd4, 0x66, 0xec, 0x46, 0x64, 0x6b, 0x3d, 0x15, 0x4f, 0xec, 0x65, 0xfd, 0x3b, 0xef, 0xcf, 0x5f, 0x71, 0x3e, 0x8, 0xd6, 0x61, 0x3a, 0xa2, 0x71, 0x41}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9b, 0x8, 0x81, 0x7c, 0x0, 0x31, 0xb7, 0x3, 0xa, 0x32, 0x93, 0xdc, 0xd9, 0x66, 0xaa, 0xd8, 0x98, 0xf7, 0xb1, 0xec, 0x5c, 0x9a, 0x48, 0x75, 0x28, 0x63, 0x2e, 0x41, 0x6d, 0x9d, 0x51, 0x38}} return a, nil } -var _switchboardBatch_add_vault_wrapper_capabilitiesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x54\xcd\x6e\xdb\x3c\x10\xbc\xeb\x29\x06\x3e\x7c\x91\x81\x40\xbe\x1b\xf9\xf9\xd2\xa2\xed\xad\x08\x92\xa0\x3d\x04\x01\xbc\x96\x56\x16\x51\x99\x24\xc8\x55\x1c\xa1\xc8\xbb\x17\xa4\x14\x9b\x4e\x23\x24\xe5\xc1\x16\xb9\x3f\xdc\x99\x59\xae\xda\x5a\xe3\x04\x5f\x3b\xbd\x51\xeb\x96\xef\xcc\x2f\xd6\xb7\x3b\x25\x65\xb3\x36\xe4\x2a\xd4\xce\x6c\x31\x9b\x32\xcf\xb2\x31\xfe\xcb\x13\x6d\xed\x68\x1f\x63\xd2\xa3\x59\x96\x2d\x16\xb8\x6b\x94\x87\x38\xd2\x9e\x4a\x51\x46\x43\x79\x10\x84\xb7\xb6\x25\x61\xd4\xc6\x85\x6d\x62\x97\x86\x04\xa5\xe9\xda\x0a\x6b\x46\xe7\xb9\xc2\xba\x07\xe9\xde\x68\x0e\x09\xc5\x80\xaa\x0a\x9e\x1f\xd9\x51\x8b\x92\x2c\xad\x55\xab\x44\xb1\x1f\x62\xad\x51\x5a\x82\x5b\x3d\x02\x80\xc4\x0a\x1f\xa9\x6b\xc5\xc3\xd4\x20\x54\xaa\xae\xd9\xb1\x16\x00\x21\xe9\xea\xae\xb7\xbc\x02\xe9\x70\x69\x6b\xf4\x26\x5e\x83\x92\x9d\x90\xd2\x58\x5d\x55\x95\x63\xef\x57\xa7\xe1\x5c\x1a\x56\x0e\x3e\x21\xcc\xb1\x37\x9d\x2b\xb9\xc8\x52\x24\x39\x0d\x51\x4b\x8c\xe1\x73\xfc\xce\x32\x00\x68\x59\x86\x72\xae\x49\x1a\xbf\xc4\xfd\x75\xb7\x6e\x55\x19\x76\x0f\xc7\x0e\xa1\xae\xe0\x10\xfe\x0f\xa6\xe4\xee\x1b\xae\x97\xc0\x7f\x53\x62\x15\xc9\xf7\x70\xb7\x75\x6c\xc9\x71\xee\xd5\x46\xb3\x5b\xe2\xaa\x93\xe6\xaa\x2c\x4d\xa7\x65\x5f\x5f\x58\x8b\x05\x6e\xc5\x38\x0e\x70\x5f\xa4\xc6\xa0\xb5\xe3\x92\xd5\x23\xbb\x13\x0f\x1b\x0b\x87\x25\x69\xa0\x74\xf4\x25\xe7\xa8\x0f\x34\x8f\xb6\x34\x63\xf0\x1b\x65\xda\xa9\xb6\x0d\x0a\x5b\xf2\x41\xe3\x81\xd7\x23\x56\xb7\x2c\x8d\xa9\xf6\xe1\x9e\xdb\xba\x38\xb0\x86\x73\xdc\x3f\x4c\x19\x0b\xb2\x96\x75\x95\xa7\xfd\x58\xdc\x8c\x65\x1f\xc8\x9e\x7f\x04\xee\x89\x87\xf4\x96\xff\x82\x17\x0e\xdf\xc6\x92\x26\xfd\x17\x5c\x51\xec\x29\x5c\xd1\xf8\x82\x2b\x6c\xce\xfe\x3f\x42\xf7\x23\x38\x5d\xe4\xf3\xf9\x18\x9b\x16\xf1\x8d\x05\x04\xc7\xb1\xe7\x4b\xde\x17\x15\x5b\xc0\xa7\xc5\x1d\x5f\x7c\xdc\x67\x38\x1f\x23\x8a\xb5\x71\xce\xec\xce\x3e\xd4\x75\x17\xfb\x94\xef\xae\x3c\x0c\x91\xe5\xe4\x5c\x2a\x82\x40\xb4\xe1\xa8\x1c\xde\x4d\x7b\x79\x09\x4b\x5a\x95\xf9\xec\x73\x9c\x26\xda\x08\x86\xc2\x8f\x99\x48\x40\xce\x06\xf2\xe2\xcf\xf3\xd0\x1b\xfc\xc4\x65\x27\x7c\x78\x19\x8b\x45\x78\xce\x91\xbf\xfd\xec\xe9\x73\xc5\x7e\xfe\x96\xd6\x9d\x57\x7a\x13\x06\xd6\x77\xde\x45\x85\x7e\xba\x20\xa1\xf3\x9f\xfa\x00\x23\x9b\x24\xbb\x98\x8c\xc9\xed\x30\x34\x5e\xb5\xfc\xe9\xfb\x8c\xa4\x4b\x86\xc1\xf2\xaa\xbf\x4e\xb1\x9f\x59\xe3\xc7\xf8\x44\x9e\xb3\xec\xf9\x4f\x00\x00\x00\xff\xff\xf1\xb3\x2c\x41\x37\x06\x00\x00" +var _switchboardBatch_add_vault_wrapper_capabilitiesCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x54\x4f\x6f\xfb\x36\x0c\xbd\xfb\x53\xbc\xe5\xf0\xfb\xd9\x40\xe0\xdc\x83\xfe\x59\xdb\xad\x3b\x6d\x2b\xd6\xa0\x3b\x14\x05\xc2\xd8\x74\x2c\xcc\x91\x04\x89\x4e\x1a\x0c\xfd\xee\x83\x64\x27\xb1\xbb\x04\xe8\x80\xe5\xe0\xd8\x22\x29\xbe\x47\x3e\x52\x6d\xac\x71\x82\xc9\x63\xab\xd7\x6a\xd5\xf0\xc2\xfc\xc5\xfa\x79\xa7\xa4\xa8\x57\x86\x5c\x39\x49\x0e\x1e\x3f\xbf\xd3\xc6\xf6\x0e\xa7\xd3\x51\xdc\xaf\x2c\x54\x92\xd0\x8b\xe2\x9d\x9f\x24\xc9\x6c\x36\xc3\xa2\x56\x1e\xe2\x48\x7b\x2a\x44\x19\x0d\xe5\x41\x10\xde\xd8\x86\x84\x51\x19\x17\x3e\x07\x76\xa9\x49\x50\x98\xb6\x29\xb1\x62\xb4\x9e\x4b\xac\xf6\x20\xbd\x37\x9a\x21\x06\x54\x96\xf0\xbc\x65\x47\x0d\x0a\xb2\xb4\x52\x8d\x12\xc5\xbe\x0b\xb4\x46\x69\x89\x89\xc5\xa0\xea\xc1\x41\x02\x3a\x6c\xa9\x6d\xc4\xc3\x54\x20\x94\xaa\xaa\xd8\xb1\x16\x2c\x17\x7b\xcb\x4b\x90\x0e\xf9\x1a\xa3\xd7\x31\x09\x0a\x76\x42\x4a\x63\x79\x57\x96\x8e\xbd\x5f\x4e\xc3\xb9\xd4\xac\x1c\xfc\xa9\x3e\x70\xec\x4d\xeb\x0a\xce\x43\xd2\x64\x48\x24\xa5\x2e\x72\x8e\xfe\x8a\x0c\x7f\x27\x09\x00\x34\x2c\x1d\x98\x27\x92\xda\xcf\xf1\xfa\xd4\xae\x1a\x55\x84\xaf\xb7\xb1\x43\xc0\x16\x1c\xc2\xff\xc9\x34\xc8\xff\x07\x57\x73\x80\x5a\xa9\xd3\x4b\x2d\xcc\x7f\xdf\x69\x76\x19\xbe\x5d\x74\x18\xbc\x77\x00\xad\x63\x4b\x8e\x53\xaf\xd6\x9a\xdd\xbc\xbb\xff\xde\x38\x67\x76\x2f\xd4\xb4\x9c\xe1\xdb\x5d\x51\x98\x56\xcb\x91\xd3\x08\xf6\x4f\x24\x84\x6b\x0c\x25\x93\x87\x42\x35\x5b\x7e\x30\x5a\x1c\x15\x12\x34\x92\x1e\x8a\x17\xe8\xcd\xa1\x55\x33\xc5\x56\xf1\xae\xfb\x0c\xcf\xab\xcb\xfa\xca\x1f\x17\x2f\x87\x5c\x37\x69\x96\x81\xfc\x0f\xf8\x9a\xfb\xed\x11\x71\xf8\xdd\xde\xc2\x92\x56\x45\x3a\x79\x88\xaa\xd3\x46\xb0\x3e\x30\x41\xb8\x20\x82\x8a\x52\x95\x9a\x51\xf4\x0c\x26\xd9\x89\xf9\x6c\x86\x67\x31\x8e\xa3\x43\x4f\x1b\x11\x04\x1c\x17\xac\xb6\xec\xbe\x7b\xd8\xd8\x66\x58\x92\x1a\x4a\x47\x5f\x72\x8e\xf6\x41\x92\xbd\x6d\x78\x63\xf0\xeb\x65\xbd\x53\x4d\x13\xc6\xc1\x92\x0f\x03\xd1\x29\x71\xa4\xc3\x0d\x4b\x6d\xca\x63\xb8\xe7\xa6\xca\x4f\x1a\xc3\x35\x5e\xdf\x2e\x19\x73\xb2\x96\x75\x99\x1e\x5b\x97\x1f\x30\x07\xf3\x97\x58\x7e\xf7\x90\xbd\xe5\x7f\xb1\x0a\x87\xe7\x29\x0c\x2f\xfd\x2f\x74\xe2\x44\x5c\xa2\x13\x8d\x07\x3a\x51\x3f\x3f\x8e\x34\x18\x15\x10\xc4\xd2\xc7\x0e\x41\xfc\xc2\x02\x82\xe3\xb8\x16\x0a\x3e\x82\x8a\x23\xe0\x87\xe0\xc6\x89\xc7\xc3\x88\xeb\x3e\x22\xf7\x62\x1c\xad\x39\x5f\xc5\xb1\xb9\xfa\xff\x46\xf4\x26\x1d\xc9\x37\xfc\x2a\x67\x36\x73\x5c\x0e\xee\xa0\x84\x6e\x8e\x42\xb3\xb3\xda\xef\x00\x8f\x2b\x31\x20\x39\xe9\x8a\x17\x1f\x1f\x9d\x36\xf8\x9d\x8b\x56\x78\xb8\x0a\x66\xb3\xb0\xf5\xba\x79\x39\x2c\xe9\x7d\xaa\xd8\x67\xe7\xba\xdd\x7a\xa5\xd7\x61\xb3\xff\xc6\xbb\xd8\xa3\x3f\x5d\x68\xa2\xf3\xf7\xfb\x11\xe8\x33\x05\xcf\x2f\x46\x8d\xcb\x64\xbb\x55\xfb\x49\xfa\x53\x8c\x9c\xa4\x5b\xb7\x9f\x04\x35\x1d\xf9\x1c\xb7\x7a\xff\x72\x34\xf6\x83\xf2\x91\x24\x1f\xff\x04\x00\x00\xff\xff\xf6\x7f\x27\x53\x56\x07\x00\x00" func switchboardBatch_add_vault_wrapper_capabilitiesCdcBytes() ([]byte, error) { return bindataRead( @@ -642,11 +622,11 @@ func switchboardBatch_add_vault_wrapper_capabilitiesCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/batch_add_vault_wrapper_capabilities.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf6, 0x59, 0x81, 0xe6, 0x82, 0x64, 0x28, 0x6c, 0x45, 0x37, 0xa2, 0xf2, 0x24, 0xed, 0x3f, 0x27, 0x80, 0x7a, 0x68, 0x23, 0x1c, 0x69, 0x57, 0xc4, 0xd2, 0x59, 0x17, 0xa6, 0x21, 0x36, 0x70, 0x29}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x90, 0x87, 0xef, 0xef, 0xe1, 0x12, 0x69, 0xb6, 0x6d, 0x72, 0xa8, 0xbd, 0x17, 0x91, 0x11, 0x34, 0xe0, 0x89, 0x19, 0x5d, 0x48, 0x24, 0x6c, 0xf6, 0xef, 0x4, 0x4f, 0xa2, 0xbe, 0x33, 0x17, 0xdc}} return a, nil } -var _switchboardRemove_vault_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x53\xcf\x6f\x9b\x30\x14\xbe\xf3\x57\x7c\xe2\xd0\x91\x0b\xb9\xa3\xae\x55\x15\x6d\xbb\x56\x69\xb5\xbb\x71\x1e\x60\x0d\x6c\x64\x3f\xa7\x8d\xa2\xfc\xef\x13\x98\x81\x91\xc2\xb6\x5c\x02\xb6\x3f\xbe\x5f\xcf\xaa\xeb\x8d\x65\x7c\xf7\xba\x56\x65\x4b\xef\xe6\x17\x69\x54\xd6\x74\x48\x57\x6b\x69\x72\xef\xe4\xdb\x87\x62\xd9\x94\x46\xd8\xd3\x3d\x50\xb4\x3d\xe3\xbf\x7d\x8a\xae\x5f\x13\xc5\x4b\x69\x92\xec\xf7\x78\x6f\x94\x03\x5b\xa1\x9d\x90\xac\x8c\x86\x72\x10\x60\xea\xfa\x56\x30\xa1\x32\x76\x78\x8d\xf6\xb9\x11\x3c\x00\xa5\xf1\xed\x09\x25\xc1\x3b\x3a\xa1\xbc\x40\xe8\x8b\xd1\x04\x36\xb0\xd4\x99\x33\xa1\x9a\x04\x82\x47\x05\x67\xe1\xdb\x80\x14\xbd\x28\x55\xab\xf8\x12\x54\x71\x43\xca\xc2\x45\x06\x2d\x39\xe3\xad\xa4\x24\x22\xce\x7a\xc1\x4d\x81\x57\x5f\xb6\x4a\xbe\x0a\x6e\x76\xb8\x26\x09\x00\xb4\xc4\xa0\xc8\xd8\xcf\x81\xe8\x10\x48\xf8\x52\xe0\x30\xf3\x3d\x3e\x5c\x57\xa9\xe5\x47\x92\xa4\xce\x64\x6f\x4f\xf3\x97\x22\x1d\x47\xaa\x0a\xe0\x61\x2b\xe8\x3c\x7a\x0e\x4a\x7a\x4b\xbd\xb0\x94\x39\x55\x6b\xb2\x05\x5e\x3c\x37\x2f\x52\x1a\xaf\x79\x56\x0b\xec\xf7\xf8\x41\x3c\xd8\xbe\x17\x05\x02\xf8\x8b\x83\x08\xc8\x09\xe5\xa8\xad\xf2\x6d\x9b\xf8\x3a\x01\xf3\x9a\x78\x71\x3c\x81\xd7\xbf\xbf\xc4\x30\xa6\xbc\x9b\x50\x6b\xbd\x02\x96\x2a\xb2\xa4\xe5\x58\xf2\x22\xd5\xad\xba\x43\xac\x77\x1d\xe6\xa2\xb1\x34\xd6\x9a\x8f\xc7\xff\x8a\xf6\x69\xf6\x90\x0d\x19\x15\x9b\xf7\x22\x7f\x63\x63\x45\x4d\x61\x38\x22\xe7\xcf\xcf\xe8\x85\x56\x32\x4b\x0f\xe3\xd0\x6a\xc3\x08\x0a\xd6\x96\x22\xb5\xe9\x2e\xb4\x75\x0b\x7f\xf4\x49\xd2\x33\xad\x3a\x3c\x86\x29\xdf\xac\x31\xca\xc4\x3b\xa5\xeb\x71\x75\x81\x87\x4b\x32\x96\x88\x8e\xb8\x31\xa7\xed\xe0\xf2\xe8\x70\xb6\x90\x15\xff\x1a\x8a\x50\xe4\x1f\x23\xb7\xe4\x77\x00\x00\x00\xff\xff\x36\x73\x1f\x58\x83\x04\x00\x00" +var _switchboardRemove_vault_capabilityCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x93\x4f\x8f\x9b\x3c\x10\xc6\xef\x7c\x8a\x47\x39\xe4\x85\x0b\xdc\xd1\xbe\xbb\x6a\xa3\xb6\xc7\xae\xd2\xd5\xde\x07\x67\x08\x56\xc1\x46\xf6\x38\xd9\x68\x95\xef\x5e\x01\x59\xfe\xa8\xa1\xbd\xd4\x17\xc0\xcc\xcc\xf3\xf8\x37\x1e\xdd\xb4\xd6\x09\x36\x5f\x83\x39\xea\xa2\xe6\x17\xfb\x93\xcd\x26\xba\xbb\xfd\xe3\xac\x45\x55\x85\x25\x77\x98\x22\xbe\xbc\x51\xd3\x8e\x79\x51\x96\x65\x78\xa9\xb4\x87\x38\x32\x9e\x94\x68\x6b\xa0\x3d\x08\xc2\x4d\x5b\x93\x30\x4a\xeb\xba\xcf\xd9\x7f\xa9\x48\xa0\x6c\xa8\x0f\x28\x18\xc1\xf3\x01\xc5\x05\x64\x2e\xd6\x30\xc4\xc2\x71\x63\x4f\x8c\xf2\x66\x06\xd2\x89\xe1\x44\xa1\x96\x5e\x50\x51\x4b\x85\xae\xb5\x5c\x50\x3a\xdb\x40\x2a\xd6\x0e\x7e\xb2\x0b\xc7\xde\x06\xa7\xb8\x0b\x8f\x66\xd2\x71\x4b\x52\xe5\x78\x0e\x45\xad\xd5\x33\x49\x95\xe0\x3d\x8a\x00\xa0\x66\x01\xcf\xce\xf6\xda\xa9\xed\x06\x21\xb9\xe4\xd8\x8d\x9a\x0f\xdb\xf7\x05\xa6\x74\xcf\x8a\xf5\x89\xdd\xf5\x71\xac\x34\xf3\xb2\xe7\x32\x07\x28\x48\x15\xaf\xd1\x4d\xbf\x9f\x0d\xbb\x04\xdb\xd5\x80\xd9\xfb\x60\xb7\x75\xdc\x92\xe3\xd8\xeb\xa3\x61\x97\x0f\xf5\x3f\x5b\xe7\xec\xf9\x95\xea\xc0\x09\xb6\x9f\x94\xb2\xc1\xc8\x78\xc2\x6e\x65\x19\xbe\xb1\x74\xc0\xee\x41\xc4\x50\xed\x3f\x0f\x1a\x72\xc7\x3c\xcf\x75\x99\xae\xe3\xc1\xff\xb7\xd4\x74\xac\xaa\xd9\xa7\x47\x96\x3f\xc0\xea\x7b\x91\xfc\xe6\x8d\xe0\xb8\x64\xc7\x46\xf5\x77\x61\xb2\xe5\xe7\x54\x97\xce\x96\xb8\x27\x37\x5e\xac\xa3\x23\xa7\x45\x0f\xe6\xe1\xdf\x35\xe1\x31\x1e\x0d\x7c\xac\x0e\x62\x8e\xf5\xe4\xc1\x4a\x77\xe7\x16\xa9\x09\x9e\x9e\xd0\x92\xd1\x2a\xde\xec\xfa\x91\x30\x56\x30\x18\x5e\x92\x98\x1d\x72\x73\xc3\x76\x1d\x1e\xfc\xc6\x2a\x08\x4f\x8d\xce\x32\xec\x87\x19\x5a\xed\xf4\x6c\x58\x82\xd7\xe6\xd8\xef\xa6\xc3\xe4\xf5\xcd\x8d\x13\x34\x2c\x95\xfd\x40\x7d\x07\xf4\x22\x7c\x52\xc9\xff\x76\x5d\x26\xf7\xd7\xe8\x57\x00\x00\x00\xff\xff\x8b\xa6\x9d\xb1\x91\x04\x00\x00" func switchboardRemove_vault_capabilityCdcBytes() ([]byte, error) { return bindataRead( @@ -662,31 +642,11 @@ func switchboardRemove_vault_capabilityCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/remove_vault_capability.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xac, 0xcb, 0x2b, 0x62, 0x7b, 0xca, 0x3f, 0xde, 0x8c, 0x12, 0x9, 0xaa, 0x96, 0xba, 0xca, 0x21, 0xe8, 0x13, 0x67, 0xf6, 0x7a, 0xe9, 0xc3, 0x3a, 0x82, 0xd7, 0xe7, 0xb2, 0xe1, 0xc0, 0x8c, 0x39}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x60, 0xc2, 0xce, 0x7f, 0x72, 0x8a, 0x85, 0x53, 0x9c, 0x9c, 0x10, 0x9e, 0xf2, 0x96, 0x21, 0x5f, 0x4f, 0xfb, 0xd1, 0xad, 0xc5, 0x15, 0x11, 0x1, 0x5b, 0x8a, 0x25, 0xb3, 0x33, 0x2f, 0x8, 0x57}} return a, nil } -var _switchboardSafe_deposit_to_lnfCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x57\x4d\x6f\xe3\x36\x10\x3d\xaf\x7f\xc5\xac\x0f\x5e\x1b\x70\xec\x4b\xd1\x83\x91\x8f\xba\x49\x5d\x2c\xb0\x87\x20\xc9\xb6\xd7\xd0\xd2\xc8\x62\x57\x26\x05\x72\x14\xad\x11\xf8\xbf\x17\x24\x45\x49\x94\x64\x6f\xb6\x48\x75\xf0\xae\xa8\x99\xe1\x9b\xc7\x79\x33\x0c\xdf\xe7\x52\x11\x6c\x0a\xb1\xe3\xdb\x0c\x9f\xe4\x37\x14\x90\x28\xb9\x87\x71\xb0\x36\x1e\x0d\x59\x3e\x96\x9c\xa2\x74\x2b\x99\x8a\x87\x9c\x5a\x9f\x1b\x7f\xce\x28\xd8\xc5\xbf\xd7\x16\x5f\xa4\xa6\xb5\x88\x37\xb2\x10\x3e\x6a\x7b\xa9\x89\x94\xc9\x32\x88\xe4\xdf\xc7\xa3\xd1\x72\x09\x4f\x29\xd7\x40\x8a\x09\xcd\x22\xe2\x52\x00\xe1\x3e\xcf\x18\xa1\x86\x54\x96\x40\x12\x34\x8a\x18\xbe\x3e\xde\xdd\x42\x52\x88\x58\xc3\x33\xc9\x67\x60\xe2\x00\xcf\xeb\x38\x56\xa8\xf5\x33\x94\x9c\x52\x59\x10\x7c\x13\xb2\xe4\x62\x07\x26\x30\x4f\x80\x13\xa4\x32\x8b\x35\x30\x78\x61\x45\x46\x20\x13\xa0\x94\x11\xe8\x1c\x23\x9e\xf0\x08\xc8\x02\xa3\x43\x8e\x0b\x78\x4a\x31\x00\x52\xf2\x2c\x03\x46\x06\x0f\x19\x1c\x26\x68\x8c\xb9\xd4\x9c\x80\x52\xac\xd0\x70\x41\xd2\xbe\x2a\x8c\x90\xbf\xa0\xfa\xa4\x41\x37\x84\xce\x0d\x0e\x21\x21\x62\x39\xdb\xf2\x8c\xd3\x01\x12\xa9\x40\xc9\x82\x3c\xd0\x10\xd1\xe6\x09\xb8\x86\xc4\xb2\x6a\xd8\x48\x31\x0c\x47\x29\x0a\x93\x98\x45\xd7\x87\x63\x33\xf7\x90\x82\x23\x8a\xa4\x20\xc5\x22\x5a\x8c\x96\xcb\x51\x2b\xcf\x29\xc9\x15\x54\x4c\xce\x81\xed\x65\x21\x68\x05\x5f\x37\xfc\xfb\xaf\xbf\xcc\xe0\x75\x04\x00\x60\x7f\xec\x61\x99\x3c\x13\x54\x28\x22\x84\x6a\x17\x47\xad\x3d\x5c\xf3\x9a\xb3\x83\x25\x81\x45\x91\x09\x65\x5d\x33\x24\x67\xf6\x80\xc9\x0a\x26\x75\x31\x2d\xfe\x32\x8b\xed\xe8\x76\x01\x14\x6a\x59\x28\xb3\x85\xe1\xc6\x9d\xa1\x89\x6d\x8f\x4b\xbb\x55\xa6\x10\xb6\x68\x48\xb4\xc9\x24\xa8\x14\xc6\xf5\x6e\x1a\x05\xd9\x58\x2b\xf8\x2d\x28\xf6\x70\xcb\x75\x3f\x1d\xcd\x77\xc2\x26\x90\x64\xb2\x74\xa8\xe7\x6e\x47\x4b\xf9\x16\xa1\xd0\x18\xdb\x53\xcc\xd9\xc1\xee\x6f\xa8\x9e\x6c\x20\x41\xd4\x50\x23\x30\xee\xf7\x4a\xbe\xf0\x18\x95\x4b\xfb\x35\x04\xe2\x3f\x1e\x1b\x30\xad\x2a\x19\x44\xe3\xca\xd5\x57\x9a\xab\x24\x8c\xe4\x0b\xaa\x2e\x8e\x00\xc6\x43\xe5\xb0\x82\xdb\x7a\x83\xcb\x49\x2d\x44\x47\x49\x07\x9d\xf7\x39\x5e\xdf\x8c\x6c\xb0\x5c\x61\xce\x14\x4e\x1d\xa2\x15\xac\x0b\x4a\xd7\xee\x8c\x4d\x99\x58\x9b\x2a\x91\x3f\x91\x80\x9d\x61\x56\x93\x54\x18\x3b\x6e\x6b\x3f\x8d\x59\xb2\xf0\x45\x02\x57\x95\xf5\x62\x2b\x95\x92\xe5\x65\xb7\x66\xae\xa7\xa6\xe0\x56\xd0\x59\x7e\x24\xa9\xd8\x0e\xef\x19\xa5\xb3\xd1\x87\x0f\x1f\x6e\x6e\x20\x67\x82\x47\xd3\xf1\xad\x2c\xb2\x18\x84\x24\x70\x11\xfb\xf0\x64\xe9\xd0\xd9\x40\x1f\xc7\xb3\x76\x46\x7f\x73\x4a\x63\xc5\x4a\x5f\x81\x75\xb5\xbf\x21\xa7\xba\x14\xe1\xf2\x22\x48\x72\x51\x56\x51\xa7\x5e\x75\xee\xdf\x59\x40\xe6\xef\x0e\xee\x39\x3e\x5b\xb5\x91\x57\x45\x15\x42\xe8\xd4\x62\x9f\xdd\x53\xa5\xe9\x69\x5e\x6a\x47\xec\x32\xf1\x45\x63\x33\x6a\x38\x32\xcf\x19\xb2\x07\x44\x55\x43\x1d\xcf\x7a\xc5\x63\xb2\x6b\x69\xc1\xb6\xed\xf3\x5a\xe8\xe7\xeb\x0b\xb8\x49\x76\x87\xf4\x5f\xea\x7f\xba\xcc\x8b\x6d\xc6\xa3\x26\x77\xff\x6d\xd6\x34\xc7\xa3\xcb\x01\xbf\x63\x54\x10\x0e\xe8\xa1\x1a\x11\x3c\xe7\x28\xe8\x93\x06\x17\xd3\x77\x49\x90\xdb\x7f\x30\x6a\x0a\xc7\x28\xb7\xb6\x86\x2b\xd8\x21\x55\x5a\x9b\x92\x6c\xf1\xc5\x13\xd7\xed\x9a\x09\xe1\x8e\xb7\xf6\x0d\x93\x9e\x9e\x9a\xfb\x8b\x7b\x0b\xc7\xe9\xa6\x7d\xa6\x8d\xfe\x4e\x79\xb6\xfe\xff\xfa\x16\x23\xb7\xd3\xf1\x7a\xea\x87\x4b\x8b\xa8\x75\x33\x6d\xdb\xa3\xad\x35\xfc\x7f\x30\x6e\x21\x88\x58\xb1\x23\x24\xdd\xb9\x68\x18\xd7\x42\x0c\x18\x5b\x68\x96\x60\x65\x53\x55\xfc\xe5\x45\x47\xbd\x27\xd5\xda\xcd\xa3\xca\xe5\x73\x52\x5f\x3b\xb8\x06\x85\x54\x28\x81\x7e\x80\x53\x8a\x5c\xd5\x39\xc6\x3c\x16\x9f\x08\x74\x11\x45\x68\x4c\xb4\x84\x12\x21\x2f\x68\x28\x6e\xe7\xea\x61\x66\x3c\xac\x45\x0c\x76\xca\xf7\x1c\x4c\xfe\x7b\xdc\x4b\xb8\x82\xf1\x5d\x81\xa0\xe4\x81\x65\xc4\x51\x8f\x07\x4d\x2b\x44\x7f\x68\xe2\x7b\x46\x68\x58\x68\x5f\x22\x16\x58\x7d\xf0\x5c\x29\x8c\x11\xf7\x66\x1c\x90\x9c\x03\x27\xb4\xcc\xf5\x08\x9f\x5b\x0c\x2b\xfb\x3b\x87\x98\xeb\x3c\x63\x87\x15\x08\x9e\xcd\x06\x61\x54\xdd\x66\x83\x58\x9f\x43\xa7\x85\xf5\x4f\xa3\x03\x7d\xd1\xc4\x18\xde\xa3\xbe\x63\x5c\x5e\xf4\x7c\xeb\xe0\x2d\xa9\xf9\x27\xe0\xa3\x72\x9c\xf6\xac\xcc\x13\x90\x33\x68\xe1\x09\xf3\x58\x86\xad\x5a\xdc\x0d\x7e\x6f\xf3\x39\x6c\xa1\xfd\x58\x3c\xec\xd1\x70\x35\x69\x11\xcc\x34\x4c\x06\x6e\x48\xc3\x81\x5a\x2d\x30\xf7\xc1\x7a\x1d\xb7\xe7\x39\xc0\xe2\x72\x09\x0f\x56\x12\xf6\x26\xaf\x70\xcf\xb8\x30\x77\x98\x0a\x98\xbb\x4b\x71\x23\x14\xae\x2b\x15\x55\xc2\x8f\xa4\x48\xf8\xae\xf0\x97\xbd\x4e\x50\x3b\x1a\x7a\x43\xa1\xe6\xa1\x0b\xf5\x63\xd5\xdf\xa6\xb3\x8f\xf5\x59\x7a\xfd\x9f\x2b\xa0\x18\x35\x29\x79\xe8\x16\x4e\x60\x77\x1c\x0d\x79\x84\x4d\xa5\x36\x39\x02\x66\x1a\xfb\x1d\xf1\xb3\x1b\x7d\x85\x46\x65\xda\x84\x9d\xa9\x29\x8b\x81\x05\x5d\xaf\xc4\x53\x7f\x99\x7c\x99\x6c\x82\x90\x6f\xec\x07\xef\xd7\x0b\xc2\x7c\xdf\xda\x08\xfe\xef\x26\xf0\x13\x0d\xa0\xed\xf6\x36\xed\x9f\xd7\xfd\x8f\x35\x7f\x4e\xef\xe7\xb5\xfe\x2e\x3a\xff\x79\x8d\xcf\xba\x55\xfb\xbe\xd2\x3e\x2b\xeb\x77\x91\xf4\x29\x39\x37\x7d\xeb\xe8\x6f\x79\xc7\x11\xfc\x1b\x00\x00\xff\xff\xfd\x84\x52\xd0\x8d\x11\x00\x00" - -func switchboardSafe_deposit_to_lnfCdcBytes() ([]byte, error) { - return bindataRead( - _switchboardSafe_deposit_to_lnfCdc, - "switchboard/safe_deposit_to_lnf.cdc", - ) -} - -func switchboardSafe_deposit_to_lnfCdc() (*asset, error) { - bytes, err := switchboardSafe_deposit_to_lnfCdcBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "switchboard/safe_deposit_to_lnf.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x26, 0x5a, 0x67, 0x79, 0x0, 0x7b, 0x1d, 0x2a, 0xd, 0x55, 0x35, 0xb6, 0xc4, 0x4b, 0xa9, 0x5e, 0xbf, 0x8d, 0x29, 0x23, 0xde, 0x9d, 0xfe, 0x59, 0xb5, 0xa3, 0xb4, 0x70, 0x0, 0x9, 0x5a, 0x96}} - return a, nil -} - -var _switchboardSafe_transfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x55\x4d\x6f\xdc\x36\x10\x3d\x7b\x7f\xc5\x64\x0f\xb5\x16\x70\xe4\x4b\xd1\xc3\xc2\x49\x6a\x24\x75\xaf\x41\xe2\xb6\x67\x4a\x1c\x49\xac\xb5\x1c\x61\x38\xb2\xbc\x30\xfc\xdf\x0b\x7e\x48\x4b\xf9\x03\xb5\x0f\xb6\x48\x0e\x67\xe6\xbd\x79\x7c\x36\x87\x81\x58\xe0\x66\xb4\xad\xa9\x7a\xbc\xa5\x3b\xb4\xd0\x30\x1d\x60\xbb\xda\xdb\x6e\x5e\x8b\xfc\x39\x19\xa9\xbb\x8a\x14\xeb\xd7\x2e\x65\xc7\xcb\xfd\x3f\x1e\xd4\x61\x58\x17\xca\xb7\xb6\x9b\xcd\xe5\x25\xdc\x76\xc6\x81\xb0\xb2\x4e\xd5\x62\xc8\x82\x71\xa0\x40\xf0\x30\xf4\x4a\x10\x1a\x62\xbf\xcc\xce\xa5\x53\x02\x35\x8d\xbd\x86\x0a\x61\x74\xa8\xa1\x3a\x82\xb2\x47\xb2\x08\x3e\xa3\x10\x38\xb4\x1a\xc4\x17\x71\x7e\xa9\x2c\x49\x87\x0c\xaa\xae\x69\xb4\x02\xd2\x31\x8d\x6d\x07\x0a\x5c\x86\x6a\x74\xc6\xb6\x20\x1d\x82\x53\x0d\x7e\xc3\x81\x9c\x11\x9f\xf0\x80\xd2\x91\x2e\x63\xab\x71\x01\x93\xe9\x7b\xb0\x24\x30\x28\x6b\x6a\x30\x4d\xbc\x98\xa5\xd3\x84\x2e\x44\x74\xea\x1e\xfd\xa9\x4f\x55\xab\x41\x55\xa6\x37\x72\x0c\x6d\x0a\x71\x38\x02\x8d\xce\x30\x6a\xb8\xb9\xbd\x00\x46\x19\xd9\xce\xbd\xe8\xd8\x07\x6a\xb8\x57\x63\x2f\x60\xac\x13\x54\xba\x8c\xdc\x21\x4c\x46\x3a\xcd\x6a\x02\x75\x08\xd8\x94\x47\xde\xe1\x82\x35\xf0\xde\xa2\x5c\xa7\xf5\x34\x33\xe7\x83\x06\xc5\xea\x80\x82\xec\x66\xe6\xfc\x6e\xc6\x76\xb9\xc9\x16\x85\xd0\x1e\xae\xb5\x66\x74\xee\x22\xd5\xdb\xc3\x5f\x37\xe6\xe1\xb7\x5f\x77\xf0\xb8\x01\x00\x08\xbf\x52\x6b\x8c\x0d\x32\xda\x1a\xe7\xc4\x11\x41\xe8\x28\x56\x3f\x22\x9f\xbb\xb9\xd5\x70\xb5\x47\x89\x61\x3f\xb0\xd9\xc3\x2f\xb9\x5e\xca\xbf\xfd\x7e\x5e\x20\x6c\x00\xa3\xa3\x91\x7d\x15\xaf\x8c\x8e\x7a\xed\x22\x8c\x34\x7f\xbf\xab\x18\xa1\xc2\xc0\xa9\xc7\xd3\x20\x33\xea\xa5\xa0\x43\x2b\x21\xd7\x1e\x7e\x5f\xa9\x3a\x95\x0c\x81\x03\xe3\xa0\x18\x0b\x67\x5a\x8b\xbc\x87\xeb\x51\xba\x44\xaa\x07\x1f\x62\x52\x6f\x7f\xa2\x80\x7a\x09\x3f\xde\x3c\x77\x71\xee\x69\xa0\xcb\x3d\x87\x7d\x53\xce\xd0\xe1\x53\x8a\x2e\x2b\x62\xa6\xe9\xea\x15\x26\x3e\x17\x9e\xc9\x3d\xbc\x3c\xf9\x29\xc4\xaa\xc5\xef\x4a\xba\xdd\xe6\xec\xec\xec\xcb\x97\x28\xd3\x62\xfb\x35\x4c\xdf\xab\x32\xe6\x7d\xd9\x24\x4d\xb1\xc7\x90\xe8\xc3\x76\xb7\x02\xf6\xcf\x2c\xb6\xc4\xed\x32\xca\x77\x40\x5b\x48\x86\xab\x8f\x2b\xac\xe5\x2c\xe1\x62\x96\x54\xfc\xbb\x3b\x09\xea\x29\x76\x81\x0f\x58\x8f\x82\xaf\xb0\x2d\x41\x6e\xb5\x19\x0c\x5a\x39\x77\x30\x8c\x55\x6f\xea\xe5\x11\x50\xf5\x2f\xd6\xa7\x7e\xfc\xcc\x97\x68\xf8\x94\x3d\x8f\x42\x68\xf7\x9e\x51\xe6\xb5\x72\x67\xfc\x81\x35\x9a\x7b\xe4\x55\xa9\xcc\x15\xe2\x68\x97\xdb\x65\x8b\xf2\x75\xb1\x84\xe2\x2d\x47\x2d\xbf\x07\x38\x71\x9e\x90\xfd\x2c\xea\x78\xf3\x66\xf6\xfd\xf8\x9e\xa0\x58\xe9\xe9\x73\xf1\xff\xc2\x89\x48\xd7\xdc\x64\x50\x3f\x6c\x77\xcb\xfc\x56\x1f\x97\x97\x90\xcc\x35\x50\xd9\x8c\x56\x3b\x08\xc6\xbe\x32\xd0\x8b\xd9\x54\x93\x03\x9e\x0c\xb5\x26\xaf\x77\xc1\x3c\xa3\x0f\xcc\xad\x39\x9a\x68\x56\x20\xf9\x26\x50\x13\x21\xdd\x19\xdb\x5e\x80\x23\x98\x30\x39\x34\xe5\xf9\x18\x6b\xf2\xe8\xa4\x23\x97\x52\x2c\xc7\xa6\x09\x63\xb5\x24\xdf\x66\x73\x5e\x84\xbd\x1a\x75\x99\xfd\x23\x49\x8f\xf5\xea\xe3\xb3\xd7\xf0\xa6\xfa\x77\x8f\xab\x51\xaf\x9f\x8c\x7e\x96\xf4\x45\x2f\x27\x9d\x3c\x9d\xf4\xac\xd1\x09\xd3\xf1\x59\x07\xab\x67\xf6\xb4\xf9\x2f\x00\x00\xff\xff\x53\xe1\x5a\x5d\x27\x08\x00\x00" +var _switchboardSafe_transfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x55\x4b\x6f\xe4\x36\x0c\x3e\x67\x7e\x05\x33\x87\xc4\x06\x76\x3d\x97\xa2\x87\x41\x1e\xdd\xdd\x36\x3d\x15\x58\x6c\xd3\xe9\x99\x96\xe9\x31\xbb\x1a\xc9\x90\xe8\x38\xc6\x22\xff\xbd\x90\xe5\x67\x1e\x45\xea\xc3\x18\xb2\xc8\x8f\x8f\xef\x23\x87\x4f\xb5\x75\x02\xdb\xbb\xc6\x1c\x39\xd7\x74\x6f\xbf\x93\xd9\x6e\x5e\xfd\xfc\x67\xcb\xa2\xaa\xdc\xa2\x2b\x66\x8b\xdf\x1e\xf1\x54\xff\xb7\xdf\x1f\x24\x58\xa0\xe0\x81\xa9\xf5\xdb\xcd\x66\xb7\xdb\xc1\x7d\xc5\x1e\xc4\xa1\xf1\xa8\x84\xad\x01\xf6\x80\x20\x74\xaa\x35\x0a\x41\x69\x5d\x38\x2e\xee\xa5\x42\x01\x65\x1b\x5d\x40\x4e\xd0\x78\x2a\x20\xef\x00\x4d\x67\x0d\x81\x58\xf0\x64\x0a\x90\x10\xce\x87\x23\x1a\x2b\x15\x39\x40\xa5\x6c\x63\xa4\x8f\x29\x95\xb3\xcd\xb1\x02\x04\x3f\x57\x02\x8d\x67\x73\x04\xa9\x08\x0a\xaa\xad\x67\x81\x13\x49\x65\x0b\xc8\x1b\x81\x9c\x4a\xeb\xa6\x9b\x60\xd8\x12\xb4\xac\x35\xd0\x63\xad\x59\xb1\xe8\x0e\x54\x45\xea\x3b\xb4\x15\xf5\x11\x1d\x29\xe2\x07\x36\xc7\x3e\xa6\xc2\x1a\x73\xd6\x2c\x5d\xa8\x30\xb7\xce\xd9\x16\x73\x4d\x60\x1d\x18\x2b\x80\xa6\x00\x2e\xa1\x23\x1f\x52\x30\xc0\x12\xe1\xc7\x5c\x42\x5e\x0f\xd8\x68\x09\x45\x85\x43\x84\x27\xb7\x40\xce\x42\xa4\xcd\xa2\x59\x89\xd8\x3d\x7c\x2a\x0a\x47\xde\x7f\x00\x3c\x85\x0e\xec\xe1\xaf\x3b\x7e\xfc\xf9\xa7\x14\x7e\x6c\x36\x00\x00\x3d\x09\x01\xaf\x24\x47\x46\xd1\x18\x20\x46\x2b\x9d\x3d\xf5\xc7\x1a\x3b\x72\x97\x7e\x6a\x64\x70\xd5\x24\xd1\xec\x1b\x95\x7b\xc0\x46\xaa\x64\x45\x78\xf6\x37\x4b\x55\x38\x6c\x53\xb8\x58\xea\x23\x3b\x04\xa7\x18\xbe\x76\x54\xa3\xa3\xc4\xf3\xd1\x90\x1b\x50\x3e\xf7\xfd\x39\xa0\x6e\x28\x85\x8b\x4f\x31\xe4\x94\xf1\x2a\xf4\xaf\x28\x08\xd7\xb0\x82\x77\xe4\xad\x7e\xa0\x2f\xd6\x88\x43\x25\x41\x6f\x49\xf8\xd6\x38\x45\xf7\x5d\x4d\x7b\x30\xac\x3f\xc0\x03\x53\x1b\x8f\xe1\xf7\xea\x6d\xad\x66\x77\xf7\x87\x31\xd6\x4d\x92\xa6\x80\xfe\x1c\xde\x67\x7e\x3b\x65\x1c\x9e\xdb\x5b\xa8\xd1\xb0\x4a\xb6\x5f\x7a\x05\x07\xe6\x8f\x63\x25\x10\x00\xfa\xa4\x7a\xd9\x87\xa6\xab\xa1\x82\x6d\x3a\x57\xbe\xdb\xc1\xef\x24\x80\x2f\x19\x8b\x2d\xbc\xf4\xe0\xc5\x3a\x2a\x22\xea\xe4\xe7\x49\x97\xd9\xc8\x16\x5c\x0f\xd6\x59\xb0\xc5\x23\x65\x51\x92\x57\xff\x97\xc4\x9b\x24\x28\x64\x3f\x73\x31\x02\x7e\x45\xa9\xd2\xcd\xd9\xd9\xd9\x6b\x35\xc7\x60\x2f\x2b\xb0\x6d\x2c\xa0\x87\x3e\x1f\xab\x7e\x8a\x2f\x7a\x24\xd5\x08\x2d\x55\x30\xf4\x62\x98\x07\xae\x99\x8c\x5c\x7a\xa8\x9b\x5c\xb3\x1a\xa5\x0a\x36\xff\x87\x94\xac\xa4\x33\x59\xc3\x75\x20\x60\x50\x58\x22\x36\x5d\x4b\xcc\x93\x91\x3e\x19\xb8\xfa\xb8\xee\x60\xd6\x0e\x6d\x49\xc6\xb9\x8a\xef\x77\x31\xb5\x4c\x76\xb1\x4d\xbf\xf6\x79\xaf\x13\x98\x6f\x23\x6d\x93\x6b\x36\x0d\x3e\x93\x1f\xe9\xbb\xf8\xf1\xd6\xa6\xce\x5e\xc4\x79\xba\x49\x56\xe2\x0c\xcf\x9b\xde\xd1\x25\x90\xba\xf2\x49\x5f\x95\xf4\x44\xef\xb0\xa2\x56\xf5\x2f\x2a\x3a\xdf\xa6\x01\x64\xd5\xb1\x03\x6a\x2e\xc2\xea\x9f\x97\x5c\x58\xb7\x8b\xfd\x99\x77\xc3\xae\xf6\x58\x52\xdc\x14\x9f\xbb\x30\xc1\x13\x0c\x97\x23\xc9\xd1\x7b\x10\xfc\xaa\x95\xd9\x73\xef\x44\xe6\x55\xf0\xcb\x6b\x42\x4f\xc3\x02\x5a\x16\xff\x0c\x70\x58\xd5\xc3\x40\x5c\x7d\x9c\xb4\x93\x4e\x5e\x4f\x40\xda\xd3\x33\x98\xdd\x0e\xbe\x91\x34\xce\x40\xd9\x98\xa2\xff\xd7\x9a\x26\x79\x94\x30\x97\x73\x37\xd9\xf7\x4d\x56\xd6\x94\x7c\x6c\xc2\xa0\x8b\x1d\x6f\xfb\xae\xf5\x30\xeb\x4c\x57\xca\x7d\x4f\xa2\xe3\xe0\x3d\x6d\xfe\x0d\x00\x00\xff\xff\x1e\xee\x83\xe0\x1a\x08\x00\x00" func switchboardSafe_transfer_tokensCdcBytes() ([]byte, error) { return bindataRead( @@ -702,31 +662,31 @@ func switchboardSafe_transfer_tokensCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/safe_transfer_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa0, 0x86, 0x70, 0xee, 0x6e, 0x97, 0x1c, 0x9c, 0x3a, 0xb5, 0xce, 0x49, 0x1c, 0x37, 0x46, 0x5c, 0xb7, 0xce, 0x1, 0x38, 0x34, 0x5a, 0x92, 0xdc, 0x3b, 0xa1, 0xf9, 0xc3, 0x25, 0xb6, 0x5e, 0x29}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x59, 0x85, 0x2e, 0x4, 0xcf, 0xf2, 0xab, 0xdc, 0xdd, 0x31, 0x4d, 0x67, 0xa9, 0x3f, 0x85, 0xcc, 0x24, 0xa0, 0x6c, 0xf1, 0xb9, 0xa9, 0x62, 0xd3, 0xc9, 0xae, 0x74, 0xfb, 0x3a, 0xdb, 0x10, 0xa2}} return a, nil } -var _switchboardSafe_transfer_tokens_v2Cdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x4d\x6f\xe3\x38\x0c\x3d\x37\xbf\xe2\x35\x87\xad\x03\xec\xba\x97\xc5\x1e\x82\x7e\x17\xdb\xbd\x16\x6d\xb7\x73\x96\x6d\x3a\xd6\x54\x91\x0c\x89\xae\x63\x14\xf9\xef\x03\x59\x8e\x23\xa7\x29\xa6\xb9\xc4\x92\xc8\x47\x3e\x3e\x92\x72\x5d\x1b\xcb\x78\x68\xf4\x4a\x66\x8a\x5e\xcc\x1b\x69\x94\xd6\xac\x31\x9f\xdc\xcd\x67\xc7\x2c\x9f\x5b\xc9\x79\x95\x19\x61\x8b\x63\x4e\xd1\xf3\xe8\xff\xef\x46\xac\xeb\x69\xa0\xf8\x6a\x3e\x9b\x9d\x9f\xe3\xa5\x92\x0e\x6c\x85\x76\x22\x67\x69\x34\xa4\x83\x00\xd3\xba\x56\x82\x09\xa5\xb1\xfe\x18\xbd\x73\x25\x18\xb9\x69\x54\x81\x8c\xd0\x38\x2a\x90\x75\x10\xba\x33\x9a\xe0\x11\xd9\xc0\x91\x2e\xc0\x3e\x88\xf3\x47\xa1\x0d\x57\x64\x21\xf2\xdc\x34\x9a\xc1\x95\x35\xcd\xaa\x82\x80\x8b\x58\x35\x4e\xea\x15\xb8\x22\x14\x54\x1b\x27\xd9\x83\xad\x89\x2b\x53\x20\x6b\x18\x19\x95\xc6\x8e\x8f\xde\xb6\x25\xb4\x52\x29\xd0\xa6\x56\x32\x97\xac\x3a\xe4\x15\xe5\x6f\x68\x2b\xea\x03\x5a\xca\x49\xbe\x7b\xd3\x5c\xd4\x22\x93\x4a\x72\x07\xe9\x3c\x70\x66\xac\x35\xad\xc8\x14\xc1\x58\x68\xc3\x10\xba\x80\x2c\xd1\x91\xf3\x49\x68\x48\x0e\xe8\x43\xc0\x3e\xb3\x77\xd1\x28\xf6\x94\xfc\x21\xa0\x93\x8d\xc0\xd3\x59\x54\xaa\x84\xcd\x12\xb7\x45\x61\xc9\xb9\x3f\x21\xd6\x9e\xfb\x12\xff\x3f\xc8\xcd\x3f\x7f\x2f\xf0\x31\x9b\x01\x40\x2f\x81\xc7\x2a\xc9\x92\xce\x69\x07\x1e\x22\xf5\xaa\xf9\x63\x2d\x3a\xb2\x67\x6e\x57\xc2\xde\x55\x11\x07\xb3\x27\x2a\x97\xf8\x23\xd6\x36\x7d\xf5\xf7\x71\x80\xfe\x02\x96\x9c\x69\xac\x8f\xe2\x55\xac\x8c\x2a\x7a\xb2\xa3\x56\xfe\x56\x58\x42\x46\xbd\x16\x9e\x4b\x49\xd6\x52\x31\x06\x74\xa4\xb9\xc7\x5a\xe2\x66\xd2\x81\x43\xc8\xde\xb0\xb6\x54\x0b\x4b\x89\x93\x2b\x4d\x76\x89\xdb\x86\xab\xdb\x90\xf9\x48\x7c\xc8\xed\x3f\x62\x88\xcf\xf4\x83\xe7\x99\x83\x63\x63\xa9\x08\x3c\x47\x3f\x47\xaa\x4c\x77\xd4\x71\x39\x58\xa7\x41\xd3\x8b\x23\x95\xb8\x4a\x7c\x25\x97\xf8\xfc\xf2\xcc\xc6\x8a\x15\x3d\x0a\xae\x16\xb3\x93\x93\x93\xeb\x6b\xd4\x42\xcb\x3c\x99\xdf\xf7\x3d\xee\x3b\x23\xe0\x7e\x4e\xd2\xb4\x21\xc7\x1e\xe8\x74\xbe\x98\x10\xfb\x21\xb9\x2a\xac\x68\x77\xb5\x1d\xa5\xfc\x06\xb5\xb1\xc8\xb8\xf8\x6b\xc2\x35\x6d\x07\xd4\x64\xd7\x4e\xe1\x7f\x08\xbd\x0d\x7f\xb4\xa1\xbc\x61\x3a\x52\xe9\xa1\x6d\x65\x2d\x49\xf3\x99\x43\xdd\x64\x4a\xe6\xe3\x60\x9a\xec\x27\xe5\xfb\x5c\xbc\xde\xa3\x35\x2e\xb1\x22\x1e\x54\x4c\xd8\x2c\xbe\x23\x63\x1c\x2b\xde\x60\x4f\xc3\xe8\x4c\x42\x45\xcb\x20\xc8\x3a\x7a\xa7\x2b\xe2\xfb\x71\xc8\x92\xaf\x36\x5f\xfa\xd8\xd3\x09\x5a\x22\xfa\x8d\x9d\xf1\xa5\x67\xf4\xfd\xf1\x1d\xa3\x10\x69\x7b\x95\xfc\xbe\x69\x86\x25\x31\xa9\x4d\x44\xf5\x74\xbe\xf0\x29\x4e\xaa\xf9\x2a\x94\x2c\xfc\xfa\xdd\xaf\x99\x83\x25\x96\x75\xc3\xbe\x74\xa2\xa4\xbb\x3e\xd4\x5d\xf7\xd2\xd5\x34\xc2\xc8\x72\xa7\x5f\xf0\x1e\x26\x65\x52\xe3\xf4\xd0\x3b\xe1\xae\xa6\x25\xfc\xe7\xc5\xcd\xb1\x31\x5a\x2c\x3e\x26\x95\x3d\xc0\x1b\x76\xe5\x30\x6d\x43\xf3\x8e\xdd\xbc\x17\x65\x0b\x52\xce\x37\x68\x8c\x55\x90\x63\x6b\xba\x83\x11\xd8\xfb\xec\x5a\x7c\xfb\x2b\x00\x00\xff\xff\x27\xe8\xc0\x2f\x4a\x07\x00\x00" +var _switchboardScriptsGet_vault_types_and_addressCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x91\x41\x6f\xa3\x30\x10\x85\xef\xfe\x15\x4f\x1c\x56\x70\x81\x7b\xb4\xbb\x51\xb4\xd2\xf6\x1a\xa5\x51\x7b\x8d\x31\x03\x58\x35\x36\x1a\x0f\x8d\xaa\x28\xff\xbd\x02\x92\x94\xa8\x8d\x8f\xe3\x79\x33\x6f\xbe\x67\xbb\x3e\xb0\x20\xf9\x3f\xf8\xc6\x96\x8e\xf6\xe1\x8d\x7c\xa2\x7e\x2c\x3f\x1f\xad\x98\xb6\x0c\x9a\xab\x44\xa9\xa2\x28\xb0\x6f\x6d\x44\x34\x6c\x7b\x01\x93\xae\x22\xa4\x25\x44\x09\x4c\x15\xde\xf5\xe0\x04\x46\xf7\xba\xb4\xce\x8a\xa5\x88\x9a\x43\x07\x8d\xf8\x35\x08\xc1\x4f\x9a\x5e\xc7\x48\x15\xb4\x31\x61\xf0\x32\x0e\x57\xda\x18\x8a\x31\xd5\xce\x65\xa8\x07\x8f\x4e\x5b\x9f\x5e\x1a\x56\xd8\x54\x15\x53\x8c\xd9\x0a\xa7\xfd\x47\x4f\xb7\xc2\x19\x27\xa5\x00\xa0\x28\xf0\x44\x02\x0d\xa6\x9a\x98\xbc\x21\x48\x98\xfd\x2d\xd6\x9b\xe0\xeb\xc0\x9d\xf5\xcd\xf8\xbb\xb8\x70\x3b\x94\xce\x9a\x69\x92\x23\x59\x6a\x76\x54\xe3\x0f\x1a\x92\xcd\xec\xe5\xea\x29\xcb\x97\xb7\xe6\x65\x60\x0e\xc7\xdf\xbf\x4e\x8f\x18\xe6\xdf\xb6\x9d\xff\xa6\xd3\xc2\xeb\x7b\xa8\x9c\xdb\xb7\x5a\xda\x5b\x7f\x86\xf5\x1a\xbd\xf6\xd6\xa4\xc9\xbf\x30\xb8\x0a\x3e\x08\x66\x13\xf7\x08\x16\xa7\x24\xd9\x8d\xd5\x8e\x64\xe0\x39\x0b\xa6\x38\x26\x17\x6a\x1c\x1a\x92\x97\x31\xc6\x11\x71\x7c\xb5\xd2\x5e\x28\xa7\xd9\x61\x12\xf2\xac\xba\xa7\x93\x3f\x56\x29\x75\x56\x9f\x01\x00\x00\xff\xff\xec\x44\x7e\xc2\x73\x02\x00\x00" -func switchboardSafe_transfer_tokens_v2CdcBytes() ([]byte, error) { +func switchboardScriptsGet_vault_types_and_addressCdcBytes() ([]byte, error) { return bindataRead( - _switchboardSafe_transfer_tokens_v2Cdc, - "switchboard/safe_transfer_tokens_v2.cdc", + _switchboardScriptsGet_vault_types_and_addressCdc, + "switchboard/scripts/get_vault_types_and_address.cdc", ) } -func switchboardSafe_transfer_tokens_v2Cdc() (*asset, error) { - bytes, err := switchboardSafe_transfer_tokens_v2CdcBytes() +func switchboardScriptsGet_vault_types_and_addressCdc() (*asset, error) { + bytes, err := switchboardScriptsGet_vault_types_and_addressCdcBytes() if err != nil { return nil, err } - info := bindataFileInfo{name: "switchboard/safe_transfer_tokens_v2.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd1, 0xa8, 0xe5, 0xd9, 0x92, 0x93, 0xd8, 0xb9, 0x8e, 0xfe, 0x39, 0x53, 0xee, 0x71, 0xfe, 0xeb, 0xb2, 0x79, 0x2c, 0xa0, 0xaf, 0xad, 0x55, 0x33, 0xff, 0x89, 0x59, 0x44, 0x9f, 0xcb, 0x9, 0x23}} + info := bindataFileInfo{name: "switchboard/scripts/get_vault_types_and_address.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xaf, 0x94, 0x76, 0x20, 0xbc, 0xb8, 0xf5, 0x3c, 0xf5, 0x75, 0x8d, 0x73, 0x44, 0x5, 0x28, 0x62, 0xe4, 0x3, 0xba, 0xf3, 0x2a, 0x1f, 0x15, 0x71, 0xde, 0x9a, 0xd8, 0xe3, 0x7d, 0x48, 0xd3, 0xdc}} return a, nil } -var _switchboardSetup_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x53\xdb\x6a\xe3\x30\x10\x7d\xf7\x57\x1c\xf2\xb0\x24\x90\x4d\xde\x4b\x5b\x28\x0b\xfb\x5c\xb6\xfd\x81\xb1\x3c\x8e\x44\x14\xc9\x48\xa3\x66\x43\xc8\xbf\x2f\xb2\x9b\x60\x37\x71\xf1\x42\x2b\x02\xd1\x6d\x8e\xce\x65\x6c\x76\x8d\x0f\x82\xdf\xc9\x6d\x4c\x69\xf9\xd5\x6f\xd9\xbd\xec\x8d\x28\x5d\x7a\x0a\x15\xea\xe0\x77\x98\x8d\x1d\xcf\x8a\x5b\xf5\xb7\x8a\x66\x45\xb1\x5e\xe3\x55\x9b\x08\x09\xe4\x22\x29\x31\xde\xc1\x44\x10\x84\x77\x8d\x25\x61\xd4\x3e\xe4\x65\xef\x5c\x34\x09\x94\x4f\xb6\x42\xc9\x48\x91\x2b\x94\x07\x64\x28\x72\x07\xef\x18\xe2\xf3\x8f\xaa\x0a\x84\x3e\xef\xc0\xd1\xa7\xa0\xba\x0b\x9a\x4d\x00\x29\xe5\x93\x13\x44\xdf\xa1\x8a\xe6\x03\x14\xb9\x0c\x16\x58\xb1\x79\x63\xec\x92\x15\xd3\x58\x46\xfd\xce\x1d\x92\xc9\x47\xa4\x68\xdc\x06\x84\xfc\x67\x19\xc7\x81\xb6\xd5\x9f\xae\x3c\x9c\x8a\x3e\xf7\x63\x51\x00\x40\x13\xb8\xa1\xc0\x73\x52\x4a\xee\xf0\x94\x44\x3f\x75\x4c\x16\xe7\x1b\x79\xac\xd7\xf8\xa5\x59\x6d\x61\xea\xcc\xec\xc2\x96\x6c\x60\xaa\x0e\xd0\x14\x47\x14\x5e\x20\x4c\x9d\xab\x64\x55\xfa\x10\xfc\xfe\xfe\xc7\x58\x68\xab\xde\xfc\xf1\x52\x0d\xcc\x73\x6c\x77\xa3\xad\xb0\x7a\x11\x1f\x68\xc3\xcf\x24\x7a\x81\x87\x07\x38\x63\x71\xec\xd5\x03\x83\x45\x56\x14\x38\xc7\x4a\x70\xbc\xbf\x9d\x0e\xb9\x0a\x4d\x12\x18\x81\x71\xe2\x11\xbb\x37\x06\x40\xad\xa8\x48\x6f\x3c\x1f\x6c\xe7\x71\xff\x73\x9c\xae\x6a\x1f\xef\xed\xcc\x17\x4b\x5c\x21\x88\x9f\xa8\xb8\x18\x15\xd7\xa4\xd2\x1a\x05\x45\x0d\x95\xc6\x1a\x39\xbc\xf7\xdc\x40\x31\xff\x6d\x7c\xdb\x43\xf9\xa0\xe2\xbc\x90\x8f\x88\x75\x72\xe7\xae\x0f\x3e\x6d\x74\x7b\x77\xac\xd5\xb2\x5f\x1c\x6a\x52\x37\xcc\xb2\xc6\x6d\xa7\xe5\x3f\x86\xfe\x78\xed\xf5\x28\xdc\xb9\xe8\xb9\xf5\x21\x9b\xb5\xbc\xb6\x99\xc2\x86\x65\x9a\xd5\x83\xe2\xc5\xb4\x06\xfb\xbf\x0c\x4a\x2f\xad\xb9\x1f\xe1\x8e\x53\x2c\xeb\x64\x9e\xda\xd6\xcd\x2f\x7c\x0e\x72\x2b\xb0\xf8\x75\x89\x7d\xca\x71\x89\x2f\x48\xf7\x9b\x53\xbd\x4c\x4e\xdd\x07\x76\x2a\x8a\x53\xf1\x2f\x00\x00\xff\xff\xb5\xea\xbe\xcb\x95\x06\x00\x00" +var _switchboardSetup_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x54\x5d\x6b\xe3\x38\x14\x7d\xf7\xaf\x38\xdb\x87\x92\x40\x36\x79\x2f\x6d\x61\x37\xb0\xb0\x6f\x65\xda\x99\xf7\x6b\xf9\x26\x16\x55\x24\x23\x5d\xb5\x35\x21\xff\x7d\x90\x1d\xbb\x76\x26\xce\x74\x3e\x60\x44\xa1\x91\x25\x1d\x9d\x73\xcf\xb9\xd2\xbb\xca\x79\xc1\xd5\x7f\xd1\x6e\x75\x6e\xf8\xc9\x3d\xb3\x7d\x7c\xd5\xa2\xca\xdc\x91\x2f\xae\xb2\xb3\x3b\xae\xb2\x6c\xb5\xc2\x53\xa9\x03\xc4\x93\x0d\xa4\x44\x3b\x0b\x1d\x40\x10\xde\x55\x86\x84\xb1\x71\x3e\x4d\x07\xeb\x52\x92\x40\xb9\x68\x0a\xe4\x8c\x18\xb8\x40\x5e\x23\x41\x91\xad\x9d\x65\x88\x4b\x7f\x54\x14\x20\x0c\x58\xc0\x73\x70\xd1\xab\x76\x43\xc9\xda\x83\x94\x72\xd1\x0a\x82\x6b\x51\xa5\xe4\x1a\x8a\x6c\x02\xf3\xac\x58\xbf\x30\x76\xd1\x88\xae\x0c\x63\x73\xe4\x0e\x49\xe4\x03\x62\xd0\x76\x0b\x42\xfa\x67\x18\xfb\x91\xb6\xe5\xa7\xf6\xb8\x3f\x64\x43\xee\xfb\x2c\x03\x80\xca\x73\x45\x9e\x67\x41\x6f\x2d\xfb\x1b\x50\x94\x72\xf6\xaf\xf3\xde\xbd\x7e\x21\x13\x79\x81\xff\x43\x88\xfc\x28\xce\xd3\x96\xd7\x54\x51\xae\x8d\x96\x7a\xed\xac\x78\x67\x0c\xfb\x05\x1e\x62\x6e\x74\x28\xdf\x17\x17\x78\xa4\x17\x3e\x9e\xff\x6c\xab\xd3\xf5\x39\xae\xff\x69\xf5\xce\x3b\x1e\x69\xac\x56\x58\x97\xac\x9e\xa1\x37\x49\x7f\x5f\x13\x32\x9e\xa9\xa8\x51\x52\x98\xa8\xe3\x02\x9e\x25\x7a\x0b\x26\x6f\xea\x74\x3e\xb8\x1e\x36\xcd\x1a\x75\xcb\xd0\xaa\x58\xe6\x8d\xbe\xdb\xeb\xa9\x94\x2c\x07\xbf\xef\x67\x1b\xef\x76\x37\x98\xde\xdb\x82\x3e\x90\x94\x73\xfc\x75\x07\xab\x0d\xf6\xfd\xe5\x69\xb4\xdc\xfa\x4f\x87\xd1\xe2\x48\xbd\xe7\x14\x34\x82\xe5\xd7\xf3\x79\x21\x5b\xa0\x8a\x02\x2d\xd0\x56\x1c\x8e\x8a\x7a\x90\x13\xa1\x81\x5e\x78\x36\xba\xee\xf6\xef\x69\x25\xaa\xb9\x7e\xf0\x65\x36\x5f\x8c\x0e\x8b\xfb\x58\x1d\xfa\x43\xf3\xb1\xb9\x86\xc9\x83\xdf\x74\x90\x94\xd7\x3e\x0f\x9a\x03\x52\x23\x91\x75\x56\x2b\x32\xa8\x48\xca\x70\xaa\x49\x0d\xb6\x2f\x63\x17\xaa\xd9\x24\x9f\x2e\xf6\x4d\x3a\x55\x63\xcf\xaf\x42\x0e\xa1\xce\xfa\xd6\x20\x28\xf4\xb8\xf5\xb1\xc1\x47\x66\xf2\x5b\xe5\x9a\x86\x4d\x0b\x05\xa7\x89\x0c\xd1\x36\xd1\x76\xcf\x8b\x77\x71\x5b\x36\xfb\xa6\x7a\x3a\xc5\x80\xfd\x86\xd4\x7b\x06\x0c\x4b\xf7\x64\xf8\x35\x55\xb8\x3b\x2b\xb7\x8b\x88\x4e\xed\x7d\x7b\x3d\x85\x7f\x3f\x8e\x4f\x1a\x3f\x94\x80\x36\x05\x97\xea\xde\x55\x7d\x40\x79\x01\x92\x0b\x49\xbb\xe4\xec\x6f\xb0\x25\x77\xd2\xd4\x7c\x08\xb5\xff\xc8\x53\xd1\xf2\x39\x34\x4d\x9a\xd0\xa7\x01\xce\xf9\x17\x46\x06\x86\x53\xd8\x9f\x74\xf2\x22\xd5\x05\xfe\xb8\xeb\xe7\x74\x7e\xc7\xfe\x6f\xba\xf0\x90\x65\x87\xec\x6b\x00\x00\x00\xff\xff\x0c\x98\xe2\x14\xfa\x07\x00\x00" func switchboardSetup_accountCdcBytes() ([]byte, error) { return bindataRead( @@ -742,11 +702,11 @@ func switchboardSetup_accountCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/setup_account.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x74, 0x85, 0x63, 0x21, 0x54, 0xb9, 0x53, 0x38, 0xac, 0x89, 0xdc, 0xfe, 0x4a, 0x2, 0xa9, 0xbc, 0xd5, 0xef, 0x31, 0x1b, 0x1a, 0xb7, 0x3d, 0xb0, 0x31, 0x7b, 0xf5, 0xb8, 0xe3, 0x43, 0xa7, 0x3b}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa6, 0xad, 0xd5, 0x2a, 0x2a, 0xca, 0x5c, 0xb4, 0x7e, 0xa8, 0xbf, 0x89, 0x5e, 0x54, 0xfc, 0x30, 0xbe, 0xa4, 0xb4, 0xb7, 0x82, 0xf2, 0xcd, 0x40, 0x3d, 0xaa, 0x5b, 0x47, 0xe1, 0xf0, 0xe2, 0x2f}} return a, nil } -var _switchboardSetup_royalty_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x58\x4d\x6f\xe3\x36\x10\xbd\xfb\x57\x4c\x73\x48\x65\xc0\xb5\xee\x41\x92\x45\x9a\x36\x8b\x5e\x8a\xc5\x26\xdb\x9e\xc7\xd4\xc8\x22\x22\x93\x02\x39\x8a\xd7\x08\xfc\xdf\x0b\x52\x96\x4c\x79\x2d\xdb\x92\x8d\x66\x75\x49\x2c\x91\x8f\xf3\xf1\xde\x13\x45\xb9\x28\xb4\x61\x78\x2a\xd5\x5c\xce\x72\x7a\xd1\xaf\xa4\x20\x35\x7a\x01\x57\xad\x7b\x57\xa3\x7d\x23\x9f\x97\x92\x45\x36\xd3\x68\x92\x7d\x93\x82\xc7\xdb\xf9\xb9\x5e\xb6\x56\xa9\x7f\x6f\x47\x48\xe4\xd6\x88\xfa\xf7\xd5\x68\x34\x8a\x63\x78\xc9\xa4\x05\x36\xa8\x2c\x0a\x96\x5a\x81\xb4\x80\xc0\xb4\x28\x72\x64\x82\x54\x1b\xf7\x33\x78\xce\x19\x32\x08\x5d\xe6\x09\xcc\x08\x4a\x4b\x09\xcc\x56\xe0\xa0\x50\xad\xb4\x22\x48\xcb\x3c\x5f\x81\x25\x2e\x0b\x40\x05\x28\x84\x2e\x15\x7b\x24\x43\x82\xe4\x9b\x54\x73\x98\x69\xce\x7c\xf4\x80\x2a\x81\x6f\xcf\x7f\x3c\x02\xbb\xa8\x2c\x20\x03\x67\x04\x16\x17\xe4\x40\x8b\x72\x96\x4b\x01\x05\x72\x06\x91\xc3\x90\xca\x32\x2a\x41\x7e\x94\xd1\x2b\xcc\x59\x92\x85\xb8\x1a\x18\x7f\x26\x45\x46\x8a\xa7\x97\xaf\x7e\x2d\x32\x7e\xea\xd8\x41\x7d\xb3\x6e\x65\x37\x0d\x93\xe4\x6f\x5a\xfe\x83\x65\xce\xff\x1a\x2c\x0a\x32\xf6\xf7\xd5\x17\xb7\x84\x0d\x7a\xb0\x20\xce\x74\x02\x98\xe7\x7a\x69\xeb\xec\x58\xbb\x9c\x1d\x9c\xc0\x02\x67\x32\x97\xbc\x82\xe5\x06\x04\x6c\x29\x32\x40\x0b\xbe\xc2\x4f\xda\x2c\xd1\x24\xee\xbe\x0b\x9a\x30\x01\x9d\x56\xeb\x0b\x2e\x31\xaf\x32\x86\x37\x17\xc6\x74\x14\xd6\x38\x1a\xc3\xfb\x68\x04\x00\x90\x13\x43\x5a\x37\xd5\x07\xfc\xd8\x2c\x7b\x03\xdb\xff\x6f\xaf\xdf\x5b\x64\x99\xd6\xe9\xaf\xef\xb7\x38\x75\xeb\x87\xe1\x00\x40\x03\x15\x94\xe9\x2b\xa5\x37\x00\xd7\x5d\x54\x9d\x06\xff\x57\x29\x15\x86\x0a\x34\x14\xa1\x10\x7c\x03\x0f\x25\x67\x0f\x15\x45\x9a\xa4\xdd\x15\xc7\xf0\x98\x91\x78\x05\x59\x97\xac\xa2\x11\xe6\x86\x30\x59\x41\x86\x8e\xa7\x9e\x41\x3e\x9d\x66\xa2\x4c\xdd\x58\x9e\xce\xb4\x31\x7a\x79\x7b\xdd\x48\x62\xea\xc7\xdd\x47\x4e\x07\x37\x10\x5b\xd6\x06\xe7\x14\xb7\xab\x3b\x86\xbb\x3b\x50\x32\x87\xf7\x06\x70\x13\xcd\x5f\x29\x28\xcd\x13\x10\x86\x9c\x30\x10\x14\x2d\x83\xf5\xc1\x90\xd5\xa5\x11\xe4\x09\x5d\x94\x0c\x92\x41\x2a\xd6\xb0\x59\xa8\x85\xe7\x23\xb4\xf8\x46\xd1\xed\x6f\x5b\x11\x4f\x2b\xec\x3f\x17\x05\xaf\x3c\x68\x34\x9e\x00\xeb\xee\x60\x1b\xcc\x75\x67\xdd\x4c\x2d\x83\x80\xae\xd2\x42\x2e\xd5\x2b\x25\xe0\xf5\x4c\x9e\x61\xdb\x91\x4e\x30\x61\x39\x7f\xf1\xd1\xce\x89\x4f\xa2\x49\x54\x2b\xb1\x89\xb5\x7e\x36\x6e\x95\xe0\xcc\x6b\x2a\x5c\x96\x5e\x28\x3b\x8d\x92\x29\x48\xfe\xd5\xee\x74\x6b\xe3\x23\x41\x15\x58\x6f\x73\xf7\x1a\x04\xfa\x5e\x68\xef\x11\xbb\x90\x6e\x5c\x42\xee\x21\x43\x5a\xaa\xda\x08\x8d\x2e\xe7\x99\x7f\xd8\x55\x0d\xc7\x00\x32\x29\x8a\x3d\xed\x2f\x95\x6b\xc2\xa9\xe5\xf2\x53\xdc\x84\x41\xa5\x9f\xc0\xb0\xda\x33\x9a\x39\x71\x2f\x02\x5a\xca\xd3\x69\x97\x65\xc1\x1d\x5c\x8c\x4c\x3d\xad\xc2\xbf\x63\x8e\x58\x45\x6d\x90\x6d\xab\xd8\xb9\xfd\x5c\x95\xc2\xbd\x2e\x7a\xba\xc5\x36\x84\x73\xdc\xa2\x89\x66\x9f\x5b\x0c\x94\x98\x33\x99\x03\x69\x5e\xca\x67\x7c\x01\x2e\xe4\x33\x7d\x32\x8d\x76\x72\xab\x51\xbe\x94\x33\x9f\xdf\xc5\xcc\xc4\x27\xf8\x81\x66\x72\x24\xcf\xfe\x8e\x72\x18\x70\x10\xdf\x6a\x4f\xe9\xc7\xb7\xca\x56\x3a\x76\x30\xbd\x6d\xe5\xd4\x3a\xf5\xf4\x98\x70\x07\x5f\x2b\xbc\xdb\x6d\x4e\xd8\x31\x1d\x67\x79\xed\x51\x9d\x60\x83\xdd\x6a\x5f\x32\x03\xec\xaa\x2b\xb0\x6a\xad\xe0\x4e\x6f\xfb\xf2\xa6\x75\x4a\xde\x97\xb2\xaf\x3e\xce\xd5\x91\xc9\x69\x6d\x1f\x6a\x7a\x51\x27\x78\xc0\xf0\x5c\x8a\xcb\x9a\x5e\x48\x94\x8f\x71\xbd\x1e\x59\x77\x59\xe0\x59\x6d\x89\x4e\xe7\x6d\x8f\x58\x27\x27\xa3\x36\x96\x7a\x21\x35\x04\x53\xab\x70\xbc\xee\x53\xde\x23\x13\xf7\xed\x8d\x86\xb6\x4a\x19\xed\x34\x3d\xfc\xa2\x0e\x3e\xe6\x8f\xbd\xf8\x9b\xe7\x03\x3a\xd3\x31\xa8\x4a\x65\x02\x1d\x5d\x3c\xb5\xda\xf7\xc3\xf9\x76\xe6\xf5\xff\x2a\xd6\x1f\xd1\xfc\xa8\xcc\x83\xc5\x5d\x7b\xa2\xb8\x49\xbb\x68\xc7\xe5\x6d\xfb\xeb\xfb\xb8\xae\x5b\xb7\x7f\x3a\x2a\xd5\xd7\x01\x4a\x7d\x90\x1d\x7c\x26\x06\x04\x43\x29\x19\xf2\x87\x6d\x7a\x57\xcc\xed\x9d\x59\xfb\x40\xa8\xde\x8f\x5d\x76\xab\xd3\x5c\xbd\xf6\x3c\x47\x61\x3f\x7d\x82\x02\x95\x14\xd1\xd5\xa3\x3f\xd5\x54\x9a\xa1\x0a\xbc\x9d\x7f\x90\xe2\xd5\xe6\xeb\x73\x5d\xfd\xa1\xef\x24\x4a\xa6\x40\x96\x71\x0c\x0f\x49\x25\x84\x1f\xd5\x17\x3a\x62\xe9\xa5\x17\x9c\x47\x6e\x4e\x1d\x0f\x55\x77\x1a\x0c\x8f\x44\x70\x8c\x77\xf0\xd3\x7b\x7c\x06\x64\xc7\xb6\x7b\x5c\x17\x61\x3d\x82\xff\x02\x00\x00\xff\xff\xf8\xa1\x09\x9d\xfb\x16\x00\x00" +var _switchboardSetup_royalty_accountCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x58\x4d\x73\xdb\x36\x10\xbd\xeb\x57\xbc\xf8\x90\x52\x33\xaa\x74\xf7\xd8\x49\x63\xb5\xce\xe4\xd2\x7a\x62\x3b\x3d\xaf\xc8\xa5\x89\x31\x04\x70\x00\x50\xaa\xc6\xe3\xff\xde\x01\x28\x92\xd0\x07\x65\xc9\x51\xa7\x3c\x24\x32\x09\x3c\xec\xdb\x7d\xfb\x40\x50\xcc\x4b\x6d\x1c\x2e\x6e\x2b\xf5\x24\x66\x92\x1f\xf4\x33\xab\x8b\xc1\xde\xdb\xf7\x4b\xe1\xd2\x62\xa6\xc9\x64\xd1\x08\xa9\x97\xdb\x93\x04\xb9\xf5\xad\xc1\x60\x32\x99\xe0\xa1\x10\x16\xce\x90\xb2\x94\x3a\xa1\x15\x84\x05\xc1\xf1\xbc\x94\xe4\x18\xb9\x36\xfe\xcf\xe8\xb9\x2b\xc8\x21\xd5\x95\xcc\x30\x63\x54\x96\x33\xcc\x56\x08\x58\xa4\x56\x5a\x31\xf2\x4a\xca\x15\x2c\xbb\xaa\x04\x29\x50\x9a\xea\x4a\xb9\x00\x65\x38\x65\xb1\x10\xea\x09\x33\xed\x0a\xf8\x00\x41\x2a\xc3\xe3\xfd\xef\x53\x38\x1f\x97\x05\x39\xb8\x82\x61\x69\xce\x01\xb5\xac\x66\x52\xa4\x28\xc9\x15\x48\x3c\x88\x50\xd6\x91\x4a\x39\x0c\x33\x7a\x45\xd2\x09\xb6\x98\xd4\x03\x27\x5f\x59\xb1\x11\xe9\xed\xc3\xf7\xb0\x18\x9b\x30\x75\x18\xb0\x1e\xad\x5f\xdb\xcf\xa3\x2c\xfb\x93\x97\x3f\xa8\x92\xee\x6f\x43\x65\xc9\xc6\xde\xac\xee\xfc\x1a\xb6\x4b\x25\xe6\xec\x0a\x9d\x81\xa4\xd4\x4b\xdb\xf0\x73\xda\xd3\x0e\x78\x29\x95\x34\x13\x52\xb8\x15\x96\x6b\x14\xd8\x2a\x2d\x40\x16\x21\xcd\xb7\xda\x2c\xc9\x64\xfe\xbe\x0f\x9b\x29\x83\xce\xeb\x00\x52\x57\x91\xac\x49\x63\xe1\xe3\x18\x0f\xe2\x3c\x27\x43\xbc\x0c\x06\x00\x20\xd9\x21\x6f\x4a\x19\x22\x9e\xb6\xcb\x5e\xa2\xfb\x7d\xf5\xf1\x65\x43\x13\xe3\x26\x01\xaf\x9f\x3a\x9c\xa6\xfe\xef\xc3\x01\xd0\x42\x45\x79\xfa\xce\xf9\x25\x40\x95\x2b\x92\x3e\x55\x8e\xff\x5a\x2a\x36\x43\x7c\xec\x1d\x10\xfd\xae\x79\x97\x86\x4b\x32\x9c\x58\xf1\xa4\xd8\x5c\xd6\xf8\x37\xda\x18\xbd\xfc\x41\xb2\xe2\x11\xbe\x59\x5b\xf1\xbd\xd3\x86\x9e\xb8\x8b\x7f\xaa\x95\x33\x5a\x4a\x36\x23\xdc\x79\x4d\xd8\xa2\x7b\x38\xc2\x3d\x2d\x78\x3d\xff\x51\x95\xdb\xcf\x87\xf8\x52\xeb\xb5\x4d\xbf\xbf\x2c\xcb\x7c\xdc\x57\x03\x5c\xa3\x0e\x71\xdc\xca\x41\xb0\x1d\x3f\xb1\x3b\x90\xc9\xa4\x91\x6b\x8b\xda\x3c\x1b\xb6\xab\xfa\xeb\xf3\x67\x94\xa4\x44\x9a\x5c\xdc\x87\x35\x90\x69\xb6\x50\xda\xa1\xa0\x05\x83\xd0\x36\xf9\xba\xb9\xd8\x44\xaa\xbc\x18\x76\x1c\x26\x13\x4c\x0b\x4e\x9f\x21\x1a\x01\xd6\x7d\x49\xd2\x30\x65\x2b\x14\xe4\x3b\x3f\x74\x62\x20\xd8\x4e\x14\x79\xc3\xcf\xd6\xa9\x1e\xcf\x42\x11\xae\x3e\xb6\x6e\x32\x0e\x33\x3e\x25\xb9\xd1\xf3\x4b\x6c\xdd\x5e\x17\xc8\x37\xd7\x10\xd7\xd7\x50\x42\xe2\x65\x83\xe4\x64\x82\x6f\xb9\x27\x35\x42\x6a\xd8\xfb\x0e\x41\xf1\x32\x0a\x06\x86\xad\xae\x4c\xca\xc1\x2e\xca\xca\x41\x38\x08\xe5\x34\xd6\x31\x6d\xe0\x6d\x85\x6b\x69\xc1\xc9\xd5\xaf\x5d\x58\xf5\x22\x7f\xcc\x4b\xb7\x0a\xe8\x49\xe8\xbf\x87\x55\xc9\x97\xf0\xff\x5e\xfd\xb6\xc3\x6c\x38\x1c\x61\x63\x8d\xe3\x2f\xa7\x0f\xa6\xa4\x45\x7d\xed\x2d\xd5\x9e\xca\x7a\x9f\x96\x42\x3d\x73\x86\x60\xca\x5c\x27\xcb\xc4\x9e\x17\x57\xf0\xc3\xe9\x12\x3d\x85\x6e\xb2\x45\xb0\x41\xb9\xab\x66\x81\xe4\x87\x71\xea\x09\x05\x53\xdb\xaa\xbc\xc8\x21\xdc\x2f\x76\xab\xfc\x6b\xd7\x8f\x08\x3b\xdd\xd1\x5c\x6c\x08\x14\x6b\x47\x0a\x5e\x3a\xa5\xb2\xa7\x21\x1b\x39\x08\xef\x1a\x7b\xc4\x7b\x4c\x8d\xd0\xa9\x6b\x03\x7b\xed\x23\x49\x13\xc2\x08\xe4\x76\xaa\xbe\x9d\x94\x1d\x02\x4d\xf5\xfe\x5f\x0e\x51\x14\x7b\x69\xdc\x90\xf4\xdb\xef\x0e\x8b\xd7\x2d\xbb\xec\xd9\x6a\xde\x67\x97\xc7\xa6\xf2\x44\xbb\x8b\x36\x9d\xd6\x62\x8e\x31\xbe\x23\x36\xb1\xb7\xfb\xa7\xb1\xcb\x5e\xb0\x77\x1b\xe7\x3e\x5a\x3f\xe1\x9c\xfd\x21\xd6\xab\x46\x77\x92\x53\x7d\x32\xb8\xe3\x31\x19\x38\x97\x4f\x9e\x6c\x91\x3d\x74\xce\xa3\x82\xfe\x17\xa6\x48\xe2\x52\xa4\x67\x76\xd1\x58\x20\x67\xb0\xa1\x63\x12\xd1\xcf\xf4\x4c\x2e\x75\x42\x22\x8f\xd0\x52\x84\x50\x4f\x0c\xfd\x93\xbb\x3d\x22\xf3\xa7\x0f\x32\xdc\xe9\x2c\x06\x0d\x67\x99\x28\xdb\xd1\x71\xe6\xa8\xfd\xb9\x1d\x74\xdc\x9b\xf3\x61\xb5\xb5\xd7\x81\x6a\xec\xd3\xdd\x3b\xdf\x7c\xf6\x5e\xff\x85\x86\x77\x24\xbc\x71\x38\x39\x4d\xcd\x1b\x58\x67\x4d\x7a\x73\x9d\xbb\x15\xf6\x93\x7d\xa3\x2b\xde\xec\x86\xaf\xec\x40\x30\x9c\xb3\xe1\x70\xda\xd6\xdb\x5a\xde\xdc\xef\x37\xcf\x83\x5d\xaa\xb7\xf6\xce\xf3\x9d\x12\x4f\x78\x41\x3d\x69\xa7\x7d\x13\xb6\x3b\x93\x4d\xc3\x77\x10\x7f\x1a\xab\xd9\x6d\xa6\x2b\xca\x48\x73\x10\x7b\xad\xff\xe3\x7f\x38\xad\x1c\x47\x2d\x30\x99\xe0\x4b\x96\x85\x0c\xef\x2a\x3d\xf6\x8f\x2a\x7c\xc2\x88\x3e\x5f\xac\x3f\x52\x1c\x2a\xc6\x38\x1a\x9e\xa4\xd1\xa1\xff\xe0\xb9\x76\xf8\x13\x90\x3d\xef\x7e\xc3\x26\x09\xaf\x03\xfc\x1b\x00\x00\xff\xff\x4f\x5a\xee\x48\xdf\x12\x00\x00" func switchboardSetup_royalty_accountCdcBytes() ([]byte, error) { return bindataRead( @@ -762,11 +722,11 @@ func switchboardSetup_royalty_accountCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/setup_royalty_account.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc6, 0x9c, 0xdc, 0x26, 0x5f, 0x47, 0x8a, 0xa, 0xed, 0xa8, 0x60, 0x29, 0x8a, 0xe6, 0x99, 0xae, 0xee, 0xe0, 0xc9, 0x30, 0x6e, 0xaa, 0x42, 0xfd, 0xa9, 0x26, 0x47, 0x26, 0x60, 0x66, 0x97, 0x1d}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe, 0xde, 0xae, 0x6, 0x58, 0x1c, 0x2d, 0x2, 0xcb, 0x1d, 0xf5, 0xe3, 0xb0, 0x5c, 0xea, 0x58, 0x8e, 0x23, 0x51, 0x97, 0x78, 0xc8, 0xcf, 0x16, 0xe1, 0xc8, 0xfb, 0x77, 0x17, 0x5c, 0xa8, 0x6}} return a, nil } -var _switchboardSetup_royalty_account_by_pathsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x58\x4d\x6f\xe3\x36\x13\xbe\xfb\x57\xcc\x9b\xc3\xbe\x32\xe0\xda\xf7\x20\xc9\x36\x4d\x9b\x45\x2f\x45\xb0\xc9\xb6\x87\x45\x0e\x63\x6a\x64\x11\x91\x49\x81\x1c\xc5\x6b\x04\xf9\xef\x05\x49\xeb\xcb\xb6\x62\xc9\x71\x9b\xea\x62\x4b\x9c\x19\xce\xd7\xf3\x88\x1a\xb9\xcc\xb5\x61\xb8\x2d\xd4\x42\xce\x33\x7a\xd0\x4f\xa4\x20\x31\x7a\x09\x67\xad\x67\x67\xa3\x7d\x92\xf7\x2b\xc9\x22\x9d\x6b\x34\xf1\x3e\xa5\xc6\x72\xad\x9f\xe9\x55\x6b\x97\xf2\xbe\x96\x90\xc8\x2d\x89\xf2\xfe\x6c\x34\x1a\xcd\x66\xf0\x90\x4a\x0b\x6c\x50\x59\x14\x2c\xb5\x02\x69\x01\x81\x69\x99\x67\xc8\x04\x89\x36\xee\xb6\xb1\xce\x29\x32\x08\x5d\x64\x31\xcc\x09\x0a\x4b\x31\xcc\xd7\xe0\x4c\xa1\x5a\x6b\x45\x90\x14\x59\xb6\x06\x4b\x5c\xe4\x80\x0a\x50\x08\x5d\x28\xf6\x96\x0c\x09\x92\xcf\x52\x2d\x60\xae\x39\xf5\xde\x03\xaa\x18\xbe\xdd\xff\x7a\x03\xec\xbc\xb2\x80\x0c\x9c\x12\x58\x5c\x92\x33\x9a\x17\xf3\x4c\x0a\xc8\x91\x53\x88\x9c\x0d\xa9\x2c\xa3\x12\xe4\xa5\x8c\x5e\x63\xc6\x92\x2c\xcc\x82\xe0\xec\x0b\x29\x32\x52\xdc\x3e\x7c\xf5\x7b\x91\xf1\xaa\x63\x67\xea\x9b\x75\x3b\x3b\x35\x8c\xe3\x3f\x68\xf5\x27\x16\x19\xff\x65\x30\xcf\xc9\xd8\x5f\xd6\x77\x6e\x0b\xdb\xa8\xc1\x92\x38\xd5\x31\x60\x96\xe9\x95\x2d\xa3\x63\xed\x62\x76\xe6\x04\xe6\x38\x97\x99\xe4\x35\xac\x36\x46\xc0\x16\x22\x05\xb4\xe0\x33\x7c\xab\xcd\x0a\x4d\xec\x9e\x3b\xa7\x09\x63\xd0\x49\xd8\x5f\x70\x81\x59\x88\x18\x9e\x9d\x1b\xd3\x51\x33\xc7\x11\xc6\xb1\x21\x6b\xcf\xe1\x3a\xfc\x19\xc3\xcb\x68\x04\x00\x90\x11\x07\x05\xe7\xad\x3d\x87\xef\x77\x3e\x6c\x77\xf7\xd8\x16\x78\x58\xe7\xe4\x04\xdc\xef\xa3\x5b\xa9\x96\x1b\x31\x7e\xa5\xe4\x1c\xe0\x53\x57\x9f\x4d\x1b\xff\xc3\xfe\xb9\xa1\x1c\x0d\x45\x28\x04\x9f\xc3\x75\xc1\xe9\x75\xa8\x6f\xe5\xa1\xbb\x66\x33\xb8\x0b\x82\x3e\x5c\x57\x01\xeb\x0b\xcd\xce\x29\x40\x63\x70\x6d\x61\x25\x39\xf5\xeb\x7b\xfb\x20\x46\xc6\xca\xa0\xa5\x2c\x99\xd6\x71\xc3\x25\x7c\x7f\xec\x5a\x9c\xba\x5a\xa8\x38\x2a\x3b\x22\x29\x31\x51\x76\xc4\xf8\x90\x66\x85\x91\xa9\x6f\x91\x52\xef\xae\x98\xdf\xf9\x5e\xda\x55\xf7\xc9\xee\xf2\xca\x2f\x96\xb6\xdd\xcd\xc5\xcf\x15\x4e\xc3\x0e\x57\xd1\xb8\xd3\xea\x96\x62\xdb\x35\xaf\xd8\x4c\xfb\x4d\x4a\xe2\x09\x64\xd9\x66\x01\x7a\x98\x19\xc2\x78\x0d\x29\x3a\x6c\xfb\x6c\x7b\xed\x4a\x51\x26\x4e\x96\xa7\x73\x6d\x8c\x5e\x5d\x7c\xda\x71\xcf\x71\xc7\x39\xcc\x2c\x6b\x83\x0b\xaa\x53\xea\x97\xc7\x70\x79\x09\x4a\x66\xf0\x52\x19\xdc\x78\xf3\x7b\x02\x4a\xf3\x04\x84\x21\x47\x26\x08\x8a\x56\x8d\xfd\xc1\x90\xd5\x85\x11\xe4\x8b\x9f\x17\x0c\x92\x41\x2a\xd6\xb0\xd9\xa8\x65\xcf\x7b\x68\xf1\x99\xa2\x8b\x9f\x6a\xe2\x9b\x06\xdb\xbf\x2d\x73\x5e\x7b\xa3\xd1\x78\x02\xac\xbb\x9d\xad\x6c\xbe\x76\xe6\xcd\x94\xd4\xd1\x80\xb8\xb4\x90\x49\xf5\x44\x31\x78\x0e\x24\x70\x66\x6b\x49\xd7\xe2\xcd\x74\xfe\xcf\x7b\xbb\x20\xbe\xa9\x4c\x5c\x7c\x7a\x69\xe1\x6c\x5a\xf6\xd5\xeb\x55\x9f\x5e\x3d\xc1\x35\x15\x2e\xca\x68\xbc\x5b\x28\x99\x80\xe4\xff\xdb\xad\x6a\x6d\xb8\xb7\x91\x05\xd6\x75\xec\xbe\x45\x81\x7e\xe4\xda\xf3\xea\xb6\x49\x27\x17\x93\x5b\x64\x48\x0a\x55\xbe\x3c\x8c\x2e\x16\x01\xf5\x5d\xd9\x70\x1d\x40\x26\x41\xb1\xa7\xfc\x85\x72\x45\xe8\x9b\x2e\xaf\xe2\x14\x8e\x4a\xfd\x04\x8e\xcb\x3d\xa3\x59\x10\xf7\x6a\xc0\x81\xc8\xf5\xf4\x78\x00\xb9\xdb\xfc\x10\x90\xbb\xf5\xf8\x3e\x78\xe6\xd9\x6c\x18\x78\x6b\x17\xde\x03\xde\xca\x9b\x7d\xe0\x3d\xb2\xe3\x1d\xe6\xdf\x08\xf3\x54\xb0\xf7\x09\x38\x11\xec\x87\x44\x7a\xe8\xa5\x74\x32\x6c\xfb\x00\x3f\x10\xdb\x7d\x5f\xbe\xd0\x17\xe0\x6f\x1b\x3c\xaa\xdf\x4a\x88\xf7\xeb\xb7\x81\x28\x6f\x7e\x06\x94\x18\xeb\xc6\x7b\x8f\x93\xdb\xe1\x3e\x2b\x59\xa2\xd3\xd8\xd1\x7c\xb1\x2f\x98\x23\x08\xa3\xcb\xb1\xb0\x57\xe3\xc9\x60\x02\xf1\xb4\xd1\x27\xee\x53\x11\xc8\x10\xee\xe8\x88\xa4\x5f\xd9\x8f\xa5\x9d\xa8\xd3\x78\x03\x3a\x9b\x6f\x8e\xd3\xd1\x4e\xb3\x51\x3e\x86\x77\x06\x44\xdd\x45\x42\xef\x2a\x4b\xd4\xbf\x6f\x07\xf8\x3a\xe9\x6d\xb5\x22\xb5\x13\xa1\xa1\xa1\x1a\xdc\xf1\xb8\x4f\x78\x0f\x4c\xa4\xff\x28\xa4\x1a\x29\xa3\xad\xa2\x37\x3f\xcb\x1b\x13\x81\x43\xaf\xde\x6a\xfd\x88\xca\x74\x08\x85\x50\x26\xd0\x51\xc5\xbe\xd9\xbe\x3a\xbe\xdf\xde\x79\xfd\xbb\x88\xf5\x73\x9e\x5d\x64\xbe\x99\xdc\xd7\x30\x2a\x48\x69\xc7\xda\x61\x78\xdb\xe1\xf8\x3e\x8c\xeb\xd6\xe3\xff\x5c\x2b\x95\xd7\x1b\x2d\xf5\x41\x74\xf0\x85\x18\x10\x0c\x25\x64\xc8\x4f\xec\xf4\x36\x98\xdb\x43\x8f\xf6\x60\x0a\x2e\xff\x89\xa3\x4e\x75\x0d\x3a\xf3\x1c\x34\xfb\xf9\x33\xe4\xa8\xa4\x88\xce\x6e\xfc\x68\x54\x69\x86\xe0\x78\x3b\xfe\x46\x88\x67\x9b\xc9\xcd\xe6\x80\x48\x3f\x48\x14\x4c\xf5\x18\x6d\x36\x83\xeb\x38\xe0\xa0\x45\x94\xbb\x59\x84\xc2\x63\xaf\x73\xaa\x39\xea\xcc\xf1\xb4\x53\x27\xca\xc3\x80\x71\x6b\x44\x36\xf4\x74\x15\x86\x90\x5b\x23\xad\x09\x54\xf3\xcd\xcd\x9f\x3a\x15\xaf\x23\xf8\x3b\x00\x00\xff\xff\xb2\x42\x4b\xe4\x46\x17\x00\x00" +var _switchboardSetup_royalty_account_by_pathsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xc4\x58\x4f\x6f\xe3\xb6\x13\xbd\xfb\x53\xcc\xe6\x90\x9f\x0c\xf8\x27\xdf\x8d\x64\xb7\x89\xdb\x2c\xf6\xd2\x06\x9b\x64\x7b\x58\xe4\x30\x96\x46\x11\x11\x9a\x14\xc8\x51\x5c\x23\xc8\x77\x2f\x48\xfd\x31\x65\x4b\xb1\x9d\xba\xa8\x2e\xb6\x44\xce\x70\xe6\xf1\xf1\x0d\x49\xb1\x2c\xb4\x61\x38\xbb\x29\xd5\x93\x58\x48\xba\xd7\xcf\xa4\xce\x46\xbd\x9f\xef\x56\x82\x93\x7c\xa1\xd1\xa4\x41\x0f\xa9\x57\xdb\x46\x02\xb9\xfe\x34\x1a\x4d\xa7\x53\xb8\xcf\x85\x05\x36\xa8\x2c\x26\x2c\xb4\x02\x61\x01\x81\x69\x59\x48\x64\x82\x4c\x1b\xf7\x1a\xb4\x73\x8e\x0c\x89\x2e\x65\x0a\x0b\x82\xd2\x52\x0a\x8b\x35\x78\x5f\xa8\xd6\x5a\x11\x64\xa5\x94\x6b\xb0\xc4\x65\x01\xa8\x00\x93\x44\x97\x8a\xbd\x2b\x43\x09\x89\x17\xa1\x9e\x60\xa1\x39\x07\x17\x20\xa0\x4a\xe1\xe1\xee\xd7\x39\xb0\x8b\xcb\x02\x32\x70\x4e\x60\x71\x49\xde\x6b\x51\x2e\xa4\x48\xa0\x40\xce\x21\x72\x4e\x84\xb2\x8c\x2a\x21\xdf\xcd\xe8\x35\x4a\x16\x64\x61\x5a\x75\x9c\x7e\x25\x45\x46\x24\x37\xf7\xdf\xfd\x60\x64\xbc\xe9\xd8\xfb\x7a\xb0\x6e\x6c\x67\x87\x69\xfa\x3b\xad\x7e\x60\x29\xf9\x4f\x83\x45\x41\xc6\x5e\xaf\x6f\xdd\x18\x76\x03\x25\x2c\x89\x73\x9d\x02\x4a\xa9\x57\xb6\xc9\x8f\xb5\x4b\xdb\xfb\x4b\xb0\xc0\x85\x90\x82\xd7\xb0\xaa\xbd\x80\x2d\x93\x1c\xd0\x82\x87\xf9\x46\x9b\x15\x9a\xd4\x7d\x77\x61\x13\xa6\xa0\xb3\x2a\x80\x84\x4b\x94\x55\xd2\xf0\xe2\xe2\x88\x47\xa3\x10\xe8\x08\xd3\xd4\x90\xb5\x33\xb8\xaa\xfe\x8c\xe1\x75\x34\x02\x00\x90\xc4\x95\x85\x8b\xd7\xce\xe0\xe7\xad\xcf\xdc\xbd\x3d\x76\x3b\xdc\xaf\x0b\x72\x1d\xdc\xef\xa3\x6b\x69\x9b\x83\x2c\xbf\x53\x36\x03\xc0\x92\xf3\x68\x88\x53\xf1\x1f\x2b\x45\x66\x0c\xe7\x83\x1d\x82\xff\x55\x90\x85\xa1\x02\x0d\x45\x56\x3c\x29\x32\xb3\xca\xff\xb5\x36\x46\xaf\x7e\xa0\x2c\x69\x02\xdf\xac\x2d\xe9\x8e\xb5\xc1\x27\x9a\xb7\x40\xce\xb5\x62\xa3\xa5\x24\x33\x01\x9f\x97\xcd\x37\x8d\x13\xb8\xc3\x17\xaa\xed\x1f\x54\xb1\xdd\x3e\x86\xab\x8a\x6d\x2d\x56\xee\x99\x4e\xe1\xb6\x8a\xc6\x23\xef\xe8\x60\x3d\xed\xd8\xc1\x03\x68\x0c\xae\x2d\xac\x04\xe7\xbe\xbd\x97\x95\x29\x32\xb6\x0e\x2d\xc9\x2c\xde\xcc\x00\x5c\xc2\xcf\xc7\xa1\xc6\xd8\xd1\x42\xa5\x51\x43\xcf\xac\x59\x94\x0d\x3d\xc7\xfb\x2c\xdb\x35\x1b\x7b\xba\x36\x76\xb7\xe5\xe2\xd6\x13\x7b\xd7\xdc\x4f\xfb\x50\x54\xbe\xb1\xf1\xed\x5e\x2e\x7e\x69\x85\xa2\x1a\xe1\x73\x34\x1e\xf4\xba\x65\xd8\x0d\xcd\x1b\x86\xb0\xcf\x73\x4a\x9e\x41\x34\x8c\xaf\x84\x00\xa5\x21\x4c\xd7\x90\xa3\x93\x1a\x0f\xb2\xb7\x6e\x0d\x45\x06\x15\x6b\x62\x5b\xb1\x23\x5e\x78\xde\x5c\x9c\xef\x8c\x97\x19\xbd\x9c\xc1\xd6\xe7\x9a\x53\x1e\x1d\xb8\xbc\x04\x25\x24\xbc\xb6\xde\xeb\xd0\xbe\x65\xa0\x34\x4f\x20\x31\xe4\x84\x0e\x41\xd1\x2a\x08\x06\x0c\x59\x5d\x9a\x84\x3c\x13\x8a\x92\x41\x30\x08\xc5\x1a\xea\x98\x3a\xfe\xb6\xc2\xb5\xf8\x42\xd1\xc5\xff\x37\x61\x55\x83\xfc\xb6\x2c\x78\xed\xbd\x47\x2d\xa0\x33\x18\x44\x72\x02\x9d\x31\x0e\x7f\x58\xbf\x0b\x49\xeb\xf5\x6d\x78\xae\x4c\xa3\x9d\x81\xc2\x09\x0b\x52\xa8\x67\x4a\xc1\x97\x01\xaa\xd0\x32\xa1\xca\x86\x53\xf8\xa9\x06\xa5\xf5\x20\xc8\xc6\x4f\xc4\x17\xe7\xaf\x1d\x15\x89\x1b\x42\xbf\x7d\x3e\x26\xdf\x7d\xcb\xe2\x53\x9c\xb8\x84\xa2\xf1\xee\xd4\x8b\x0c\x04\xff\xcf\x6e\xcd\x7f\x5d\x67\x82\x84\x59\x6f\xd2\x7c\xe9\x30\x14\x6a\x15\xf5\xe2\x30\xc7\x02\x2e\xa1\x2f\xdb\x86\x0f\xc2\x29\x5d\x0f\x7b\x0f\x99\x24\xd8\xd0\xab\xe3\xbb\xd6\xbe\xa8\x09\x61\x02\xc8\x3b\xd3\x3e\xa8\x15\x4d\x02\xcd\xec\xfd\xb7\x39\x04\x51\xf4\xa6\x71\x8d\xd2\x15\xfc\x9d\x2c\xde\xba\x2a\x95\x35\x56\xde\x68\x53\x15\x06\x32\x7b\x9f\x8b\x7b\x65\xf7\x48\x9d\x0b\x0a\x64\xab\x2d\x87\x28\xde\x01\x05\x77\xff\xba\x69\x74\x72\xd0\xd9\x87\x15\xb3\x2f\xad\x7f\x20\x99\xc3\x21\x56\xa3\x06\x5f\xa2\x63\x05\xd2\xcb\xe2\x21\x08\xf4\xf0\xeb\x43\xfa\x78\xb4\x34\x0e\xa4\x73\x1a\x16\x0c\x6f\xee\x02\x6a\xd7\xdb\xc8\x13\xaa\x67\x48\x90\x13\xc8\xcf\x21\x40\x0c\x67\x7a\x22\x75\x3a\x02\xc8\x03\xb8\x14\x78\xa8\x0c\xfd\xfa\xc9\xb8\x87\x64\xc2\x6f\x57\x69\xc3\xb3\xd0\xa9\x3f\x35\x05\x68\x07\x07\xa7\x83\xea\x72\xdb\xe9\xb0\x5d\xfe\xfb\x6c\x6b\x9f\x77\x66\xa3\x8f\x77\x1f\xdc\xf2\xf4\x3e\xff\x06\x87\x77\x28\xdc\x39\x48\x1d\xc7\xe6\x8e\xaf\x93\x82\xde\x3c\xa7\x5e\x0a\xfd\xc9\xee\x59\x15\x7b\x57\xc3\x57\x62\x40\x30\x94\x91\x21\x7f\xae\xd7\xdb\x5c\xee\xd6\xf9\xee\xd9\x75\x03\xf5\x56\xed\x3c\xdd\x89\xf6\x88\x8d\xe9\x51\x95\x76\xaf\xdb\x2f\x5f\xa0\x40\x25\x92\xe8\x6c\xee\x6f\x5c\x94\x66\xa8\xb2\xeb\xc2\x15\x20\x72\x56\x81\x5c\xef\xed\xe9\x2f\x4a\x4a\xa6\xcd\x69\x78\x3a\x85\xab\x34\xf5\xf8\x76\x54\x65\x17\x73\x28\xfd\x65\xc9\xe0\x45\xc9\x68\x70\x46\xe2\x41\x9b\xa8\xa8\x6e\x2c\xb6\x4e\xba\xc7\x16\xf2\xea\x56\x63\xeb\x64\x3a\x81\xf6\xc2\xa4\xfe\x53\xef\xd1\xde\x46\xa3\xb7\x11\xfc\x1d\x00\x00\xff\xff\x0b\x82\x55\xa4\x4e\x13\x00\x00" func switchboardSetup_royalty_account_by_pathsCdcBytes() ([]byte, error) { return bindataRead( @@ -782,11 +742,11 @@ func switchboardSetup_royalty_account_by_pathsCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/setup_royalty_account_by_paths.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x25, 0x74, 0x5c, 0x4a, 0x90, 0xd4, 0x13, 0xe, 0x2a, 0x42, 0xf7, 0x5e, 0x3, 0xcf, 0x28, 0x75, 0xa1, 0xbc, 0xc9, 0x80, 0x6e, 0xd0, 0xbe, 0x94, 0xbb, 0x12, 0x8b, 0x8a, 0xea, 0xc, 0x31, 0x42}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xff, 0x14, 0x56, 0x4d, 0xc4, 0xbf, 0x61, 0xb2, 0x72, 0x9b, 0x9f, 0x9b, 0xc, 0xb5, 0x79, 0xd4, 0xba, 0xa, 0x41, 0x6f, 0xea, 0xc7, 0x47, 0x10, 0x36, 0x82, 0x29, 0xe1, 0x9, 0x2d, 0xad, 0x39}} return a, nil } -var _switchboardTransfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x54\x4f\x4f\xdb\x4e\x10\x3d\xe3\x4f\x31\xbf\x1c\x7e\x38\x52\x08\x97\xaa\x87\x88\x3f\x45\xb4\xf4\x8a\x28\x6d\xcf\x63\x7b\x62\x6f\xeb\xec\xac\x66\xc7\x84\x08\xf1\xdd\xab\xdd\xb5\x8d\x0d\x95\x68\x0e\x71\x3c\x3b\x7f\xde\xbc\xf7\x36\x66\xe7\x58\x14\x6e\x3a\x5b\x9b\xa2\xa5\x7b\xfe\x4d\x16\xb6\xc2\x3b\x58\xcc\x62\x8b\xac\xcf\xfc\xf2\x88\x3b\x37\x4f\x9c\x86\x16\x59\x76\x7a\x0a\xf7\x8d\xf1\xa0\x82\xd6\x63\xa9\x86\x2d\x18\x0f\x08\x4a\x3b\xd7\xa2\x12\x6c\x59\xc2\xeb\xe4\x5c\x1b\xd4\x50\x58\x72\xd7\x56\x50\x10\x74\x9e\x2a\x28\x0e\x80\xf6\xc0\x96\x40\x19\x3c\xd9\x0a\x34\xcc\xf0\xe1\x15\x2d\x6b\x43\x02\x58\x96\xdc\xd9\x58\xac\x8d\x70\x57\x37\x80\xe0\xf7\x46\xcb\xa6\x60\x94\x6a\x05\xe8\xa1\x65\x5b\x87\xa7\x36\x74\x80\x06\x1f\x08\x3c\x29\x74\x2e\x04\x8c\x84\xda\x49\x05\xa0\xad\x52\x12\x56\x55\xc8\x00\x27\xec\x48\xa0\x44\x87\x85\x69\x8d\x1e\x02\x00\x13\x66\xa6\x65\x63\xa6\x90\xf7\xc0\xdb\x58\x20\x54\x92\x79\x78\x41\xb7\x8a\x51\xdc\x85\xdf\xa1\x36\xae\xbe\xa5\x38\x39\x4c\x0b\xa7\xb7\x5d\xd1\x9a\xf2\x16\xb5\x89\xfc\x84\x50\x4d\x96\xc4\x94\x70\x73\xff\xd2\x71\x6f\xda\x36\x10\xa4\x0d\x85\x6a\x87\x82\x3b\x52\x12\x9f\x4d\xf8\xcc\x95\x37\x70\x95\x30\xad\xfa\xb9\x1b\xf8\x7e\x63\x1e\x3f\x7e\x58\x8d\xbd\xc2\xac\xcd\x64\xee\x12\x9e\xb2\x0c\x00\xa0\x5f\xea\x01\xbb\x56\x41\xc8\x73\x27\x25\x45\x8d\xa0\xe1\xb6\x8a\x3c\x8e\x52\x84\x28\x0a\x41\x41\xc6\xd6\xe3\x66\x42\x55\x6c\xd5\x92\x06\xe5\xf4\x47\xe8\xb5\x81\x4f\x33\x53\xad\x63\x34\xcd\x74\x42\x0e\x85\x72\x6f\x6a\x4b\xb2\x81\xab\x4e\x9b\xab\xc4\xde\x88\xab\xc7\xf6\x95\x14\x10\x84\xb6\x24\x64\xcb\x68\x8e\x00\x28\x55\x1e\x7b\xf0\xca\x42\x55\x82\x3f\xd6\x05\x20\x31\x72\x47\x5b\x38\xef\x93\xd7\x05\x8b\xf0\xfe\xec\xff\xa9\x85\x13\xaa\x8b\x3c\x98\x7b\x03\x6f\x4f\xbe\x29\x0b\xd6\x14\x19\xcb\x8e\x8e\x8e\x2e\x2f\xc1\xa1\x35\x65\xbe\xb8\x8e\xee\xb5\xac\x90\xfa\xbe\xc5\xc8\xfb\x04\x31\x36\xfa\x6f\xb1\x9c\xed\xf5\xd3\x68\x53\x09\xee\x07\x6a\xe3\xed\x7a\x7f\x33\x4f\xed\x76\x3d\x72\x0c\x67\x27\xe3\x9e\xeb\x7d\xdf\x31\x1f\x2c\x90\x9e\xcb\x58\x1b\xbf\x9e\x13\x02\x7a\xa4\xb2\x53\xfa\x0b\xd1\xbd\x9d\x8d\x33\x64\xf5\xd8\x83\x8b\x76\x19\x8c\x0d\x5c\xfc\xa2\x72\xce\xf2\x98\x0d\xe7\x50\x93\xf6\x22\xe6\xca\xcb\x7f\x51\x71\x3a\xeb\xae\x37\xea\xeb\xf6\x31\x98\x74\x1c\xd3\xc7\x9c\xf0\x59\xd7\xa4\xd7\xe3\x6d\xcd\xa7\x86\x5f\xce\x13\x07\x03\x3c\xcd\x8d\x39\x4c\x7e\xbe\xc8\xdf\xd7\xb8\xbf\x99\xb3\x55\x26\xff\x27\xaf\x65\xfe\x4c\x8e\xbd\x49\xcc\x0e\x02\xd9\x41\x73\x63\xdf\xb0\x20\xaf\x59\x98\x30\xb0\xae\x52\xb3\xde\xac\x67\x27\x73\x33\xcc\x85\x7e\xce\xfe\x04\x00\x00\xff\xff\x2d\x30\xef\xcf\xee\x05\x00\x00" +var _switchboardTransfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x54\x41\x6f\xeb\x36\x0c\x3e\x37\xbf\xe2\x6b\x0e\xad\x03\x64\xce\x65\xd8\x21\x68\x5a\x74\xed\xb2\xd3\x80\xa2\xc8\xb2\x33\x2d\x33\xb1\x36\x47\x32\x24\x3a\x6e\x50\xf4\xbf\x0f\x92\xed\xc4\x49\xdf\xc3\xeb\xeb\xa1\x8e\x28\x92\x1f\x3f\xf2\xa3\xf4\xae\xb2\x4e\x30\x5e\xd6\x66\xab\xb3\x92\x57\xf6\x3f\x36\xe3\x51\x6f\xfe\xe3\x8d\x76\xd5\x27\xeb\x99\xf3\x5f\x2c\x94\x93\xd0\x5a\x73\xe3\xc7\xa3\xd1\x6c\x36\xc3\xaa\xd0\x1e\xe2\xc8\x78\x52\xa2\xad\x81\xf6\x20\x08\xef\xaa\x92\x84\xb1\xb1\x2e\x1c\x07\xf7\x52\x90\x40\xd9\xba\xcc\x91\x31\x6a\xcf\x39\xb2\x03\xc8\x1c\xac\x61\x88\x85\x67\x93\x43\x02\x9c\x0f\x47\x32\x56\x0a\x76\x20\xa5\x6c\x6d\x24\x62\x4a\xe1\x6c\xbd\x2d\x40\xf0\x8d\x16\x55\x64\x96\x5c\x3e\x05\x79\x94\xd6\x6c\xc3\x57\x0a\x3e\xa0\xa0\x3d\xc3\xb3\xa0\xae\x82\x41\xbb\xa1\x3b\xc8\xe4\xad\x07\xe5\x79\xb8\x46\xe5\x6c\xc5\x0e\x8a\x2a\xca\x74\xa9\xe5\x10\xe0\x75\x44\xec\x98\x46\x5f\xc7\xde\xc3\x6e\x62\x88\x63\xc5\x7a\x7f\xaa\x6e\x1a\xad\xb4\x0b\xbf\x43\x74\xe4\xbd\x09\xf7\xa6\xc5\x78\xa9\xb3\x52\xab\x17\x92\x22\x76\x26\x98\xb6\x6c\xd8\x69\x85\xe5\xea\x94\xae\xd1\x65\x89\x8c\x3b\xb2\x8c\x8a\x1c\xed\x58\xd8\xf9\x58\xcd\xa0\x9d\x89\xd8\x39\x1e\xdb\xaa\xa6\x1d\xf2\x1c\x7f\x2f\xf5\xdb\x6f\xbf\x4e\x8f\x09\x03\xe0\x7c\x00\x3e\xc1\xfb\x68\x04\x00\x1d\x2d\xaf\xb7\x86\xdd\xad\xc7\x9e\xea\x32\x56\xde\x68\x29\x72\x47\x0d\x36\xce\xee\xa2\x6b\xc9\x02\x6f\x6b\xa7\x78\x1d\x9c\xe6\xa0\x5a\x8a\xe4\x4c\x1f\xe9\x3f\x5d\xd4\x04\x37\x43\x39\xa5\x31\xa2\x45\xac\x1c\x57\xe4\x38\x69\x21\xbb\x2c\xbf\x5b\xe7\x6c\xb3\xa6\xb2\xe6\x09\x6e\x1e\xdb\x66\x1e\x8b\xec\xd1\x63\x71\xcf\x24\x84\x05\xce\xd2\x3b\xf6\xb6\xdc\xf3\x93\x35\xe2\x48\x49\x90\x67\x12\x6c\xa1\xd8\xd5\xa1\xe2\x39\x8c\x2e\xa7\xd8\x6b\x6e\xda\x63\xf8\x7f\xf7\x7d\x69\xa7\xcb\xd5\xba\xc7\xba\x4f\x26\x13\x90\xbf\xc6\xd7\xdc\x1f\x8e\x15\x87\xbf\x87\x07\x54\x64\xb4\x4a\xc6\x4f\x51\xf0\xc6\x0a\xb6\x3d\x13\x84\x04\xb1\xa8\xa3\x16\x54\xc7\x60\x3c\x39\x31\x9f\xcd\xf0\x27\x0b\x08\x8e\x37\xec\xd8\xa8\xb8\x25\x32\x9c\x9a\x17\xeb\x38\x6f\xb3\x1e\xe3\x3c\x97\x9b\x74\x30\x30\x2c\xba\x80\x34\xb8\xd3\x96\xd3\x2c\x76\xfd\xee\x67\xe7\x78\x9f\x04\x4d\xcc\x4f\xe3\xe8\x13\x46\x65\x8d\xae\xae\xae\xbe\x45\xbb\x05\xfb\x4c\xc2\x36\x2d\x87\x98\xfa\xba\x27\xfe\xd1\x7e\xf8\x8d\x55\x2d\x3c\x14\x42\xd7\x8e\x6e\xfb\x74\xa5\xd9\xc8\xad\x47\x15\xb5\xdd\xef\x21\x6c\xf6\x2f\x2b\x39\x53\xcf\xd1\x1b\x8b\x30\x83\x4e\x64\x89\xd8\x2f\xf5\x7a\x88\xf5\xda\x6d\xd5\x65\xfa\x68\x7c\xe5\x0d\x16\x27\xf7\xf4\xf8\x9c\x68\xf6\x7d\xc7\x6f\xde\xcf\xdb\xdd\x27\xfc\xb8\x4f\x86\x1b\xfb\xe3\x5e\x76\xcf\xc5\x59\xb5\x83\x37\xee\xfa\x42\x47\xcf\x5c\x59\xaf\xdb\xe6\xf5\x0b\x6e\xfa\xb7\x56\x9b\x4f\x44\xdd\x25\xd1\x01\xc9\x34\x6f\x93\x75\x62\xb8\xfb\xe5\x52\x6f\x69\x8f\x90\xf4\xaf\x52\xfb\x9d\x9c\x46\xfc\x31\xfa\x3f\x00\x00\xff\xff\x0c\x28\x2d\xa4\x94\x06\x00\x00" func switchboardTransfer_tokensCdcBytes() ([]byte, error) { return bindataRead( @@ -802,11 +762,51 @@ func switchboardTransfer_tokensCdc() (*asset, error) { } info := bindataFileInfo{name: "switchboard/transfer_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd6, 0x42, 0x4f, 0x7e, 0xc3, 0x84, 0x4d, 0x7a, 0xf4, 0x33, 0x40, 0xa8, 0x15, 0xe6, 0x5c, 0xa9, 0x54, 0x16, 0x76, 0x6a, 0xee, 0x7d, 0x88, 0x23, 0xc2, 0xe3, 0xa1, 0xef, 0xaa, 0xd9, 0x6d, 0xa}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x15, 0xf, 0xbc, 0x92, 0xd5, 0x70, 0x8, 0x33, 0xb2, 0xec, 0xf7, 0x37, 0xf9, 0x9d, 0x78, 0xbf, 0x5c, 0x5, 0x1a, 0xff, 0xe5, 0x94, 0x16, 0xd6, 0xdf, 0x0, 0xed, 0x36, 0xbb, 0xe8, 0x89, 0x83}} + return a, nil +} + +var _tokenforwarderCreate_forwarderCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xbc\x55\xdf\x6f\xdb\x36\x10\x7e\xe7\x5f\x71\xf3\x43\x67\x07\x8e\x8c\xfd\x7a\x31\x92\x06\x9d\xbb\x0c\x05\xb6\xa1\x58\xdc\xbc\xae\x67\xea\x6c\x72\x95\x49\x81\x3c\x59\x35\x8a\xfc\xef\x03\x49\x89\x96\x9c\x34\xc8\x5e\xea\x87\x20\x12\x79\x77\xdf\x7d\xdf\x77\xa7\xc5\xc5\x85\x10\x6b\xa5\x3d\xb0\x43\xe3\x51\xb2\xb6\x06\xb4\x07\x04\xa6\x7d\x5d\x21\x13\x6c\xad\x0b\x8f\x83\x73\x56\xc8\x20\x6d\x53\x95\xb0\x21\x68\x3c\x95\x82\x2d\x78\x62\x68\x6a\x40\x03\x28\xa5\x6d\x0c\x03\xdb\x10\xdc\xa2\x2b\xa1\xa4\xda\x7a\xcd\x54\x02\xdb\x4f\x64\x7c\x38\x43\x63\x59\x91\x03\x47\x92\xf4\x81\x5c\x21\xc4\xbb\x2d\xa0\x39\x5a\x43\xe0\xc9\x94\x7e\x78\x39\xd4\x71\xdf\x7b\xb8\x4d\x19\xc9\xc1\xdf\x5d\xdc\x5c\xb0\xa2\xfc\x04\xad\xae\x2a\xf8\xb7\xf1\x9c\x8b\xb3\xb2\x9e\x06\xb9\xc2\xf5\x7b\x6c\x2a\x4e\x9d\x28\xf4\xb0\x21\x32\x22\x74\x80\x3e\x1e\x3b\x92\xba\xd6\x64\x18\xd0\x94\x40\x7b\x1d\xfe\x01\x3a\x84\x37\x31\x48\x9b\x52\x4b\x64\xf2\xa2\x55\x5a\xaa\x88\xae\x2f\x18\xba\x54\x7d\xc1\xa2\x23\xb8\xc5\xe3\x1c\x74\xe8\x0f\xec\x76\x7b\x29\x15\x6a\x03\x9e\xdc\x41\x4b\x82\x16\x0d\x47\x68\x7b\x6b\x34\x5b\x07\xad\xb2\x41\x86\x2e\xa1\x36\x3b\x71\x82\xaf\x79\x0e\x9a\x41\xa2\x81\x16\x59\xaa\x04\x2b\x1e\x79\x22\x68\x15\x39\x1a\x00\x00\x89\x7b\x82\xad\xb3\xfb\x42\x88\x3b\xa6\xba\xbb\x99\xd4\x4a\x52\x79\x68\x35\xab\x14\x90\xbb\x70\x4b\x21\x7e\x28\x60\xad\x08\x6e\x1b\xb3\xd3\x9b\x8a\x60\x1d\x6f\x48\x6b\xd8\xa1\x0c\x2c\x30\xb9\x2d\x4a\x02\xaf\xa2\x1f\xb0\x72\x84\xe5\x31\xf8\xa2\xa4\xba\xb2\x47\x2a\xc1\xdb\x3d\x45\x50\xe2\xc7\x94\x0d\xeb\xba\xd2\x12\x43\x3e\x1e\xe7\xeb\xb2\x0c\xa2\x0b\xf1\x53\x0a\x1a\x28\xd2\xd9\xab\xbb\xac\xf0\x40\x80\x9d\xa0\xc1\xac\x1c\xfd\x9c\x12\x3b\x42\xa6\x52\x00\x40\x14\xd2\xb3\x75\x54\x82\x36\xa0\xd9\xc7\x27\xdc\x51\xea\x1d\xa1\x6e\x36\x95\xf6\x8a\xca\xec\x25\xf1\x73\x01\x6f\x23\x90\xc8\xe7\xc7\xd8\xfd\x6d\xd6\xa4\x90\xa5\xfc\x78\x02\x1f\x5d\x5a\xea\xed\x96\xdc\x00\xa6\xf8\xa5\x08\x9e\x05\x04\x43\x2d\xbc\x49\x2f\x97\xb0\x8a\xc8\x62\xda\xbe\x1f\x63\xdd\x1e\xab\xea\x38\x8f\x70\x59\x91\x01\xd7\x98\x54\x39\x35\xf2\x4f\x96\x26\x95\x1e\x0c\x65\x0a\xda\x11\xb3\x36\x3b\x18\x0d\x44\x90\x7e\x54\x28\x19\xf8\xcc\xe8\x85\xb8\x58\x08\xa1\xf7\xb5\x75\x0c\x93\x5e\xf0\xd8\xf1\x24\xbf\xfe\xed\x33\xee\xeb\x47\x6f\xcf\x68\x99\x3c\x9d\xe5\x4f\x62\x2c\x91\xf1\x5e\x53\xeb\x27\x42\x0c\xc0\x4f\xfb\x15\xb0\x84\x37\x65\xe9\xc8\xfb\x19\x7c\x11\xb1\xa3\xda\x51\x8d\x8e\xa6\x5e\xef\x4c\x38\xc7\x86\xd5\xf4\x57\xeb\x9c\x6d\xef\xb1\x6a\x68\x0e\xef\xbc\x6f\xe8\x2e\x49\xb9\xc2\x1a\x37\xba\xd2\x7c\x5c\x05\x55\x6c\x55\x91\x9b\xc3\xfb\x24\xec\xe9\x70\x0e\x77\x78\xa0\x2e\xfe\x83\xa9\xcf\xcf\x67\xf0\xaa\x13\x2a\xe3\x08\xbf\x8a\x18\x0e\xc1\x66\x6f\x91\x11\xae\x61\xc8\x46\xe1\xc8\xdb\xea\x40\xab\xce\x0d\xa1\xcb\x69\x78\xd7\x38\x49\xeb\x63\x4d\x4b\x30\xba\x9a\xc3\x41\x53\x9b\x1e\xc3\xdf\xab\xaf\x33\x54\xdc\xae\xef\xfb\x5a\xaf\xa7\xb3\x19\xa0\xff\x0e\x5e\x76\xfd\x26\x23\x0e\xbf\x9b\x1b\xa8\xd1\x68\x39\x9d\xac\xe2\xbc\x18\xcb\xc1\x27\xa9\x13\x08\x09\x22\xa8\x6e\x74\x28\xfb\x79\x32\x3b\x75\xbe\x58\xc0\xef\xc4\xbd\x61\x92\xad\x64\xa6\x2b\x87\xf6\x06\xdb\x50\x30\xe1\x60\x1b\xda\x11\x87\xa7\x51\xbe\x0e\x48\x3a\xaa\xb3\x09\x66\x45\x4e\xad\xc9\x17\x3b\xe2\xab\x57\x5f\x46\x9d\x17\xbd\xb7\x1f\x5e\x4f\xb3\x20\x45\x1f\xff\x1e\x59\x8d\xb1\x0f\x86\x2d\x4f\x50\xda\x07\x61\x77\x68\xee\x3f\x0a\xe7\x03\x52\xda\x7e\x98\x06\x8b\xf8\x91\x1b\xe0\xea\x12\x1e\x6d\x86\x58\xf1\x2f\x6a\xf3\xe7\x6a\x9a\xbb\x5e\x9e\x08\x98\xe5\x6c\xc9\xdf\x45\xb7\x92\x8a\x00\x6c\x7a\x75\x19\xf3\xcf\x81\xed\x12\x16\xdd\xd1\x82\x06\xae\xcb\xd9\xc7\xfd\x7e\x30\x95\x36\x9f\x22\x70\xfa\xac\x7d\x5c\x09\x27\xb9\xce\x6b\x8e\xd8\x6e\xfa\x69\x78\x11\xb1\x7f\xf4\x65\x4c\x32\x50\xd7\xfe\x53\x26\x19\xf1\x16\xb7\x73\x2f\xe2\x0a\x6b\xb8\x7e\x12\x4c\xcf\x86\x0e\x23\xfe\x9c\x09\x46\x86\x8f\xd8\x9e\x65\x6b\x74\xfd\x91\x06\x23\x08\x3d\x1b\xe7\x88\xe7\x80\xbc\x84\xff\xcd\x51\x86\x10\x77\x92\x7c\x96\x9f\x7c\xf7\xe5\x04\x9d\xdb\xf0\xac\xdc\xb7\x63\x6a\x88\x3d\x51\xb5\x88\xe7\xf2\x6b\xf6\x0d\x59\x1f\xc4\x83\xf8\x2f\x00\x00\xff\xff\x82\x60\xcb\xa0\x92\x0a\x00\x00" + +func tokenforwarderCreate_forwarderCdcBytes() ([]byte, error) { + return bindataRead( + _tokenforwarderCreate_forwarderCdc, + "tokenForwarder/create_forwarder.cdc", + ) +} + +func tokenforwarderCreate_forwarderCdc() (*asset, error) { + bytes, err := tokenforwarderCreate_forwarderCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "tokenForwarder/create_forwarder.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1a, 0xc0, 0x53, 0x38, 0x82, 0x8a, 0xda, 0x23, 0x35, 0x65, 0x9f, 0x91, 0xef, 0xbd, 0x9c, 0xbf, 0x61, 0x8a, 0xf6, 0xcf, 0x4e, 0x38, 0xf4, 0xa9, 0x4d, 0x78, 0x27, 0xc7, 0xeb, 0x81, 0x49, 0x17}} return a, nil } -var _transfer_many_accountsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x54\x4d\x6f\x9b\x40\x10\x3d\x87\x5f\x31\xe1\xd0\xe0\x43\xc8\xa5\xea\x01\x39\x89\xac\xb4\xe9\xa9\x52\x94\xa6\xed\xa1\xaa\x94\x05\x06\xd8\x06\xef\xae\x66\x87\xd8\x91\xe5\xff\x5e\x2d\xbb\x20\x6c\xac\xd4\x17\x4b\xf3\xf1\xe6\xcd\xbc\xc7\xca\xb5\xd1\xc4\x70\xdf\xa9\x5a\xe6\x2d\x3e\xe9\x17\x54\x50\x91\x5e\x43\x7c\x10\x8b\xa3\x50\xf9\x65\x2b\xd6\xe6\xb0\x70\x1a\x8a\xa3\xe8\xea\xea\x0a\x9e\x48\x28\x5b\x21\x59\x60\x17\x75\x7f\x20\xa0\x95\x96\x41\x57\x20\xca\x92\xd0\x5a\xb4\x60\x0d\x16\xb2\x92\x58\x82\x54\xc0\x0d\xc2\x73\xc8\xad\xd6\xba\x53\xfc\x4d\x98\x67\x30\x82\xc4\x1a\x19\x29\x8a\xd8\xc1\x8a\x82\xa5\x56\xc9\x71\x61\x06\xbb\x95\x0f\x65\xf0\xe3\x5e\x6e\x3f\x7d\xdc\x2f\x60\x17\x45\x00\x00\x8e\x51\x83\xf0\x53\x74\x2d\x03\xa1\xd5\x1d\x15\x08\xdc\x08\x86\x46\xb7\xa5\xed\x47\x0f\x4c\x5d\x54\x10\x42\x8e\x52\xd5\xc0\x61\x13\xc2\xb2\x87\x6a\x91\xe1\xd5\xe1\x3c\x62\x95\xc1\x87\xe9\xee\x69\x8f\xef\x27\x1a\x42\x23\x08\x13\x2b\x6b\x85\x94\xc1\xaa\xe3\x66\x55\x14\x8e\xeb\xc8\x2a\x30\xfb\x8a\x0c\x02\x08\x2b\x24\x54\x8e\x96\xee\xe9\xf8\xce\x0b\x0b\x96\x35\x61\xe9\x87\x8e\x7d\x16\xdb\x2a\x1d\x78\xc0\x75\xa8\x4e\x73\x4d\xa4\x37\xcb\x13\xb4\x6e\x12\x27\x56\x06\xf3\xcc\x77\xd6\x24\x6a\x7c\x10\xdc\x2c\xa2\xb3\xb3\xb3\xdb\x5b\x30\x42\xc9\x22\x89\xef\x74\xd7\x96\xa0\x34\x83\xc7\x9d\x93\xd4\x1b\xcf\xb1\x07\x3a\x8f\x17\x3d\xbf\xbd\x5f\x0f\xb7\x58\x74\x8c\xd3\x6d\x2b\x4d\x83\xf8\x4e\xf0\x63\x09\xd3\x17\x7c\xb3\xd3\xfa\x70\xa1\x5f\x92\x9b\x92\xc4\x66\x90\xa8\xb7\xdd\xff\x6f\x34\xc8\x65\x51\xb1\x97\x7e\x79\x79\x78\xb8\x74\x13\x90\x13\xd1\x73\xc8\x66\x94\x7e\x87\xc0\x9f\xf3\xc5\x8c\x96\x13\xce\xb1\x20\x2c\xa4\x91\xa8\xf8\xc2\x82\xe9\xf2\x56\x16\x20\xbc\xd4\xa0\xf3\xbf\x58\xcc\x19\x8d\x1d\x70\x0d\x35\x72\x30\xc6\x60\xe9\xd3\x93\x4e\x58\x64\x3a\xf8\x11\x0b\x94\xaf\x48\xa7\x66\xf5\x09\xef\x93\xb1\x25\xad\x91\xef\x84\x11\xb9\x6c\x25\xbf\x25\x07\xb6\x18\xb0\x1e\xfa\x65\xbc\x31\xe0\xe8\x37\x5a\x6d\x77\xf0\x4e\x8c\xbd\xfb\x9b\x64\xde\xf4\xae\xb5\x7c\xdf\xfb\x5b\xf6\x32\xc6\xf3\x03\x7d\x46\xa3\xad\xf4\x72\x0c\x9a\xaa\xc1\x2e\xe1\x69\x99\xe2\xd0\xa9\x6b\x4d\x2e\x95\x96\x1e\x30\x7c\x34\xcb\xcb\xd1\x43\x93\xd9\xfb\xe0\xf6\x7d\xf4\x2f\x00\x00\xff\xff\x59\x4e\x87\x84\x46\x05\x00\x00" +var _tokenforwarderScriptsIs_recipient_validCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\xce\xb1\x6a\x03\x31\x0c\x06\xe0\xdd\x4f\x21\x32\x14\x1b\x8a\x1f\xe0\x68\x0b\xe9\x90\x39\x94\xbe\x80\x4e\xd6\x25\x26\x8e\x15\x64\x99\x0c\x21\xef\x5e\x7a\x47\x87\x2b\xa7\x49\xc3\xaf\x5f\x5f\xbe\xde\x44\x0d\x76\xdf\x72\xe1\x7a\x10\xbd\xa3\xa6\x5c\x4f\x3b\xe7\x90\x88\x5b\xf3\x58\x4a\x80\xa9\x57\xb8\x62\xae\x1e\x53\xd2\x01\xf6\x29\x29\xb7\xf6\x0a\xb6\xbe\x3a\xa2\x9d\x07\x38\xf6\xb1\x64\xfa\xdd\xc3\x00\x9f\x22\x05\x1e\x0e\x00\xa0\xb0\xc1\xb4\x64\x59\xbf\x78\x82\x77\x38\xb1\xed\x89\xa4\x57\x9b\x9b\xc3\x9c\xdb\x98\x48\x78\xc3\x31\x97\x6c\x99\x5b\x1c\x45\x55\xee\x6f\x2f\x8f\x7f\xe8\x78\xf8\x6b\x5f\x08\xcf\x0f\xbf\x01\x0c\x6e\xfe\xa2\x6c\x5d\xeb\x0a\x14\xe9\xcc\x74\xf1\xc1\x3d\x7f\x02\x00\x00\xff\xff\x63\xb3\x87\xb4\x16\x01\x00\x00" + +func tokenforwarderScriptsIs_recipient_validCdcBytes() ([]byte, error) { + return bindataRead( + _tokenforwarderScriptsIs_recipient_validCdc, + "tokenForwarder/scripts/is_recipient_valid.cdc", + ) +} + +func tokenforwarderScriptsIs_recipient_validCdc() (*asset, error) { + bytes, err := tokenforwarderScriptsIs_recipient_validCdcBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "tokenForwarder/scripts/is_recipient_valid.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa1, 0xd5, 0x8d, 0x4, 0x81, 0x73, 0xb6, 0xfa, 0xe1, 0x31, 0x67, 0x35, 0x66, 0x5d, 0x6c, 0xb5, 0x1f, 0x3c, 0x61, 0x81, 0x36, 0x95, 0x6f, 0x71, 0xb8, 0x3, 0xfd, 0x72, 0x60, 0x53, 0x8a, 0xeb}} + return a, nil +} + +var _transfer_many_accountsCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x55\x4d\x4f\xe3\x48\x10\x3d\xe3\x5f\x51\xe4\x00\xb6\xb4\x38\x97\xd5\x1e\xac\x00\x62\x61\xd9\x13\xd2\x28\xca\x30\x87\xd1\x48\x54\xec\x72\xdc\x83\xd3\x6d\x75\x97\x13\x10\xca\x7f\x1f\xf5\x57\x70\x3e\x06\x31\x7d\x48\x94\x72\x75\xd5\x7b\xaf\x5e\xc5\x62\xd9\x29\xcd\x30\xba\xef\xe5\x42\xcc\x5b\x9a\xa9\x67\x92\xa3\x24\x86\xff\x7b\xc1\x65\x77\x10\xdd\x49\x7e\x20\xc6\x0a\x19\x1f\x05\xad\xcd\x28\x49\xc6\xe3\x31\xcc\x34\x4a\x53\x93\x36\xc0\x36\xc5\x7e\x01\x42\x2b\x0c\x83\xaa\x01\xab\x4a\x93\x31\x64\xc0\x74\x54\x8a\x5a\x50\x05\x42\x02\x37\x04\x4f\xe1\xd9\xcd\x52\xf5\x92\x1f\xb0\x7b\x82\x0e\x35\x2e\x89\x49\x27\x09\xdb\xb2\x58\xb2\x50\x32\xdd\x4f\x2c\xe0\xed\xc6\x87\x0a\xf8\x7a\x2f\x5e\xfe\xf9\x7b\x93\xc1\x5b\x92\x00\x00\x58\x48\xf7\xb3\x47\xec\x5b\xbe\x43\x46\x58\x06\xc8\xb0\x12\xb4\x86\x5a\x69\xd7\xdb\x41\x85\x39\x09\xb9\x80\xde\x50\xe5\xae\xb6\xc4\xb0\x8a\x17\x0b\xf8\x3d\xf3\x7c\xd0\xe0\xbd\xeb\xac\x21\x70\x61\xd0\x64\x54\xaf\x4b\x02\x6e\x90\xa1\x51\x6d\x65\xde\xbb\x1a\x1f\x45\x4d\xa1\x3f\x07\x01\xf5\x3e\x8c\x29\xd5\x05\x60\xcf\x4d\xba\x03\x25\xff\x26\xb8\xa9\x34\xae\x33\x38\x1b\xce\x2c\x77\xcd\x3d\x9e\x4e\x53\x87\x9a\x52\x23\x16\x92\x74\xa8\xf2\xaf\xd2\x5a\xad\x1f\xb1\xed\x29\x83\xb3\x9b\xb2\xb4\x72\x5a\xe1\x20\x1c\x43\x6d\x9d\x6f\x15\x80\x4b\xd8\x29\x6f\x59\xb5\x2b\xba\x55\x92\x35\x96\x6c\x95\x48\x23\xd3\xd9\x6b\x47\x05\x48\xd1\xfe\xe5\x74\xf6\x3f\xed\xe7\xe4\x73\x2a\x5e\xa5\x59\x06\x68\x4e\x3f\x29\xfa\xf5\x16\xb2\x3d\xd7\xd7\xd0\xa1\x14\x65\x3a\xb2\x89\x53\x0f\x53\x43\xa5\xc8\x80\x54\x7e\x1c\xed\x8a\x76\x6c\x61\x51\x8e\xb2\x64\x5b\x67\x3c\x86\xff\x89\x01\x41\x53\x4d\x9a\xa4\x1d\x9e\x72\x43\xf3\x12\x9e\x1b\x30\xac\x34\x55\x7e\x34\x47\x24\x9b\x52\x0d\x97\x21\x3b\xb7\xb9\xb8\xa0\x7c\xee\x24\x9f\xfc\xe9\x10\xaf\xd2\x5a\xab\x65\xb1\x37\x90\x58\xf5\x0b\x72\x93\x25\x27\x27\x27\xef\xc4\x6f\x55\xdf\x56\x8e\xac\xef\x78\x48\x43\xad\x3d\x0b\x57\xff\x74\x94\x39\x06\x1b\x2f\x00\xbd\x50\xd9\x33\xc5\x15\xb2\xc7\x2e\x4a\x58\x3b\xbb\xaf\xfb\x1b\x98\x3f\xd3\xab\x19\xe6\x07\x0d\x23\xab\x68\x75\x4b\xe3\x13\x2a\x46\xdb\x1b\x92\xec\x57\x68\x72\xb1\x2b\x6d\xbe\x0e\x95\x53\x74\x18\x8a\x03\x48\xdf\x43\xe0\xc7\x69\x76\x00\xcb\x8e\xd6\xa2\xd0\x54\x8a\x4e\x90\xe4\x73\x03\x5d\x3f\x6f\x45\x09\xe8\xd7\x00\xd4\xfc\x27\x95\x87\x88\xb6\x37\xe0\x12\x16\xc4\x61\x69\xe2\x3f\xd2\xf1\x4e\x47\x4c\x34\x6c\x3c\xa5\x92\xc4\x8a\xf4\xb1\x5e\xee\x81\x77\xd2\xf6\x4a\x5e\x62\x87\x73\xd1\x0a\x16\x64\xa2\xa3\xce\xde\x76\xed\x14\x8b\x6e\xae\xd2\x3d\xd3\xc4\xaa\xde\x35\xb0\x77\x3e\xb4\x90\xbf\xf8\x31\x1b\x37\xae\xd1\xa1\x10\x77\xd4\x29\x23\xbc\xec\x71\x76\x32\xda\x22\xbc\x01\x86\x75\xf4\x31\x55\x06\x8a\xe4\x95\x2f\x18\x36\x63\x72\xb1\xf5\xca\xa0\xf7\x26\xb8\x7a\x93\xfc\x0a\x00\x00\xff\xff\xab\x22\xcc\xb5\xec\x06\x00\x00" func transfer_many_accountsCdcBytes() ([]byte, error) { return bindataRead( @@ -822,11 +822,11 @@ func transfer_many_accountsCdc() (*asset, error) { } info := bindataFileInfo{name: "transfer_many_accounts.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc9, 0x3a, 0x6, 0xa3, 0x37, 0xad, 0x9b, 0x2, 0xd, 0x14, 0x2a, 0xef, 0xa6, 0xe0, 0x60, 0x2f, 0xd6, 0xd2, 0xae, 0x2a, 0x85, 0x4e, 0x5d, 0xc2, 0xe7, 0x60, 0x62, 0x48, 0x4a, 0x73, 0x20, 0x55}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1d, 0x55, 0x99, 0x5b, 0x8, 0xa8, 0x39, 0xe2, 0x24, 0x45, 0x26, 0xaa, 0x87, 0xf6, 0x8, 0x46, 0xc, 0x81, 0x61, 0x1a, 0x9c, 0x6, 0x7e, 0xbe, 0x37, 0x6b, 0x4, 0x9, 0x55, 0x71, 0xd8, 0xc5}} return a, nil } -var _transfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x53\x4d\x6f\xd3\x40\x10\xbd\xfb\x57\x0c\x39\x50\x47\xa2\xce\x05\x71\x88\xfa\x41\x55\x28\xd7\xaa\x14\x38\xaf\xed\x97\x78\xc1\xd9\xb5\x66\xc7\x4d\xab\xaa\xff\x1d\xed\xae\xd7\xd8\x09\xe2\x23\x97\xc8\xe3\x99\x37\x6f\xde\x7b\x5e\xad\xe8\xbe\xd1\x8e\x84\x95\x71\xaa\x12\x6d\x0d\x69\x47\x8a\x04\xbb\xae\x55\x02\xda\x58\xf6\x8f\x93\xf7\xd2\x28\xc9\x56\x2b\xaa\x6c\xdf\xd6\x54\x82\x7a\x87\x9a\xca\x27\x52\xe6\xc9\x1a\x90\x58\x72\x30\x35\x89\xfd\x01\xe3\xfc\xa3\x32\x56\x1a\x30\xa9\xaa\xb2\xbd\x09\xc3\x1e\x84\x1a\xe5\xa8\x04\x0c\x39\x08\xf5\x9d\x6f\x65\x54\xd0\x0f\x18\x86\x8b\x6c\xb5\xca\x02\x47\xd0\x5e\x4b\x53\xb3\xda\x93\xda\x79\x10\x52\x7e\x45\x83\x04\x4a\x1b\xb6\x3b\xda\x42\xae\x7e\x2d\xd9\x27\x86\xbe\xaf\x53\xac\x76\x10\x70\xa0\xe4\x2b\x93\xa3\xb2\x4c\xef\x3a\xcb\x42\x37\xbd\xd9\xea\xb2\xc5\xbd\xdf\x1f\x31\x17\xb3\xda\x22\x75\x7e\x7c\x54\xbb\x6e\xde\x38\x2d\x2d\xb2\x6c\x82\x9f\x47\xd2\x6b\xfa\x72\xa3\x1f\xdf\xbd\x7d\x43\x62\xd7\x74\x55\xd7\x0c\xe7\x96\xf4\x9c\x65\x44\x44\xc3\xa1\x5f\x55\xdf\x0a\x31\x9c\xed\xb9\xc2\xa0\x94\x6d\x6b\x17\x49\x0f\xaa\xfa\xaa\x62\x50\x09\x6d\xb6\xf1\x94\x0d\x98\x51\x07\xa8\x16\xe2\x4d\x90\x80\xb5\xa6\xf7\xb3\x13\x8a\x50\x8d\x3b\x3b\x46\xa7\x18\xb9\xd3\x5b\x03\x5e\xd3\x55\x2f\xcd\xa0\xe0\xc8\x6b\xe0\xf6\x09\x42\x8a\x18\x1b\x30\x4c\x85\xa4\x62\x9c\x3c\x71\xe4\xc4\x32\x6a\x7a\x08\xe0\x69\xce\x13\x09\x95\x3b\x6c\xe8\x7c\x68\x2e\x4a\xcb\x6c\xf7\x67\xaf\xa7\x82\x45\x56\x17\xb9\x97\x72\x4d\xc7\x6f\x3e\x8b\x65\xb5\xc5\xad\x92\x66\x39\xc2\xfb\xdf\xe5\x25\x75\xca\xe8\x2a\x5f\x5c\x07\xbf\x8d\x15\x8a\x0b\x8e\xc9\xda\x7d\xe4\x1a\x10\x5f\x2d\x96\xb3\x03\xbf\xa5\x84\x0d\x1a\x07\x53\xff\x7e\xa2\x43\xbb\x29\x46\xb1\xe9\xec\x74\x3c\xb8\x48\x99\x1d\xed\x8f\xff\x91\xff\x4b\x5c\x8e\x47\x54\xbd\xe0\x37\x62\xfb\xd5\x8c\x4a\x77\x1a\x46\x4e\x1c\x75\x7d\xd9\xea\x6a\x0c\xbc\x2d\xbf\xa3\x9a\x2b\x3d\x76\xd3\xf9\xe4\x53\xc8\xc5\x2e\xff\xc5\xc9\xe9\xae\xbb\xf8\x1d\xf2\x21\x7c\x28\x46\x2f\xc7\xf6\x62\x0b\xb9\x56\x9d\x2a\x75\xab\xe5\x29\x9f\x59\x97\x70\x6e\x03\xf7\x63\xf3\xc6\x28\x3c\xcf\x23\x9a\xe6\x5e\x2e\xf2\xff\x70\x3b\xce\xfc\xf9\xb2\xe0\xd2\x81\xf3\x1f\xd0\x59\xa7\xa3\xe2\xc9\x33\x93\x62\xa0\xcd\x11\x06\x1f\xaa\x33\x51\xa6\xa8\x23\xd8\x10\xe4\xb3\xd3\x79\x3e\x92\xf7\x2f\xd9\xcf\x00\x00\x00\xff\xff\xf7\x59\xaf\xcf\x7c\x05\x00\x00" +var _transfer_tokensCdc = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x54\xc1\x6e\xeb\x36\x10\xbc\xeb\x2b\xe6\xf9\x90\x27\x03\xef\x49\x97\xa2\x07\xc3\x49\x9a\x26\x4d\x4f\x05\x8a\xc0\x4d\xcf\x2b\x69\x6d\xb1\x95\x49\x81\x5c\xd9\x09\x82\xfc\x7b\x41\x52\x54\x64\x07\x69\x53\x1d\x12\x70\xbd\xdc\x99\x9d\xd9\x65\x59\x62\xd3\x2a\x07\xb1\xa4\x1d\xd5\xa2\x8c\x86\x72\x20\x08\xef\xfb\x8e\x84\xb1\x35\xd6\x1f\x67\xbf\x4b\x4b\x92\x95\x25\x6a\x33\x74\x0d\x2a\xc6\xe0\xb8\x41\xf5\x0c\xd2\xcf\x46\x33\xc4\xc0\xb1\x6e\x20\xe6\x6f\xd6\xce\x1f\x49\x1b\x69\xd9\x82\xea\xda\x0c\x3a\x5c\xf6\x45\xd0\x92\x43\xc5\xac\xe1\x58\x30\xf4\x3e\xd5\x72\xcd\xea\xc0\xe3\xe5\x22\x2b\xcb\x2c\x70\x64\x1c\x95\xb4\x8d\xa5\x23\x68\xef\x8b\x80\x3c\x44\xcb\xa9\x28\xb6\xd6\xec\xb1\x63\xb9\x79\x03\x39\x26\x86\x3e\xaf\x27\x4b\x7b\x16\xb6\x81\x92\x8f\xcc\x9a\xca\x32\xb5\xef\x8d\x15\x2c\xee\x07\xbd\x53\x55\xc7\x1b\x4f\x60\x31\x85\x7f\x79\xa2\x7d\xff\x2e\x7a\x92\xfc\x1b\x0b\x35\x24\xf4\xa8\xf8\xe8\x16\x59\x36\x2b\x9f\x47\xce\x2b\xfc\x71\xaf\x9e\x7e\xfc\xe1\x1b\xc4\xac\x70\xd3\x34\x96\x9d\x5b\xe2\x25\xcb\x00\xa0\x2c\x4b\xdc\x6f\x1e\x69\xe8\xe4\x8e\x84\xb0\x1f\xeb\xe1\xa0\xf8\x18\x7c\x08\xa4\x3d\x14\x2a\x56\x7a\x17\x84\x0f\x57\x3b\x16\x1c\xd2\xc5\x15\x3e\xa6\x55\xcc\x00\x12\x6a\x50\x37\x44\x61\xd9\x99\xc1\xd6\x3c\xda\x63\xba\xc6\xbd\x81\xba\x18\x25\xcb\x23\x7c\x68\x70\xcb\xd6\xce\x58\x38\xd6\x12\x6a\xad\xf0\xd3\xcb\x09\x8f\x22\x84\x5f\x23\x6a\x6f\xb9\x27\xcb\xb9\x53\x3b\xcd\x76\x05\x1a\xa4\xcd\x7f\x36\xd6\x9a\xe3\x23\x75\x03\x2f\x71\x31\xfa\x38\xc9\xe3\x3f\xc7\xdd\xb6\x98\x1a\xc5\x25\xe6\xb6\x14\x9e\x7d\x77\xe0\x5b\xa3\xc5\x52\x2d\xbe\xe1\x3c\x75\xb4\x79\xee\x79\x05\xad\xba\x6f\x41\xce\x78\xf4\x7f\xd7\x9f\x13\xeb\x2a\x5f\x2e\x41\xee\xcb\x27\xb5\xbd\x9e\x28\xfb\xef\xfa\x1a\x3d\x69\x55\xe7\x0b\x9f\xf8\x10\x69\x5a\x34\x86\x1d\xb4\x89\xb2\x77\x07\x3e\x71\xdf\xb3\x5c\x2c\xdf\x5a\x2f\x4b\xfc\xca\x02\x82\xe5\x2d\x5b\xd6\x35\xa7\x31\x8e\x1a\x7e\x75\x70\x62\x2c\x37\x71\x10\xa6\x7b\xd3\x68\x3c\xf0\x16\x97\x63\x72\xe1\x53\x69\xc7\x45\x15\x24\x5f\x07\xf9\x4f\xdd\xfa\x73\x5c\xb7\x25\x2e\x4e\x44\x0e\x0c\xaf\x72\xbf\x6d\xab\x33\x3f\x52\xd5\xdf\x49\xda\xe5\x07\x02\xdc\x86\x95\xf4\x4d\x47\xe8\xf7\xed\x98\x63\xec\x26\x00\x7d\x39\x93\x20\xb1\x4a\x13\x19\x96\xfe\xbf\x45\x08\x3c\xa7\xd1\xc4\xfa\xfb\x24\x49\x91\x9e\x95\x69\x45\xe3\xff\xc8\x7f\x9c\x56\x7e\xe2\x7a\x10\x9e\x4f\xe2\x68\x87\x87\xb6\x5c\xab\x5e\xb1\x96\xaf\x0e\xfd\x50\x75\xaa\x9e\xde\x24\x53\xfd\xc5\xf5\xa9\x17\x53\x36\x2e\x67\xaf\x55\x2e\xe6\x53\x5e\xcf\xb1\x1e\xe2\x53\x69\xcf\xcb\x87\x60\x74\x7b\x4a\x2f\x6a\xea\xa9\x52\x9d\x12\xc5\x2e\xb9\x7e\x71\xb6\xa0\xa9\xe0\xeb\x55\x7e\x66\x6c\xaa\xfa\x3f\x9d\x8d\x97\xfe\xbd\x8b\xe0\xc8\x99\xcb\x77\xdc\x1b\xa7\xa2\xba\xc9\x1f\x9d\x2c\x57\xfa\x5d\x0d\x7b\xae\xc4\x4c\x85\xa2\x89\xc5\xc6\x89\x5d\x7f\x3f\x9d\x85\xe4\xf3\x6b\xf6\x4f\x00\x00\x00\xff\xff\xdb\x83\x07\xed\x0b\x07\x00\x00" func transfer_tokensCdcBytes() ([]byte, error) { return bindataRead( @@ -842,7 +842,7 @@ func transfer_tokensCdc() (*asset, error) { } info := bindataFileInfo{name: "transfer_tokens.cdc", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} - a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9d, 0x16, 0xc6, 0x17, 0xab, 0x4d, 0xba, 0x5d, 0xd7, 0x3e, 0xe9, 0x51, 0xf7, 0xc1, 0x21, 0x29, 0x68, 0xd8, 0x18, 0xbe, 0xb4, 0x85, 0xd9, 0xcb, 0x64, 0x28, 0x51, 0xe0, 0xca, 0xba, 0xde, 0x5a}} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf5, 0x3d, 0x51, 0xbf, 0x1a, 0xd8, 0x34, 0xf, 0x15, 0x63, 0x6a, 0xf2, 0x48, 0x2b, 0x2f, 0xc8, 0x77, 0x7, 0x72, 0x38, 0xf1, 0x0, 0x4b, 0xc9, 0x48, 0xe0, 0x8a, 0x1a, 0x18, 0xd8, 0xb, 0x6c}} return a, nil } @@ -938,8 +938,14 @@ func AssetNames() []string { // _bindata is a table, holding each asset generator, mapped to its name. var _bindata = map[string]func() (*asset, error){ "burn_tokens.cdc": burn_tokensCdc, - "create_forwarder.cdc": create_forwarderCdc, - "generic_transfer.cdc": generic_transferCdc, + "generic_transfer_with_address.cdc": generic_transfer_with_addressCdc, + "generic_transfer_with_paths.cdc": generic_transfer_with_pathsCdc, + "metadata/scripts/get_token_metadata.cdc": metadataScriptsGet_token_metadataCdc, + "metadata/scripts/get_vault_data.cdc": metadataScriptsGet_vault_dataCdc, + "metadata/scripts/get_vault_display.cdc": metadataScriptsGet_vault_displayCdc, + "metadata/scripts/get_vault_supply_view.cdc": metadataScriptsGet_vault_supply_viewCdc, + "metadata/scripts/get_views.cdc": metadataScriptsGet_viewsCdc, + "metadata/setup_account_from_address.cdc": metadataSetup_account_from_addressCdc, "metadata/setup_account_from_vault_reference.cdc": metadataSetup_account_from_vault_referenceCdc, "mint_tokens.cdc": mint_tokensCdc, "privateForwarder/create_account_private_forwarder.cdc": privateforwarderCreate_account_private_forwarderCdc, @@ -949,29 +955,23 @@ var _bindata = map[string]func() (*asset, error){ "privateForwarder/transfer_private_many_accounts.cdc": privateforwarderTransfer_private_many_accountsCdc, "safe_generic_transfer.cdc": safe_generic_transferCdc, "scripts/get_balance.cdc": scriptsGet_balanceCdc, + "scripts/get_balance_generic.cdc": scriptsGet_balance_genericCdc, "scripts/get_supply.cdc": scriptsGet_supplyCdc, "scripts/get_supported_vault_types.cdc": scriptsGet_supported_vault_typesCdc, - "scripts/metadata/get_token_metadata.cdc": scriptsMetadataGet_token_metadataCdc, - "scripts/metadata/get_vault_data.cdc": scriptsMetadataGet_vault_dataCdc, - "scripts/metadata/get_vault_display.cdc": scriptsMetadataGet_vault_displayCdc, - "scripts/metadata/get_vault_supply_view.cdc": scriptsMetadataGet_vault_supply_viewCdc, - "scripts/switchboard/check_receiver_by_type.cdc": scriptsSwitchboardCheck_receiver_by_typeCdc, - "scripts/switchboard/get_vault_types.cdc": scriptsSwitchboardGet_vault_typesCdc, - "scripts/switchboard/get_vault_types_and_address.cdc": scriptsSwitchboardGet_vault_types_and_addressCdc, - "scripts/tokenForwarder/is_recipient_valid.cdc": scriptsTokenforwarderIs_recipient_validCdc, "setup_account.cdc": setup_accountCdc, "switchboard/add_vault_capability.cdc": switchboardAdd_vault_capabilityCdc, "switchboard/add_vault_wrapper_capability.cdc": switchboardAdd_vault_wrapper_capabilityCdc, "switchboard/batch_add_vault_capabilities.cdc": switchboardBatch_add_vault_capabilitiesCdc, "switchboard/batch_add_vault_wrapper_capabilities.cdc": switchboardBatch_add_vault_wrapper_capabilitiesCdc, "switchboard/remove_vault_capability.cdc": switchboardRemove_vault_capabilityCdc, - "switchboard/safe_deposit_to_lnf.cdc": switchboardSafe_deposit_to_lnfCdc, "switchboard/safe_transfer_tokens.cdc": switchboardSafe_transfer_tokensCdc, - "switchboard/safe_transfer_tokens_v2.cdc": switchboardSafe_transfer_tokens_v2Cdc, + "switchboard/scripts/get_vault_types_and_address.cdc": switchboardScriptsGet_vault_types_and_addressCdc, "switchboard/setup_account.cdc": switchboardSetup_accountCdc, "switchboard/setup_royalty_account.cdc": switchboardSetup_royalty_accountCdc, "switchboard/setup_royalty_account_by_paths.cdc": switchboardSetup_royalty_account_by_pathsCdc, "switchboard/transfer_tokens.cdc": switchboardTransfer_tokensCdc, + "tokenForwarder/create_forwarder.cdc": tokenforwarderCreate_forwarderCdc, + "tokenForwarder/scripts/is_recipient_valid.cdc": tokenforwarderScriptsIs_recipient_validCdc, "transfer_many_accounts.cdc": transfer_many_accountsCdc, "transfer_tokens.cdc": transfer_tokensCdc, } @@ -1021,9 +1021,17 @@ type bintree struct { var _bintree = &bintree{nil, map[string]*bintree{ "burn_tokens.cdc": {burn_tokensCdc, map[string]*bintree{}}, - "create_forwarder.cdc": {create_forwarderCdc, map[string]*bintree{}}, - "generic_transfer.cdc": {generic_transferCdc, map[string]*bintree{}}, + "generic_transfer_with_address.cdc": {generic_transfer_with_addressCdc, map[string]*bintree{}}, + "generic_transfer_with_paths.cdc": {generic_transfer_with_pathsCdc, map[string]*bintree{}}, "metadata": {nil, map[string]*bintree{ + "scripts": {nil, map[string]*bintree{ + "get_token_metadata.cdc": {metadataScriptsGet_token_metadataCdc, map[string]*bintree{}}, + "get_vault_data.cdc": {metadataScriptsGet_vault_dataCdc, map[string]*bintree{}}, + "get_vault_display.cdc": {metadataScriptsGet_vault_displayCdc, map[string]*bintree{}}, + "get_vault_supply_view.cdc": {metadataScriptsGet_vault_supply_viewCdc, map[string]*bintree{}}, + "get_views.cdc": {metadataScriptsGet_viewsCdc, map[string]*bintree{}}, + }}, + "setup_account_from_address.cdc": {metadataSetup_account_from_addressCdc, map[string]*bintree{}}, "setup_account_from_vault_reference.cdc": {metadataSetup_account_from_vault_referenceCdc, map[string]*bintree{}}, }}, "mint_tokens.cdc": {mint_tokensCdc, map[string]*bintree{}}, @@ -1037,22 +1045,9 @@ var _bintree = &bintree{nil, map[string]*bintree{ "safe_generic_transfer.cdc": {safe_generic_transferCdc, map[string]*bintree{}}, "scripts": {nil, map[string]*bintree{ "get_balance.cdc": {scriptsGet_balanceCdc, map[string]*bintree{}}, + "get_balance_generic.cdc": {scriptsGet_balance_genericCdc, map[string]*bintree{}}, "get_supply.cdc": {scriptsGet_supplyCdc, map[string]*bintree{}}, "get_supported_vault_types.cdc": {scriptsGet_supported_vault_typesCdc, map[string]*bintree{}}, - "metadata": {nil, map[string]*bintree{ - "get_token_metadata.cdc": {scriptsMetadataGet_token_metadataCdc, map[string]*bintree{}}, - "get_vault_data.cdc": {scriptsMetadataGet_vault_dataCdc, map[string]*bintree{}}, - "get_vault_display.cdc": {scriptsMetadataGet_vault_displayCdc, map[string]*bintree{}}, - "get_vault_supply_view.cdc": {scriptsMetadataGet_vault_supply_viewCdc, map[string]*bintree{}}, - }}, - "switchboard": {nil, map[string]*bintree{ - "check_receiver_by_type.cdc": {scriptsSwitchboardCheck_receiver_by_typeCdc, map[string]*bintree{}}, - "get_vault_types.cdc": {scriptsSwitchboardGet_vault_typesCdc, map[string]*bintree{}}, - "get_vault_types_and_address.cdc": {scriptsSwitchboardGet_vault_types_and_addressCdc, map[string]*bintree{}}, - }}, - "tokenForwarder": {nil, map[string]*bintree{ - "is_recipient_valid.cdc": {scriptsTokenforwarderIs_recipient_validCdc, map[string]*bintree{}}, - }}, }}, "setup_account.cdc": {setup_accountCdc, map[string]*bintree{}}, "switchboard": {nil, map[string]*bintree{ @@ -1061,14 +1056,21 @@ var _bintree = &bintree{nil, map[string]*bintree{ "batch_add_vault_capabilities.cdc": {switchboardBatch_add_vault_capabilitiesCdc, map[string]*bintree{}}, "batch_add_vault_wrapper_capabilities.cdc": {switchboardBatch_add_vault_wrapper_capabilitiesCdc, map[string]*bintree{}}, "remove_vault_capability.cdc": {switchboardRemove_vault_capabilityCdc, map[string]*bintree{}}, - "safe_deposit_to_lnf.cdc": {switchboardSafe_deposit_to_lnfCdc, map[string]*bintree{}}, "safe_transfer_tokens.cdc": {switchboardSafe_transfer_tokensCdc, map[string]*bintree{}}, - "safe_transfer_tokens_v2.cdc": {switchboardSafe_transfer_tokens_v2Cdc, map[string]*bintree{}}, + "scripts": {nil, map[string]*bintree{ + "get_vault_types_and_address.cdc": {switchboardScriptsGet_vault_types_and_addressCdc, map[string]*bintree{}}, + }}, "setup_account.cdc": {switchboardSetup_accountCdc, map[string]*bintree{}}, "setup_royalty_account.cdc": {switchboardSetup_royalty_accountCdc, map[string]*bintree{}}, "setup_royalty_account_by_paths.cdc": {switchboardSetup_royalty_account_by_pathsCdc, map[string]*bintree{}}, "transfer_tokens.cdc": {switchboardTransfer_tokensCdc, map[string]*bintree{}}, }}, + "tokenForwarder": {nil, map[string]*bintree{ + "create_forwarder.cdc": {tokenforwarderCreate_forwarderCdc, map[string]*bintree{}}, + "scripts": {nil, map[string]*bintree{ + "is_recipient_valid.cdc": {tokenforwarderScriptsIs_recipient_validCdc, map[string]*bintree{}}, + }}, + }}, "transfer_many_accounts.cdc": {transfer_many_accountsCdc, map[string]*bintree{}}, "transfer_tokens.cdc": {transfer_tokensCdc, map[string]*bintree{}}, }} diff --git a/lib/go/templates/script_templates.go b/lib/go/templates/script_templates.go index 319b4910..9b2dd29f 100644 --- a/lib/go/templates/script_templates.go +++ b/lib/go/templates/script_templates.go @@ -2,40 +2,39 @@ package templates import ( "github.com/onflow/flow-ft/lib/go/templates/internal/assets" - "github.com/onflow/flow-go-sdk" ) const ( scriptsPath = "scripts/" readBalanceFilename = "get_balance.cdc" readSupplyFilename = "get_supply.cdc" - readSupplyViewFilename = "metadata/get_vault_supply_view.cdc" + readSupplyViewFilename = "metadata/scripts/get_vault_supply_view.cdc" ) // GenerateInspectVaultScript creates a script that retrieves a // Vault from the array in storage and makes assertions about // its balance. If these assertions fail, the script panics. -func GenerateInspectVaultScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateInspectVaultScript(env Environment) []byte { code := assets.MustAssetString(scriptsPath + readBalanceFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } // GenerateInspectSupplyScript creates a script that reads // the total supply of tokens in existence // and makes assertions about the number -func GenerateInspectSupplyScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateInspectSupplyScript(env Environment) []byte { code := assets.MustAssetString(scriptsPath + readSupplyFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } // GenerateInspectSupplyViewScript creates a script that reads // the total supply of tokens in existence through a metadata view -func GenerateInspectSupplyViewScript(fungibleAddr, tokenAddr, metadataViewsAddr, ftMetadataViewsAddr flow.Address, tokenName string) []byte { +func GenerateInspectSupplyViewScript(env Environment) []byte { - code := assets.MustAssetString(scriptsPath + readSupplyViewFilename) + code := assets.MustAssetString(readSupplyViewFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, metadataViewsAddr, ftMetadataViewsAddr, tokenName) + return []byte(ReplaceAddresses(code, env)) } diff --git a/lib/go/templates/templates.go b/lib/go/templates/templates.go index c37cc77d..233ea6e4 100644 --- a/lib/go/templates/templates.go +++ b/lib/go/templates/templates.go @@ -4,10 +4,9 @@ package templates import ( "bytes" + "fmt" "regexp" "strings" - - "github.com/onflow/flow-go-sdk" ) var ( @@ -16,25 +15,112 @@ var ( ) var ( - placeholderFungibleToken = regexp.MustCompile(`"FungibleToken"`) - placeholderExampleToken = regexp.MustCompile(`"ExampleToken"`) - placeholderForwarding = regexp.MustCompile(`"TokenForwarding"`) - placeholderMetadataViews = regexp.MustCompile(`"MetadataViews"`) - placeholderFTMetadataViews = regexp.MustCompile(`"FungibleTokenMetadataViews"`) + placeholderFungibleToken = "\"FungibleToken\"" + placeholderExampleToken = "\"ExampleToken\"" + placeholderForwarding = "\"TokenForwarding\"" + placeholderPrivateForwardAddr = "\"PrivateReceiverForwarder\"" + placeholderSwitchboard = "\"FungibleTokenSwitchboard\"" + placeholderMetadataViews = "\"MetadataViews\"" + placeholderFTMetadataViews = "\"FungibleTokenMetadataViews\"" + placeholderViewResolver = "\"ViewResolver\"" + placeholderBurner = "\"Burner\"" + exampleTokenImport = "ExampleToken from " + metadataViewsImport = "MetadataViews from " + ftMetadataViewsImport = "FungibleTokenMetadataViews from " + burnerImport = "Burner from " + fungibleTokenImport = "FungibleToken from " + viewResolverImport = "ViewResolver from " + switchboardImport = "FungibleTokenSwitchboard from " + forwardingImport = "TokenForwarding from " + privateForwardingImport = "PrivateReceiverForwarder from " ) -func replaceAddresses(code string, ftAddress, tokenAddress, forwardingAddress, metadataViewsAddress, ftMetadataViewsAddr flow.Address, tokenName string) []byte { - code = placeholderFungibleToken.ReplaceAllString(code, "0x"+ftAddress.String()) - code = placeholderExampleToken.ReplaceAllString(code, "0x"+tokenAddress.String()) - code = placeholderForwarding.ReplaceAllString(code, "0x"+forwardingAddress.String()) - code = placeholderMetadataViews.ReplaceAllString(code, "0x"+metadataViewsAddress.String()) - code = placeholderFTMetadataViews.ReplaceAllString(code, "0x"+ftMetadataViewsAddr.String()) +type Environment struct { + Network string + FungibleTokenAddress string + ExampleTokenAddress string + TokenForwardingAddress string + PrivateForwardingAddress string + MetadataViewsAddress string + FungibleTokenMetadataViewsAddress string + ViewResolverAddress string + BurnerAddress string + SwitchboardAddress string +} + +func withHexPrefix(address string) string { + if address == "" { + return "" + } + + if address[0:2] == "0x" { + return address + } + + return fmt.Sprintf("0x%s", address) +} + +func ReplaceAddresses(code string, env Environment) string { + + code = strings.ReplaceAll( + code, + placeholderFungibleToken, + fungibleTokenImport+withHexPrefix(env.FungibleTokenAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderExampleToken, + exampleTokenImport+withHexPrefix(env.ExampleTokenAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderForwarding, + forwardingImport+withHexPrefix(env.TokenForwardingAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderPrivateForwardAddr, + privateForwardingImport+withHexPrefix(env.PrivateForwardingAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderMetadataViews, + metadataViewsImport+withHexPrefix(env.MetadataViewsAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderFTMetadataViews, + ftMetadataViewsImport+withHexPrefix(env.FungibleTokenMetadataViewsAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderViewResolver, + viewResolverImport+withHexPrefix(env.ViewResolverAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderBurner, + burnerImport+withHexPrefix(env.BurnerAddress), + ) + + code = strings.ReplaceAll( + code, + placeholderSwitchboard, + switchboardImport+withHexPrefix(env.SwitchboardAddress), + ) - storageName := MakeFirstLowerCase(tokenName) - code = defaultTokenName.ReplaceAllString(code, tokenName) - code = defaultTokenStorage.ReplaceAllString(code, storageName) + // storageName := MakeFirstLowerCase(tokenName) + // code = defaultTokenName.ReplaceAllString(code, tokenName) + // code = defaultTokenStorage.ReplaceAllString(code, storageName) - return []byte(code) + return code } // MakeFirstLowerCase makes the first letter in a string lowercase diff --git a/lib/go/templates/transaction_templates.go b/lib/go/templates/transaction_templates.go index cd77479f..2198ca92 100644 --- a/lib/go/templates/transaction_templates.go +++ b/lib/go/templates/transaction_templates.go @@ -3,142 +3,134 @@ package templates //go:generate go run github.com/kevinburke/go-bindata/go-bindata -prefix ../../../transactions -o internal/assets/assets.go -pkg assets -nometadata -nomemcopy ../../../transactions/... import ( - "fmt" - - "github.com/onflow/flow-go-sdk" - _ "github.com/kevinburke/go-bindata" + "strings" + "github.com/onflow/flow-ft/lib/go/templates/internal/assets" ) const ( - transferTokensFilename = "transfer_tokens.cdc" - genericTransferFilename = "generic_transfer.cdc" - transferManyAccountsFilename = "transfer_many_accounts.cdc" - setupAccountFilename = "setup_account.cdc" - mintTokensFilename = "mint_tokens.cdc" - createForwarderFilename = "create_forwarder.cdc" - burnTokensFilename = "burn_tokens.cdc" + transferTokensFilename = "transfer_tokens.cdc" + genericTransferWithPathsFilename = "generic_transfer_with_paths.cdc" + genericTransferWithAddressFilename = "generic_transfer_with_address.cdc" + transferManyAccountsFilename = "transfer_many_accounts.cdc" + setupAccountFilename = "setup_account.cdc" + setupGenericVaultFilename = "metadata/setup_account_from_address.cdc" + mintTokensFilename = "mint_tokens.cdc" + createForwarderFilename = "tokenForwarder/create_forwarder.cdc" + burnTokensFilename = "burn_tokens.cdc" ) // GenerateCreateTokenScript creates a script that instantiates // a new Vault instance and stores it in storage. // balance is an argument to the Vault constructor. // The Vault must have been deployed already. -func GenerateCreateTokenScript(fungibleAddr, tokenAddr, metadataViewsAddr flow.Address, tokenName string) []byte { +func GenerateCreateTokenScript(env Environment) []byte { code := assets.MustAssetString(setupAccountFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, metadataViewsAddr, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } -// GenerateDestroyVaultScript creates a script that withdraws -// tokens from a vault and destroys the tokens -func GenerateDestroyVaultScript(fungibleAddr, tokenAddr flow.Address, tokenName string, withdrawAmount int) []byte { - storageName := MakeFirstLowerCase(tokenName) +// GenerateSetupGenericVaultScript creates a script that instantiates +// a new Vault instance and stores it in storage. It can be used +// to create any token as long as you know the address of the contract +// and the name of the contract +func GenerateSetupAccountFromAddressScript(fungibleTokenAddr, fungibleTokenMVAddr string) []byte { - template := ` - import FungibleToken from 0x%[1]s - import %[3]s from 0x%[2]s + code := assets.MustAssetString(setupGenericVaultFilename) - transaction { - prepare(acct: AuthAccount) { - let vault <- acct.load<@%[3]s.Vault>(from: /storage/%[4]sVault) - ?? panic("Couldn't load Vault from storage") - - let withdrawVault <- vault.withdraw(amount: %[5]d.0) + code = strings.ReplaceAll( + code, + placeholderFungibleToken, + fungibleTokenImport+withHexPrefix(fungibleTokenAddr), + ) - acct.save(<-vault, to: /storage/%[4]sVault) + code = strings.ReplaceAll( + code, + placeholderFTMetadataViews, + ftMetadataViewsImport+withHexPrefix(fungibleTokenMVAddr), + ) - destroy withdrawVault - } - } - ` - - return []byte(fmt.Sprintf(template, fungibleAddr, tokenAddr, tokenName, storageName, withdrawAmount)) + return []byte(code) } // GenerateTransferVaultScript creates a script that withdraws an tokens from an account // and deposits it to another account's vault -func GenerateTransferVaultScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateTransferVaultScript(env Environment) []byte { code := assets.MustAssetString(transferTokensFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } -// GenerateTransferGenericVaultScript creates a script that withdraws an tokens from an account -// and deposits it to another account's vault for any vault type -func GenerateTransferGenericVaultScript(fungibleAddr flow.Address) []byte { +// GenerateTransferGenericVaultWithPathsScript creates a script that withdraws an tokens from an account +// and deposits it to another account's vault for any vault type using paths as arguments +func GenerateTransferGenericVaultWithPathsScript(fungibleTokenAddr string) []byte { + + code := assets.MustAssetString(genericTransferWithPathsFilename) + + code = strings.ReplaceAll( + code, + placeholderFungibleToken, + fungibleTokenImport+withHexPrefix(fungibleTokenAddr), + ) + + return []byte(code) +} + +// GenerateTransferGenericVaultWithAddressScript creates a script that withdraws an tokens from an account +// and deposits it to another account's vault for any vault type using the contract's address and name as arguments +func GenerateTransferGenericVaultWithAddressScript(fungibleTokenAddr, ftMetadataViewsAddr string) []byte { + + code := assets.MustAssetString(genericTransferWithAddressFilename) + + code = strings.ReplaceAll( + code, + placeholderFungibleToken, + fungibleTokenImport+withHexPrefix(fungibleTokenAddr), + ) - code := assets.MustAssetString(genericTransferFilename) + code = strings.ReplaceAll( + code, + placeholderFTMetadataViews, + ftMetadataViewsImport+withHexPrefix(ftMetadataViewsAddr), + ) - return replaceAddresses(code, fungibleAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, "") + return []byte(code) } // GenerateTransferManyAccountsScript creates a script that transfers the same number of tokens // to a list of accounts -func GenerateTransferManyAccountsScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateTransferManyAccountsScript(env Environment) []byte { code := assets.MustAssetString(transferManyAccountsFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } // GenerateMintTokensScript creates a script that uses the admin resource // to mint new tokens and deposit them in a Vault -func GenerateMintTokensScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateMintTokensScript(env Environment) []byte { code := assets.MustAssetString(mintTokensFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } // GenerateBurnTokensScript creates a script that uses the admin resource // to destroy tokens and deposit them in a Vault -func GenerateBurnTokensScript(fungibleAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateBurnTokensScript(env Environment) []byte { code := assets.MustAssetString(burnTokensFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, flow.EmptyAddress, flow.EmptyAddress, flow.EmptyAddress, tokenName) -} - -// GenerateTransferInvalidVaultScript creates a script that withdraws an tokens from an account -// and tries to deposit it into a vault of the wrong type. Should fail -func GenerateTransferInvalidVaultScript(fungibleAddr, tokenAddr, otherTokenAddr, receiverAddr flow.Address, tokenName, otherTokenName string, amount int) []byte { - storageName := MakeFirstLowerCase(tokenName) - - otherStorageName := MakeFirstLowerCase(otherTokenName) - - template := ` - import FungibleToken from 0x%s - import %s from 0x%s - import %s from 0x%s - - transaction { - prepare(acct: AuthAccount) { - let recipient = getAccount(0x%s) - - let providerRef = acct.borrow<&{FungibleToken.Provider}>(from: /storage/%sVault) - ?? panic("Could not borrow Provider reference to the Vault!") - - let receiverRef = recipient.getCapability(/public/%sReceiver)!.borrow<&{FungibleToken.Receiver}>() - ?? panic("Could not borrow receiver reference to the recipient's Vault") - - let tokens <- providerRef.withdraw(amount: %d.0) - - receiverRef.deposit(from: <-tokens) - } - } - ` - - return []byte(fmt.Sprintf(template, fungibleAddr, tokenName, tokenAddr, otherTokenName, otherTokenAddr, receiverAddr, storageName, otherStorageName, amount)) + return []byte(ReplaceAddresses(code, env)) } // GenerateCreateForwarderScript creates a script that instantiates // a new forwarder instance in an account -func GenerateCreateForwarderScript(fungibleAddr, forwardingAddr, tokenAddr flow.Address, tokenName string) []byte { +func GenerateCreateForwarderScript(env Environment) []byte { code := assets.MustAssetString(createForwarderFilename) - return replaceAddresses(code, fungibleAddr, tokenAddr, forwardingAddr, flow.EmptyAddress, flow.EmptyAddress, tokenName) + return []byte(ReplaceAddresses(code, env)) } diff --git a/lib/go/test/forwarding_test.go b/lib/go/test/forwarding_test.go deleted file mode 100644 index 2b85a279..00000000 --- a/lib/go/test/forwarding_test.go +++ /dev/null @@ -1,229 +0,0 @@ -package test - -import ( - "context" - "testing" - - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" - - "github.com/onflow/cadence" - jsoncdc "github.com/onflow/cadence/encoding/json" - "github.com/onflow/cadence/runtime/common" - "github.com/onflow/flow-go-sdk" - "github.com/onflow/flow-go-sdk/crypto" - - "github.com/onflow/flow-ft/lib/go/contracts" - "github.com/onflow/flow-ft/lib/go/templates" -) - -func TestPrivateForwarder(t *testing.T) { - b, adapter, accountKeys := newTestSetup(t) - - serviceSigner, _ := b.ServiceKey().Signer() - - exampleTokenAccountKey, exampleTokenSigner := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, _, _, _ := - DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) - - forwardingCode := contracts.PrivateReceiverForwarder(fungibleAddr.String()) - cadenceCode := bytesToCadenceArray(forwardingCode) - - name, _ := cadence.NewString("PrivateReceiverForwarder") - - tx := flow.NewTransaction(). - SetScript(templates.GenerateDeployPrivateForwardingScript()). - SetGasLimit(100). - SetProposalKey(b.ServiceKey().Address, b.ServiceKey().Index, b.ServiceKey().SequenceNumber). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(exampleTokenAddr). - AddRawArgument(jsoncdc.MustEncode(name)). - AddRawArgument(jsoncdc.MustEncode(cadenceCode)) - - _ = tx.AddArgument(cadence.Path{Domain: common.PathDomainStorage, Identifier: "privateForwardingSender"}) - _ = tx.AddArgument(cadence.Path{Domain: common.PathDomainStorage, Identifier: "privateForwardingStorage"}) - _ = tx.AddArgument(cadence.Path{Domain: common.PathDomainPublic, Identifier: "privateForwardingPublic"}) - - signAndSubmit( - t, b, tx, - []flow.Address{b.ServiceKey().Address, exampleTokenAddr}, - []crypto.Signer{serviceSigner, exampleTokenSigner}, - false, - ) - - joshAccountKey, joshSigner := accountKeys.NewWithSigner() - joshAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{joshAccountKey}, nil) - - t.Run("Should be able to set up an account to accept private deposits", func(t *testing.T) { - - script := templates.GenerateSetupAccountPrivateForwarderScript( - fungibleAddr, - exampleTokenAddr, - exampleTokenAddr, - "ExampleToken", - ) - - tx := flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, - ) - }) - - t.Run("Should be able to transfer private tokens to an account", func(t *testing.T) { - - recipient1Address := cadence.Address(joshAddress) - recipient1Amount := CadenceUFix64("300.0") - - pair := cadence.KeyValuePair{Key: recipient1Address, Value: recipient1Amount} - recipientPairs := make([]cadence.KeyValuePair, 1) - recipientPairs[0] = pair - - script := templates.GenerateTransferPrivateManyAccountsScript(fungibleAddr, exampleTokenAddr, exampleTokenAddr, "ExampleToken") - tx = flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(exampleTokenAddr) - - _ = tx.AddArgument(cadence.NewDictionary(recipientPairs)) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - exampleTokenAddr, - }, - []crypto.Signer{ - serviceSigner, - exampleTokenSigner, - }, - false, - ) - - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result, err := b.ExecuteScript( - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), - }, - ) - require.NoError(t, err) - if !assert.True(t, result.Succeeded()) { - t.Log(result.Error.Error()) - } - balance := result.Value - assertEqual(t, CadenceUFix64("700.0"), balance) - - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result, err = b.ExecuteScript( - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(joshAddress)), - }, - ) - require.NoError(t, err) - if !assert.True(t, result.Succeeded()) { - t.Log(result.Error.Error()) - } - balance = result.Value - assertEqual(t, CadenceUFix64("300.0"), balance) - - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assertEqual(t, CadenceUFix64("1000.0"), supply) - }) - - t.Run("Should be able to create a new account with private forwarder", func(t *testing.T) { - - script := templates.GenerateCreateAccountPrivateForwarderScript( - fungibleAddr, - exampleTokenAddr, - exampleTokenAddr, - "ExampleToken", - ) - tx = flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(exampleTokenAddr) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - exampleTokenAddr, - }, - []crypto.Signer{ - serviceSigner, - exampleTokenSigner, - }, - false, - ) - - }) - - t.Run("Should be able to do account setup a second time without change", func(t *testing.T) { - - script := templates.GenerateSetupAccountPrivateForwarderScript( - fungibleAddr, - exampleTokenAddr, - exampleTokenAddr, - "ExampleToken", - ) - - // send the same transaction one more time for the same address that's already set up - tx := flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, - ) - }) -} diff --git a/lib/go/test/go.mod b/lib/go/test/go.mod index c2e6af1a..9b9c578b 100644 --- a/lib/go/test/go.mod +++ b/lib/go/test/go.mod @@ -3,159 +3,205 @@ module github.com/onflow/flow-ft/lib/go/test go 1.18 require ( - github.com/onflow/cadence v0.39.12 - github.com/onflow/flow-emulator v0.51.2-0.20230704183611-ecad54e231b7 - github.com/onflow/flow-ft/lib/go/contracts v0.7.0 - github.com/onflow/flow-ft/lib/go/templates v0.0.0-00010101000000-000000000000 - github.com/onflow/flow-go-sdk v0.41.6 - github.com/onflow/flow-nft/lib/go/contracts v1.1.0 + github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 + github.com/onflow/cadence v1.0.0-preview.25 + github.com/onflow/flow-emulator v1.0.0-preview.22 + github.com/onflow/flow-ft/lib/go/contracts v0.7.1-0.20240424211859-3ff4c0fe2a1e + github.com/onflow/flow-ft/lib/go/templates v0.7.1-0.20240424211859-3ff4c0fe2a1e + github.com/onflow/flow-go-sdk v1.0.0-preview.25 + github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240429184308-40c3de711140 github.com/rs/zerolog v1.29.0 - github.com/stretchr/testify v1.8.4 + github.com/stretchr/testify v1.9.0 ) require ( + github.com/DataDog/zstd v1.5.2 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/SaveTheRbtz/mph v0.1.1-0.20240117162131-4166ec7869bc // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/VictoriaMetrics/fastcache v1.12.1 // indirect github.com/beorn7/perks v1.0.1 // indirect - github.com/bits-and-blooms/bitset v1.7.0 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect github.com/btcsuite/btcd/btcec/v2 v2.2.1 // indirect - github.com/cenkalti/backoff/v4 v4.2.0 // indirect + github.com/cenkalti/backoff/v4 v4.2.1 // indirect github.com/cespare/xxhash v1.1.0 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/cockroachdb/errors v1.9.1 // indirect + github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect + github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 // indirect + github.com/cockroachdb/redact v1.1.3 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect github.com/coreos/go-semver v0.3.0 // indirect + github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect + github.com/deckarep/golang-set/v2 v2.1.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect github.com/dgraph-io/badger/v2 v2.2007.4 // indirect github.com/dgraph-io/ristretto v0.1.0 // indirect github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/ef-ds/deque v1.0.4 // indirect - github.com/ethereum/go-ethereum v1.12.1 // indirect + github.com/ethereum/c-kzg-4844 v0.4.0 // indirect + github.com/ethereum/go-ethereum v1.13.10 // indirect github.com/fsnotify/fsnotify v1.6.0 // indirect github.com/fxamacker/cbor/v2 v2.4.1-0.20230228173756-c0c9f774e40c // indirect github.com/fxamacker/circlehash v0.3.0 // indirect - github.com/glebarez/go-sqlite v1.21.1 // indirect - github.com/go-logr/logr v1.2.3 // indirect + github.com/getsentry/sentry-go v0.18.0 // indirect + github.com/glebarez/go-sqlite v1.22.0 // indirect + github.com/go-logr/logr v1.4.1 // indirect github.com/go-logr/stdr v1.2.2 // indirect + github.com/go-ole/go-ole v1.2.6 // indirect github.com/go-redis/redis/v8 v8.11.5 // indirect - github.com/go-test/deep v1.1.0 // indirect + github.com/go-stack/stack v1.8.1 // indirect + github.com/gofrs/flock v0.8.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/glog v1.1.0 // indirect - github.com/golang/protobuf v1.5.3 // indirect + github.com/golang/glog v1.2.0 // indirect + github.com/golang/protobuf v1.5.4 // indirect github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect - github.com/google/uuid v1.3.0 // indirect - github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3 // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/websocket v1.5.0 // indirect + github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 // indirect github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect - github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect + github.com/hashicorp/golang-lru v1.0.2 // indirect + github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/hashicorp/hcl v1.0.0 // indirect - github.com/holiman/uint256 v1.2.3 // indirect + github.com/holiman/bloomfilter/v2 v2.0.3 // indirect + github.com/holiman/uint256 v1.2.4 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/ipfs/bbloom v0.0.4 // indirect - github.com/ipfs/go-block-format v0.0.3 // indirect - github.com/ipfs/go-cid v0.3.2 // indirect + github.com/ipfs/boxo v0.17.1-0.20240131173518-89bceff34bf1 // indirect + github.com/ipfs/go-block-format v0.2.0 // indirect + github.com/ipfs/go-cid v0.4.1 // indirect github.com/ipfs/go-datastore v0.6.0 // indirect - github.com/ipfs/go-ipfs-blockstore v1.2.0 // indirect + github.com/ipfs/go-ipfs-blockstore v1.3.0 // indirect github.com/ipfs/go-ipfs-ds-help v1.1.0 // indirect - github.com/ipfs/go-ipfs-util v0.0.2 // indirect - github.com/ipfs/go-ipld-format v0.3.0 // indirect + github.com/ipfs/go-ipfs-util v0.0.3 // indirect + github.com/ipfs/go-ipld-format v0.6.0 // indirect github.com/ipfs/go-log v1.0.5 // indirect github.com/ipfs/go-log/v2 v2.5.1 // indirect github.com/ipfs/go-metrics-interface v0.0.1 // indirect github.com/jbenet/goprocess v0.1.4 // indirect - github.com/kevinburke/go-bindata v3.23.0+incompatible // indirect - github.com/klauspost/compress v1.15.15 // indirect - github.com/klauspost/cpuid/v2 v2.2.4 // indirect + github.com/k0kubun/pp v3.0.1+incompatible // indirect + github.com/kevinburke/go-bindata v3.24.0+incompatible // indirect + github.com/klauspost/compress v1.17.4 // indirect + github.com/klauspost/cpuid/v2 v2.2.6 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/kr/text v0.2.0 // indirect github.com/libp2p/go-buffer-pool v0.1.0 // indirect - github.com/libp2p/go-libp2p v0.24.2 // indirect - github.com/libp2p/go-openssl v0.1.0 // indirect + github.com/libp2p/go-libp2p v0.32.2 // indirect github.com/logrusorgru/aurora v2.0.3+incompatible // indirect github.com/logrusorgru/aurora/v4 v4.0.0 // indirect github.com/magiconair/properties v1.8.7 // indirect github.com/mattn/go-colorable v0.1.13 // indirect - github.com/mattn/go-isatty v0.0.18 // indirect - github.com/mattn/go-pointer v0.0.1 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.15 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect - github.com/minio/sha256-simd v1.0.0 // indirect + github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect + github.com/minio/sha256-simd v1.0.1 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/mr-tron/base58 v1.2.0 // indirect github.com/multiformats/go-base32 v0.1.0 // indirect github.com/multiformats/go-base36 v0.2.0 // indirect - github.com/multiformats/go-multiaddr v0.8.0 // indirect - github.com/multiformats/go-multibase v0.1.1 // indirect - github.com/multiformats/go-multicodec v0.7.0 // indirect - github.com/multiformats/go-multihash v0.2.1 // indirect + github.com/multiformats/go-multiaddr v0.12.2 // indirect + github.com/multiformats/go-multibase v0.2.0 // indirect + github.com/multiformats/go-multicodec v0.9.0 // indirect + github.com/multiformats/go-multihash v0.2.3 // indirect + github.com/multiformats/go-multistream v0.5.0 // indirect github.com/multiformats/go-varint v0.0.7 // indirect - github.com/onflow/atree v0.6.0 // indirect - github.com/onflow/flow-core-contracts/lib/go/contracts v1.2.4-0.20230703193002-53362441b57d // indirect - github.com/onflow/flow-core-contracts/lib/go/templates v1.2.3 // indirect - github.com/onflow/flow-go v0.31.1-0.20230704154018-87a84e9d36c2 // indirect - github.com/onflow/flow-go/crypto v0.24.7 // indirect - github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20230602212908-08fc6536d391 // indirect - github.com/onflow/fusd/lib/go/contracts v0.0.0-20211021081023-ae9de8fb2c7e // indirect - github.com/onflow/nft-storefront/lib/go/contracts v0.0.0-20221222181731-14b90207cead // indirect - github.com/onflow/sdks v0.5.0 // indirect + github.com/olekukonko/tablewriter v0.0.5 // indirect + github.com/onflow/atree v0.7.0-rc.1 // indirect + github.com/onflow/crypto v0.25.1 // indirect + github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240429192223-e696a8e439b5 // indirect + github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240429192223-e696a8e439b5 // indirect + github.com/onflow/flow-go v0.34.0-crescendo-preview.18 // indirect + github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240429184308-40c3de711140 // indirect + github.com/onflow/flow/protobuf/go/flow v0.4.1-0.20240412170550-911321113030 // indirect + github.com/onflow/go-ethereum v1.13.4 // indirect + github.com/onflow/sdks v0.5.1-0.20230912225508-b35402f12bba // indirect github.com/opentracing/opentracing-go v1.2.0 // indirect github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect github.com/pelletier/go-toml/v2 v2.0.6 // indirect github.com/pierrec/lz4 v2.6.1+incompatible // indirect github.com/pkg/errors v0.9.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/prometheus/client_golang v1.14.0 // indirect - github.com/prometheus/client_model v0.3.0 // indirect - github.com/prometheus/common v0.39.0 // indirect - github.com/prometheus/procfs v0.9.0 // indirect + github.com/prometheus/client_golang v1.18.0 // indirect + github.com/prometheus/client_model v0.5.0 // indirect + github.com/prometheus/common v0.45.0 // indirect + github.com/prometheus/procfs v0.12.0 // indirect github.com/psiemens/graceland v1.0.0 // indirect github.com/psiemens/sconfig v0.1.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rivo/uniseg v0.4.4 // indirect + github.com/rogpeppe/go-internal v1.10.0 // indirect github.com/sethvargo/go-retry v0.2.3 // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect github.com/slok/go-http-metrics v0.10.0 // indirect - github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect - github.com/spf13/afero v1.9.3 // indirect + github.com/spf13/afero v1.10.0 // indirect github.com/spf13/cast v1.5.0 // indirect - github.com/spf13/cobra v1.7.0 // indirect + github.com/spf13/cobra v1.8.0 // indirect github.com/spf13/jwalterweatherman v1.1.0 // indirect github.com/spf13/pflag v1.0.5 // indirect github.com/spf13/viper v1.15.0 // indirect + github.com/stretchr/objx v0.5.2 // indirect github.com/subosito/gotenv v1.4.2 // indirect + github.com/supranational/blst v0.3.11 // indirect + github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect github.com/texttheater/golang-levenshtein/levenshtein v0.0.0-20200805054039-cae8b0eaed6c // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect github.com/turbolent/prettier v0.0.0-20220320183459-661cc755135d // indirect github.com/vmihailenco/msgpack v4.0.4+incompatible // indirect github.com/vmihailenco/msgpack/v4 v4.3.11 // indirect github.com/vmihailenco/tagparser v0.1.1 // indirect github.com/x448/float16 v0.8.4 // indirect github.com/zeebo/blake3 v0.2.3 // indirect - go.opentelemetry.io/otel v1.14.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.14.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.14.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.14.0 // indirect - go.opentelemetry.io/otel/sdk v1.14.0 // indirect - go.opentelemetry.io/otel/trace v1.14.0 // indirect - go.opentelemetry.io/proto/otlp v0.19.0 // indirect - go.uber.org/atomic v1.10.0 // indirect - go.uber.org/multierr v1.9.0 // indirect - go.uber.org/zap v1.24.0 // indirect - golang.org/x/crypto v0.17.0 // indirect - golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc // indirect - golang.org/x/net v0.17.0 // indirect - golang.org/x/sync v0.3.0 // indirect - golang.org/x/sys v0.15.0 // indirect + go.opentelemetry.io/otel v1.24.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 // indirect + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 // indirect + go.opentelemetry.io/otel/metric v1.24.0 // indirect + go.opentelemetry.io/otel/sdk v1.24.0 // indirect + go.opentelemetry.io/otel/trace v1.24.0 // indirect + go.opentelemetry.io/proto/otlp v1.0.0 // indirect + go.uber.org/atomic v1.11.0 // indirect + go.uber.org/multierr v1.11.0 // indirect + go.uber.org/zap v1.26.0 // indirect + golang.org/x/crypto v0.19.0 // indirect + golang.org/x/exp v0.0.0-20240119083558-1b970713d09a // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/net v0.21.0 // indirect + golang.org/x/sync v0.6.0 // indirect + golang.org/x/sys v0.17.0 // indirect golang.org/x/text v0.14.0 // indirect - golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect - google.golang.org/appengine v1.6.7 // indirect - google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect - google.golang.org/grpc v1.56.1 // indirect - google.golang.org/protobuf v1.30.0 // indirect + golang.org/x/time v0.5.0 // indirect + golang.org/x/tools v0.17.0 // indirect + golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect + gonum.org/v1/gonum v0.14.0 // indirect + google.golang.org/appengine v1.6.8 // indirect + google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20240227224415-6ceb2ff114de // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de // indirect + google.golang.org/grpc v1.63.2 // indirect + google.golang.org/protobuf v1.33.0 // indirect gopkg.in/ini.v1 v1.67.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - lukechampine.com/blake3 v1.1.7 // indirect - modernc.org/libc v1.22.3 // indirect - modernc.org/mathutil v1.5.0 // indirect - modernc.org/memory v1.5.0 // indirect - modernc.org/sqlite v1.21.1 // indirect + lukechampine.com/blake3 v1.2.1 // indirect + modernc.org/libc v1.37.6 // indirect + modernc.org/mathutil v1.6.0 // indirect + modernc.org/memory v1.7.2 // indirect + modernc.org/sqlite v1.28.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect ) +// replace github.com/onflow/flow-nft/lib/go/contracts => ../../../../flow/flow-nft/lib/go/contracts + replace github.com/onflow/flow-ft/lib/go/contracts => ../contracts replace github.com/onflow/flow-ft/lib/go/templates => ../templates diff --git a/lib/go/test/go.sum b/lib/go/test/go.sum index 9dbc60a1..751aad21 100644 --- a/lib/go/test/go.sum +++ b/lib/go/test/go.sum @@ -1,12 +1,15 @@ +cloud.google.com/go v0.0.0-20170206221025-ce650573d812/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.43.0/go.mod h1:BOSR3VbTLkk6FDC/TcffxP4NF/FFBGA5ku+jvKOP7pg= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw= cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= @@ -27,99 +30,1095 @@ cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aD cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go v0.110.0/go.mod h1:SJnCLqQ0FCFGSZMUNUf84MV3Aia54kn7pi8st7tMzaY= +cloud.google.com/go v0.110.2/go.mod h1:k04UEeEtb6ZBRTv3dZz4CeJC3jKGxyhl0sAiVVquxiw= +cloud.google.com/go v0.110.4/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= +cloud.google.com/go v0.110.6/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= +cloud.google.com/go v0.110.7/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI= +cloud.google.com/go v0.110.8/go.mod h1:Iz8AkXJf1qmxC3Oxoep8R1T36w8B92yU29PcBhHO5fk= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accessapproval v1.6.0/go.mod h1:R0EiYnwV5fsRFiKZkPHr6mwyk2wxUJ30nL4j2pcFY2E= +cloud.google.com/go/accessapproval v1.7.1/go.mod h1:JYczztsHRMK7NTXb6Xw+dwbs/WnOJxbo/2mTI+Kgg68= +cloud.google.com/go/accessapproval v1.7.2/go.mod h1:/gShiq9/kK/h8T/eEn1BTzalDvk0mZxJlhfw0p+Xuc0= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/accesscontextmanager v1.6.0/go.mod h1:8XCvZWfYw3K/ji0iVnp+6pu7huxoQTLmxAbVjbloTtM= +cloud.google.com/go/accesscontextmanager v1.7.0/go.mod h1:CEGLewx8dwa33aDAZQujl7Dx+uYhS0eay198wB/VumQ= +cloud.google.com/go/accesscontextmanager v1.8.0/go.mod h1:uI+AI/r1oyWK99NN8cQ3UK76AMelMzgZCvJfsi2c+ps= +cloud.google.com/go/accesscontextmanager v1.8.1/go.mod h1:JFJHfvuaTC+++1iL1coPiG1eu5D24db2wXCDWDjIrxo= +cloud.google.com/go/accesscontextmanager v1.8.2/go.mod h1:E6/SCRM30elQJ2PKtFMs2YhfJpZSNcJyejhuzoId4Zk= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/aiplatform v1.35.0/go.mod h1:7MFT/vCaOyZT/4IIFfxH4ErVg/4ku6lKv3w0+tFTgXQ= +cloud.google.com/go/aiplatform v1.36.1/go.mod h1:WTm12vJRPARNvJ+v6P52RDHCNe4AhvjcIZ/9/RRHy/k= +cloud.google.com/go/aiplatform v1.37.0/go.mod h1:IU2Cv29Lv9oCn/9LkFiiuKfwrRTq+QQMbW+hPCxJGZw= +cloud.google.com/go/aiplatform v1.45.0/go.mod h1:Iu2Q7sC7QGhXUeOhAj/oCK9a+ULz1O4AotZiqjQ8MYA= +cloud.google.com/go/aiplatform v1.48.0/go.mod h1:Iu2Q7sC7QGhXUeOhAj/oCK9a+ULz1O4AotZiqjQ8MYA= +cloud.google.com/go/aiplatform v1.50.0/go.mod h1:IRc2b8XAMTa9ZmfJV1BCCQbieWWvDnP1A8znyz5N7y4= +cloud.google.com/go/aiplatform v1.51.0/go.mod h1:IRc2b8XAMTa9ZmfJV1BCCQbieWWvDnP1A8znyz5N7y4= +cloud.google.com/go/aiplatform v1.51.1/go.mod h1:kY3nIMAVQOK2XDqDPHaOuD9e+FdMA6OOpfBjsvaFSOo= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/analytics v0.17.0/go.mod h1:WXFa3WSym4IZ+JiKmavYdJwGG/CvpqiqczmL59bTD9M= +cloud.google.com/go/analytics v0.18.0/go.mod h1:ZkeHGQlcIPkw0R/GW+boWHhCOR43xz9RN/jn7WcqfIE= +cloud.google.com/go/analytics v0.19.0/go.mod h1:k8liqf5/HCnOUkbawNtrWWc+UAzyDlW89doe8TtoDsE= +cloud.google.com/go/analytics v0.21.2/go.mod h1:U8dcUtmDmjrmUTnnnRnI4m6zKn/yaA5N9RlEkYFHpQo= +cloud.google.com/go/analytics v0.21.3/go.mod h1:U8dcUtmDmjrmUTnnnRnI4m6zKn/yaA5N9RlEkYFHpQo= +cloud.google.com/go/analytics v0.21.4/go.mod h1:zZgNCxLCy8b2rKKVfC1YkC2vTrpfZmeRCySM3aUbskA= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigateway v1.5.0/go.mod h1:GpnZR3Q4rR7LVu5951qfXPJCHquZt02jf7xQx7kpqN8= +cloud.google.com/go/apigateway v1.6.1/go.mod h1:ufAS3wpbRjqfZrzpvLC2oh0MFlpRJm2E/ts25yyqmXA= +cloud.google.com/go/apigateway v1.6.2/go.mod h1:CwMC90nnZElorCW63P2pAYm25AtQrHfuOkbRSHj0bT8= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/apigeeconnect v1.5.0/go.mod h1:KFaCqvBRU6idyhSNyn3vlHXc8VMDJdRmwDF6JyFRqZ8= +cloud.google.com/go/apigeeconnect v1.6.1/go.mod h1:C4awq7x0JpLtrlQCr8AzVIzAaYgngRqWf9S5Uhg+wWs= +cloud.google.com/go/apigeeconnect v1.6.2/go.mod h1:s6O0CgXT9RgAxlq3DLXvG8riw8PYYbU/v25jqP3Dy18= +cloud.google.com/go/apigeeregistry v0.4.0/go.mod h1:EUG4PGcsZvxOXAdyEghIdXwAEi/4MEaoqLMLDMIwKXY= +cloud.google.com/go/apigeeregistry v0.5.0/go.mod h1:YR5+s0BVNZfVOUkMa5pAR2xGd0A473vA5M7j247o1wM= +cloud.google.com/go/apigeeregistry v0.6.0/go.mod h1:BFNzW7yQVLZ3yj0TKcwzb8n25CFBri51GVGOEUcgQsc= +cloud.google.com/go/apigeeregistry v0.7.1/go.mod h1:1XgyjZye4Mqtw7T9TsY4NW10U7BojBvG4RMD+vRDrIw= +cloud.google.com/go/apigeeregistry v0.7.2/go.mod h1:9CA2B2+TGsPKtfi3F7/1ncCCsL62NXBRfM6iPoGSM+8= +cloud.google.com/go/apikeys v0.4.0/go.mod h1:XATS/yqZbaBK0HOssf+ALHp8jAlNHUgyfprvNcBIszU= +cloud.google.com/go/apikeys v0.5.0/go.mod h1:5aQfwY4D+ewMMWScd3hm2en3hCj+BROlyrt3ytS7KLI= +cloud.google.com/go/apikeys v0.6.0/go.mod h1:kbpXu5upyiAlGkKrJgQl8A0rKNNJ7dQ377pdroRSSi8= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/appengine v1.6.0/go.mod h1:hg6i0J/BD2cKmDJbaFSYHFyZkgBEfQrDg/X0V5fJn84= +cloud.google.com/go/appengine v1.7.0/go.mod h1:eZqpbHFCqRGa2aCdope7eC0SWLV1j0neb/QnMJVWx6A= +cloud.google.com/go/appengine v1.7.1/go.mod h1:IHLToyb/3fKutRysUlFO0BPt5j7RiQ45nrzEJmKTo6E= +cloud.google.com/go/appengine v1.8.1/go.mod h1:6NJXGLVhZCN9aQ/AEDvmfzKEfoYBlfB80/BHiKVputY= +cloud.google.com/go/appengine v1.8.2/go.mod h1:WMeJV9oZ51pvclqFN2PqHoGnys7rK0rz6s3Mp6yMvDo= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/area120 v0.7.0/go.mod h1:a3+8EUD1SX5RUcCs3MY5YasiO1z6yLiNLRiFrykbynY= +cloud.google.com/go/area120 v0.7.1/go.mod h1:j84i4E1RboTWjKtZVWXPqvK5VHQFJRF2c1Nm69pWm9k= +cloud.google.com/go/area120 v0.8.1/go.mod h1:BVfZpGpB7KFVNxPiQBuHkX6Ed0rS51xIgmGyjrAfzsg= +cloud.google.com/go/area120 v0.8.2/go.mod h1:a5qfo+x77SRLXnCynFWPUZhnZGeSgvQ+Y0v1kSItkh4= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/artifactregistry v1.11.1/go.mod h1:lLYghw+Itq9SONbCa1YWBoWs1nOucMH0pwXN1rOBZFI= +cloud.google.com/go/artifactregistry v1.11.2/go.mod h1:nLZns771ZGAwVLzTX/7Al6R9ehma4WUEhZGWV6CeQNQ= +cloud.google.com/go/artifactregistry v1.12.0/go.mod h1:o6P3MIvtzTOnmvGagO9v/rOjjA0HmhJ+/6KAXrmYDCI= +cloud.google.com/go/artifactregistry v1.13.0/go.mod h1:uy/LNfoOIivepGhooAUpL1i30Hgee3Cu0l4VTWHUC08= +cloud.google.com/go/artifactregistry v1.14.1/go.mod h1:nxVdG19jTaSTu7yA7+VbWL346r3rIdkZ142BSQqhn5E= +cloud.google.com/go/artifactregistry v1.14.2/go.mod h1:Xk+QbsKEb0ElmyeMfdHAey41B+qBq3q5R5f5xD4XT3U= +cloud.google.com/go/artifactregistry v1.14.3/go.mod h1:A2/E9GXnsyXl7GUvQ/2CjHA+mVRoWAXC0brg2os+kNI= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/asset v1.11.1/go.mod h1:fSwLhbRvC9p9CXQHJ3BgFeQNM4c9x10lqlrdEUYXlJo= +cloud.google.com/go/asset v1.12.0/go.mod h1:h9/sFOa4eDIyKmH6QMpm4eUK3pDojWnUhTgJlk762Hg= +cloud.google.com/go/asset v1.13.0/go.mod h1:WQAMyYek/b7NBpYq/K4KJWcRqzoalEsxz/t/dTk4THw= +cloud.google.com/go/asset v1.14.1/go.mod h1:4bEJ3dnHCqWCDbWJ/6Vn7GVI9LerSi7Rfdi03hd+WTQ= +cloud.google.com/go/asset v1.15.0/go.mod h1:tpKafV6mEut3+vN9ScGvCHXHj7FALFVta+okxFECHcg= +cloud.google.com/go/asset v1.15.1/go.mod h1:yX/amTvFWRpp5rcFq6XbCxzKT8RJUam1UoboE179jU4= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/assuredworkloads v1.10.0/go.mod h1:kwdUQuXcedVdsIaKgKTp9t0UJkE5+PAVNhdQm4ZVq2E= +cloud.google.com/go/assuredworkloads v1.11.1/go.mod h1:+F04I52Pgn5nmPG36CWFtxmav6+7Q+c5QyJoL18Lry0= +cloud.google.com/go/assuredworkloads v1.11.2/go.mod h1:O1dfr+oZJMlE6mw0Bp0P1KZSlj5SghMBvTpZqIcUAW4= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/automl v1.12.0/go.mod h1:tWDcHDp86aMIuHmyvjuKeeHEGq76lD7ZqfGLN6B0NuU= +cloud.google.com/go/automl v1.13.1/go.mod h1:1aowgAHWYZU27MybSCFiukPO7xnyawv7pt3zK4bheQE= +cloud.google.com/go/automl v1.13.2/go.mod h1:gNY/fUmDEN40sP8amAX3MaXkxcqPIn7F1UIIPZpy4Mg= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/baremetalsolution v0.5.0/go.mod h1:dXGxEkmR9BMwxhzBhV0AioD0ULBmuLZI8CdwalUxuss= +cloud.google.com/go/baremetalsolution v1.1.1/go.mod h1:D1AV6xwOksJMV4OSlWHtWuFNZZYujJknMAP4Qa27QIA= +cloud.google.com/go/baremetalsolution v1.2.0/go.mod h1:68wi9AwPYkEWIUT4SvSGS9UJwKzNpshjHsH4lzk8iOw= +cloud.google.com/go/baremetalsolution v1.2.1/go.mod h1:3qKpKIw12RPXStwQXcbhfxVj1dqQGEvcmA+SX/mUR88= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/batch v0.7.0/go.mod h1:vLZN95s6teRUqRQ4s3RLDsH8PvboqBK+rn1oevL159g= +cloud.google.com/go/batch v1.3.1/go.mod h1:VguXeQKXIYaeeIYbuozUmBR13AfL4SJP7IltNPS+A4A= +cloud.google.com/go/batch v1.4.1/go.mod h1:KdBmDD61K0ovcxoRHGrN6GmOBWeAOyCgKD0Mugx4Fkk= +cloud.google.com/go/batch v1.5.0/go.mod h1:KdBmDD61K0ovcxoRHGrN6GmOBWeAOyCgKD0Mugx4Fkk= +cloud.google.com/go/batch v1.5.1/go.mod h1:RpBuIYLkQu8+CWDk3dFD/t/jOCGuUpkpX+Y0n1Xccs8= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= +cloud.google.com/go/beyondcorp v0.4.0/go.mod h1:3ApA0mbhHx6YImmuubf5pyW8srKnCEPON32/5hj+RmM= +cloud.google.com/go/beyondcorp v0.5.0/go.mod h1:uFqj9X+dSfrheVp7ssLTaRHd2EHqSL4QZmH4e8WXGGU= +cloud.google.com/go/beyondcorp v0.6.1/go.mod h1:YhxDWw946SCbmcWo3fAhw3V4XZMSpQ/VYfcKGAEU8/4= +cloud.google.com/go/beyondcorp v1.0.0/go.mod h1:YhxDWw946SCbmcWo3fAhw3V4XZMSpQ/VYfcKGAEU8/4= +cloud.google.com/go/beyondcorp v1.0.1/go.mod h1:zl/rWWAFVeV+kx+X2Javly7o1EIQThU4WlkynffL/lk= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= +cloud.google.com/go/bigquery v1.47.0/go.mod h1:sA9XOgy0A8vQK9+MWhEQTY6Tix87M/ZurWFIxmF9I/E= +cloud.google.com/go/bigquery v1.48.0/go.mod h1:QAwSz+ipNgfL5jxiaK7weyOhzdoAy1zFm0Nf1fysJac= +cloud.google.com/go/bigquery v1.49.0/go.mod h1:Sv8hMmTFFYBlt/ftw2uN6dFdQPzBlREY9yBh7Oy7/4Q= +cloud.google.com/go/bigquery v1.50.0/go.mod h1:YrleYEh2pSEbgTBZYMJ5SuSr0ML3ypjRB1zgf7pvQLU= +cloud.google.com/go/bigquery v1.52.0/go.mod h1:3b/iXjRQGU4nKa87cXeg6/gogLjO8C6PmuM8i5Bi/u4= +cloud.google.com/go/bigquery v1.53.0/go.mod h1:3b/iXjRQGU4nKa87cXeg6/gogLjO8C6PmuM8i5Bi/u4= +cloud.google.com/go/bigquery v1.55.0/go.mod h1:9Y5I3PN9kQWuid6183JFhOGOW3GcirA5LpsKCUn+2ec= +cloud.google.com/go/bigquery v1.56.0/go.mod h1:KDcsploXTEY7XT3fDQzMUZlpQLHzE4itubHrnmhUrZA= +cloud.google.com/go/bigtable v1.2.0/go.mod h1:JcVAOl45lrTmQfLj7T6TxyMzIN/3FGGcFm+2xVAli2o= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/billing v1.12.0/go.mod h1:yKrZio/eu+okO/2McZEbch17O5CB5NpZhhXG6Z766ss= +cloud.google.com/go/billing v1.13.0/go.mod h1:7kB2W9Xf98hP9Sr12KfECgfGclsH3CQR0R08tnRlRbc= +cloud.google.com/go/billing v1.16.0/go.mod h1:y8vx09JSSJG02k5QxbycNRrN7FGZB6F3CAcgum7jvGA= +cloud.google.com/go/billing v1.17.0/go.mod h1:Z9+vZXEq+HwH7bhJkyI4OQcR6TSbeMrjlpEjO2vzY64= +cloud.google.com/go/billing v1.17.1/go.mod h1:Z9+vZXEq+HwH7bhJkyI4OQcR6TSbeMrjlpEjO2vzY64= +cloud.google.com/go/billing v1.17.2/go.mod h1:u/AdV/3wr3xoRBk5xvUzYMS1IawOAPwQMuHgHMdljDg= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/binaryauthorization v1.5.0/go.mod h1:OSe4OU1nN/VswXKRBmciKpo9LulY41gch5c68htf3/Q= +cloud.google.com/go/binaryauthorization v1.6.1/go.mod h1:TKt4pa8xhowwffiBmbrbcxijJRZED4zrqnwZ1lKH51U= +cloud.google.com/go/binaryauthorization v1.7.0/go.mod h1:Zn+S6QqTMn6odcMU1zDZCJxPjU2tZPV1oDl45lWY154= +cloud.google.com/go/binaryauthorization v1.7.1/go.mod h1:GTAyfRWYgcbsP3NJogpV3yeunbUIjx2T9xVeYovtURE= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/certificatemanager v1.6.0/go.mod h1:3Hh64rCKjRAX8dXgRAyOcY5vQ/fE1sh8o+Mdd6KPgY8= +cloud.google.com/go/certificatemanager v1.7.1/go.mod h1:iW8J3nG6SaRYImIa+wXQ0g8IgoofDFRp5UMzaNk1UqI= +cloud.google.com/go/certificatemanager v1.7.2/go.mod h1:15SYTDQMd00kdoW0+XY5d9e+JbOPjp24AvF48D8BbcQ= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/channel v1.11.0/go.mod h1:IdtI0uWGqhEeatSB62VOoJ8FSUhJ9/+iGkJVqp74CGE= +cloud.google.com/go/channel v1.12.0/go.mod h1:VkxCGKASi4Cq7TbXxlaBezonAYpp1GCnKMY6tnMQnLU= +cloud.google.com/go/channel v1.16.0/go.mod h1:eN/q1PFSl5gyu0dYdmxNXscY/4Fi7ABmeHCJNf/oHmc= +cloud.google.com/go/channel v1.17.0/go.mod h1:RpbhJsGi/lXWAUM1eF4IbQGbsfVlg2o8Iiy2/YLfVT0= +cloud.google.com/go/channel v1.17.1/go.mod h1:xqfzcOZAcP4b/hUDH0GkGg1Sd5to6di1HOJn/pi5uBQ= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/cloudbuild v1.6.0/go.mod h1:UIbc/w9QCbH12xX+ezUsgblrWv+Cv4Tw83GiSMHOn9M= +cloud.google.com/go/cloudbuild v1.7.0/go.mod h1:zb5tWh2XI6lR9zQmsm1VRA+7OCuve5d8S+zJUul8KTg= +cloud.google.com/go/cloudbuild v1.9.0/go.mod h1:qK1d7s4QlO0VwfYn5YuClDGg2hfmLZEb4wQGAbIgL1s= +cloud.google.com/go/cloudbuild v1.10.1/go.mod h1:lyJg7v97SUIPq4RC2sGsz/9tNczhyv2AjML/ci4ulzU= +cloud.google.com/go/cloudbuild v1.13.0/go.mod h1:lyJg7v97SUIPq4RC2sGsz/9tNczhyv2AjML/ci4ulzU= +cloud.google.com/go/cloudbuild v1.14.0/go.mod h1:lyJg7v97SUIPq4RC2sGsz/9tNczhyv2AjML/ci4ulzU= +cloud.google.com/go/cloudbuild v1.14.1/go.mod h1:K7wGc/3zfvmYWOWwYTgF/d/UVJhS4pu+HAy7PL7mCsU= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/clouddms v1.5.0/go.mod h1:QSxQnhikCLUw13iAbffF2CZxAER3xDGNHjsTAkQJcQA= +cloud.google.com/go/clouddms v1.6.1/go.mod h1:Ygo1vL52Ov4TBZQquhz5fiw2CQ58gvu+PlS6PVXCpZI= +cloud.google.com/go/clouddms v1.7.0/go.mod h1:MW1dC6SOtI/tPNCciTsXtsGNEM0i0OccykPvv3hiYeM= +cloud.google.com/go/clouddms v1.7.1/go.mod h1:o4SR8U95+P7gZ/TX+YbJxehOCsM+fe6/brlrFquiszk= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/cloudtasks v1.9.0/go.mod h1:w+EyLsVkLWHcOaqNEyvcKAsWp9p29dL6uL9Nst1cI7Y= +cloud.google.com/go/cloudtasks v1.10.0/go.mod h1:NDSoTLkZ3+vExFEWu2UJV1arUyzVDAiZtdWcsUyNwBs= +cloud.google.com/go/cloudtasks v1.11.1/go.mod h1:a9udmnou9KO2iulGscKR0qBYjreuX8oHwpmFsKspEvM= +cloud.google.com/go/cloudtasks v1.12.1/go.mod h1:a9udmnou9KO2iulGscKR0qBYjreuX8oHwpmFsKspEvM= +cloud.google.com/go/cloudtasks v1.12.2/go.mod h1:A7nYkjNlW2gUoROg1kvJrQGhJP/38UaWwsnuBDOBVUk= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute v1.18.0/go.mod h1:1X7yHxec2Ga+Ss6jPyjxRxpu2uu7PLgsOVXvgU0yacs= +cloud.google.com/go/compute v1.19.0/go.mod h1:rikpw2y+UMidAe9tISo04EHNOIf42RLYF/q8Bs93scU= +cloud.google.com/go/compute v1.19.1/go.mod h1:6ylj3a05WF8leseCdIf77NK0g1ey+nj5IKd5/kvShxE= +cloud.google.com/go/compute v1.19.3/go.mod h1:qxvISKp/gYnXkSAD1ppcSOveRAmzxicEv/JlizULFrI= +cloud.google.com/go/compute v1.20.1/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= +cloud.google.com/go/compute v1.21.0/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= +cloud.google.com/go/compute v1.23.0/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM= +cloud.google.com/go/compute v1.23.1/go.mod h1:CqB3xpmPKKt3OJpW2ndFIXnA9A4xAy/F3Xp1ixncW78= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/contactcenterinsights v1.6.0/go.mod h1:IIDlT6CLcDoyv79kDv8iWxMSTZhLxSCofVV5W6YFM/w= +cloud.google.com/go/contactcenterinsights v1.9.1/go.mod h1:bsg/R7zGLYMVxFFzfh9ooLTruLRCG9fnzhH9KznHhbM= +cloud.google.com/go/contactcenterinsights v1.10.0/go.mod h1:bsg/R7zGLYMVxFFzfh9ooLTruLRCG9fnzhH9KznHhbM= +cloud.google.com/go/contactcenterinsights v1.11.0/go.mod h1:hutBdImE4XNZ1NV4vbPJKSFOnQruhC5Lj9bZqWMTKiU= +cloud.google.com/go/contactcenterinsights v1.11.1/go.mod h1:FeNP3Kg8iteKM80lMwSk3zZZKVxr+PGnAId6soKuXwE= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/container v1.13.1/go.mod h1:6wgbMPeQRw9rSnKBCAJXnds3Pzj03C4JHamr8asWKy4= +cloud.google.com/go/container v1.14.0/go.mod h1:3AoJMPhHfLDxLvrlVWaK57IXzaPnLaZq63WX59aQBfM= +cloud.google.com/go/container v1.15.0/go.mod h1:ft+9S0WGjAyjDggg5S06DXj+fHJICWg8L7isCQe9pQA= +cloud.google.com/go/container v1.22.1/go.mod h1:lTNExE2R7f+DLbAN+rJiKTisauFCaoDq6NURZ83eVH4= +cloud.google.com/go/container v1.24.0/go.mod h1:lTNExE2R7f+DLbAN+rJiKTisauFCaoDq6NURZ83eVH4= +cloud.google.com/go/container v1.26.0/go.mod h1:YJCmRet6+6jnYYRS000T6k0D0xUXQgBSaJ7VwI8FBj4= +cloud.google.com/go/container v1.26.1/go.mod h1:5smONjPRUxeEpDG7bMKWfDL4sauswqEtnBK1/KKpR04= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/containeranalysis v0.7.0/go.mod h1:9aUL+/vZ55P2CXfuZjS4UjQ9AgXoSw8Ts6lemfmxBxI= +cloud.google.com/go/containeranalysis v0.9.0/go.mod h1:orbOANbwk5Ejoom+s+DUCTTJ7IBdBQJDcSylAx/on9s= +cloud.google.com/go/containeranalysis v0.10.1/go.mod h1:Ya2jiILITMY68ZLPaogjmOMNkwsDrWBSTyBubGXO7j0= +cloud.google.com/go/containeranalysis v0.11.0/go.mod h1:4n2e99ZwpGxpNcz+YsFT1dfOHPQFGcAC8FN2M2/ne/U= +cloud.google.com/go/containeranalysis v0.11.1/go.mod h1:rYlUOM7nem1OJMKwE1SadufX0JP3wnXj844EtZAwWLY= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/datacatalog v1.8.1/go.mod h1:RJ58z4rMp3gvETA465Vg+ag8BGgBdnRPEMMSTr5Uv+M= +cloud.google.com/go/datacatalog v1.12.0/go.mod h1:CWae8rFkfp6LzLumKOnmVh4+Zle4A3NXLzVJ1d1mRm0= +cloud.google.com/go/datacatalog v1.13.0/go.mod h1:E4Rj9a5ZtAxcQJlEBTLgMTphfP11/lNaAshpoBgemX8= +cloud.google.com/go/datacatalog v1.14.0/go.mod h1:h0PrGtlihoutNMp/uvwhawLQ9+c63Kz65UFqh49Yo+E= +cloud.google.com/go/datacatalog v1.14.1/go.mod h1:d2CevwTG4yedZilwe+v3E3ZBDRMobQfSG/a6cCCN5R4= +cloud.google.com/go/datacatalog v1.16.0/go.mod h1:d2CevwTG4yedZilwe+v3E3ZBDRMobQfSG/a6cCCN5R4= +cloud.google.com/go/datacatalog v1.17.1/go.mod h1:nCSYFHgtxh2MiEktWIz71s/X+7ds/UT9kp0PC7waCzE= +cloud.google.com/go/datacatalog v1.18.0/go.mod h1:nCSYFHgtxh2MiEktWIz71s/X+7ds/UT9kp0PC7waCzE= +cloud.google.com/go/datacatalog v1.18.1/go.mod h1:TzAWaz+ON1tkNr4MOcak8EBHX7wIRX/gZKM+yTVsv+A= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataflow v0.8.0/go.mod h1:Rcf5YgTKPtQyYz8bLYhFoIV/vP39eL7fWNcSOyFfLJE= +cloud.google.com/go/dataflow v0.9.1/go.mod h1:Wp7s32QjYuQDWqJPFFlnBKhkAtiFpMTdg00qGbnIHVw= +cloud.google.com/go/dataflow v0.9.2/go.mod h1:vBfdBZ/ejlTaYIGB3zB4T08UshH70vbtZeMD+urnUSo= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/dataform v0.6.0/go.mod h1:QPflImQy33e29VuapFdf19oPbE4aYTJxr31OAPV+ulA= +cloud.google.com/go/dataform v0.7.0/go.mod h1:7NulqnVozfHvWUBpMDfKMUESr+85aJsC/2O0o3jWPDE= +cloud.google.com/go/dataform v0.8.1/go.mod h1:3BhPSiw8xmppbgzeBbmDvmSWlwouuJkXsXsb8UBih9M= +cloud.google.com/go/dataform v0.8.2/go.mod h1:X9RIqDs6NbGPLR80tnYoPNiO1w0wenKTb8PxxlhTMKM= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datafusion v1.6.0/go.mod h1:WBsMF8F1RhSXvVM8rCV3AeyWVxcC2xY6vith3iw3S+8= +cloud.google.com/go/datafusion v1.7.1/go.mod h1:KpoTBbFmoToDExJUso/fcCiguGDk7MEzOWXUsJo0wsI= +cloud.google.com/go/datafusion v1.7.2/go.mod h1:62K2NEC6DRlpNmI43WHMWf9Vg/YvN6QVi8EVwifElI0= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/datalabeling v0.7.0/go.mod h1:WPQb1y08RJbmpM3ww0CSUAGweL0SxByuW2E+FU+wXcM= +cloud.google.com/go/datalabeling v0.8.1/go.mod h1:XS62LBSVPbYR54GfYQsPXZjTW8UxCK2fkDciSrpRFdY= +cloud.google.com/go/datalabeling v0.8.2/go.mod h1:cyDvGHuJWu9U/cLDA7d8sb9a0tWLEletStu2sTmg3BE= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataplex v1.5.2/go.mod h1:cVMgQHsmfRoI5KFYq4JtIBEUbYwc3c7tXmIDhRmNNVQ= +cloud.google.com/go/dataplex v1.6.0/go.mod h1:bMsomC/aEJOSpHXdFKFGQ1b0TDPIeL28nJObeO1ppRs= +cloud.google.com/go/dataplex v1.8.1/go.mod h1:7TyrDT6BCdI8/38Uvp0/ZxBslOslP2X2MPDucliyvSE= +cloud.google.com/go/dataplex v1.9.0/go.mod h1:7TyrDT6BCdI8/38Uvp0/ZxBslOslP2X2MPDucliyvSE= +cloud.google.com/go/dataplex v1.9.1/go.mod h1:7TyrDT6BCdI8/38Uvp0/ZxBslOslP2X2MPDucliyvSE= +cloud.google.com/go/dataplex v1.10.1/go.mod h1:1MzmBv8FvjYfc7vDdxhnLFNskikkB+3vl475/XdCDhs= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataproc v1.12.0/go.mod h1:zrF3aX0uV3ikkMz6z4uBbIKyhRITnxvr4i3IjKsKrw4= +cloud.google.com/go/dataproc/v2 v2.0.1/go.mod h1:7Ez3KRHdFGcfY7GcevBbvozX+zyWGcwLJvvAMwCaoZ4= +cloud.google.com/go/dataproc/v2 v2.2.0/go.mod h1:lZR7AQtwZPvmINx5J87DSOOpTfof9LVZju6/Qo4lmcY= +cloud.google.com/go/dataproc/v2 v2.2.1/go.mod h1:QdAJLaBjh+l4PVlVZcmrmhGccosY/omC1qwfQ61Zv/o= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= +cloud.google.com/go/dataqna v0.7.0/go.mod h1:Lx9OcIIeqCrw1a6KdO3/5KMP1wAmTc0slZWwP12Qq3c= +cloud.google.com/go/dataqna v0.8.1/go.mod h1:zxZM0Bl6liMePWsHA8RMGAfmTG34vJMapbHAxQ5+WA8= +cloud.google.com/go/dataqna v0.8.2/go.mod h1:KNEqgx8TTmUipnQsScOoDpq/VlXVptUqVMZnt30WAPs= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= -cloud.google.com/go/kms v1.0.0/go.mod h1:nhUehi+w7zht2XrUfvTRNpxrfayBHqP4lu2NSywui/0= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastore v1.11.0/go.mod h1:TvGxBIHCS50u8jzG+AW/ppf87v1of8nwzFNgEZU1D3c= +cloud.google.com/go/datastore v1.12.0/go.mod h1:KjdB88W897MRITkvWWJrg2OUtrR5XVj1EoLgSp6/N70= +cloud.google.com/go/datastore v1.12.1/go.mod h1:KjdB88W897MRITkvWWJrg2OUtrR5XVj1EoLgSp6/N70= +cloud.google.com/go/datastore v1.13.0/go.mod h1:KjdB88W897MRITkvWWJrg2OUtrR5XVj1EoLgSp6/N70= +cloud.google.com/go/datastore v1.14.0/go.mod h1:GAeStMBIt9bPS7jMJA85kgkpsMkvseWWXiaHya9Jes8= +cloud.google.com/go/datastore v1.15.0/go.mod h1:GAeStMBIt9bPS7jMJA85kgkpsMkvseWWXiaHya9Jes8= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/datastream v1.6.0/go.mod h1:6LQSuswqLa7S4rPAOZFVjHIG3wJIjZcZrw8JDEDJuIs= +cloud.google.com/go/datastream v1.7.0/go.mod h1:uxVRMm2elUSPuh65IbZpzJNMbuzkcvu5CjMqVIUHrww= +cloud.google.com/go/datastream v1.9.1/go.mod h1:hqnmr8kdUBmrnk65k5wNRoHSCYksvpdZIcZIEl8h43Q= +cloud.google.com/go/datastream v1.10.0/go.mod h1:hqnmr8kdUBmrnk65k5wNRoHSCYksvpdZIcZIEl8h43Q= +cloud.google.com/go/datastream v1.10.1/go.mod h1:7ngSYwnw95YFyTd5tOGBxHlOZiL+OtpjheqU7t2/s/c= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/deploy v1.6.0/go.mod h1:f9PTHehG/DjCom3QH0cntOVRm93uGBDt2vKzAPwpXQI= +cloud.google.com/go/deploy v1.8.0/go.mod h1:z3myEJnA/2wnB4sgjqdMfgxCA0EqC3RBTNcVPs93mtQ= +cloud.google.com/go/deploy v1.11.0/go.mod h1:tKuSUV5pXbn67KiubiUNUejqLs4f5cxxiCNCeyl0F2g= +cloud.google.com/go/deploy v1.13.0/go.mod h1:tKuSUV5pXbn67KiubiUNUejqLs4f5cxxiCNCeyl0F2g= +cloud.google.com/go/deploy v1.13.1/go.mod h1:8jeadyLkH9qu9xgO3hVWw8jVr29N1mnW42gRJT8GY6g= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dialogflow v1.29.0/go.mod h1:b+2bzMe+k1s9V+F2jbJwpHPzrnIyHihAdRFMtn2WXuM= +cloud.google.com/go/dialogflow v1.31.0/go.mod h1:cuoUccuL1Z+HADhyIA7dci3N5zUssgpBJmCzI6fNRB4= +cloud.google.com/go/dialogflow v1.32.0/go.mod h1:jG9TRJl8CKrDhMEcvfcfFkkpp8ZhgPz3sBGmAUYJ2qE= +cloud.google.com/go/dialogflow v1.38.0/go.mod h1:L7jnH+JL2mtmdChzAIcXQHXMvQkE3U4hTaNltEuxXn4= +cloud.google.com/go/dialogflow v1.40.0/go.mod h1:L7jnH+JL2mtmdChzAIcXQHXMvQkE3U4hTaNltEuxXn4= +cloud.google.com/go/dialogflow v1.43.0/go.mod h1:pDUJdi4elL0MFmt1REMvFkdsUTYSHq+rTCS8wg0S3+M= +cloud.google.com/go/dialogflow v1.44.0/go.mod h1:pDUJdi4elL0MFmt1REMvFkdsUTYSHq+rTCS8wg0S3+M= +cloud.google.com/go/dialogflow v1.44.1/go.mod h1:n/h+/N2ouKOO+rbe/ZnI186xImpqvCVj2DdsWS/0EAk= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/dlp v1.9.0/go.mod h1:qdgmqgTyReTz5/YNSSuueR8pl7hO0o9bQ39ZhtgkWp4= +cloud.google.com/go/dlp v1.10.1/go.mod h1:IM8BWz1iJd8njcNcG0+Kyd9OPnqnRNkDV8j42VT5KOI= +cloud.google.com/go/dlp v1.10.2/go.mod h1:ZbdKIhcnyhILgccwVDzkwqybthh7+MplGC3kZVZsIOQ= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/documentai v1.16.0/go.mod h1:o0o0DLTEZ+YnJZ+J4wNfTxmDVyrkzFvttBXXtYRMHkM= +cloud.google.com/go/documentai v1.18.0/go.mod h1:F6CK6iUH8J81FehpskRmhLq/3VlwQvb7TvwOceQ2tbs= +cloud.google.com/go/documentai v1.20.0/go.mod h1:yJkInoMcK0qNAEdRnqY/D5asy73tnPe88I1YTZT+a8E= +cloud.google.com/go/documentai v1.22.0/go.mod h1:yJkInoMcK0qNAEdRnqY/D5asy73tnPe88I1YTZT+a8E= +cloud.google.com/go/documentai v1.22.1/go.mod h1:LKs22aDHbJv7ufXuPypzRO7rG3ALLJxzdCXDPutw4Qc= +cloud.google.com/go/documentai v1.23.0/go.mod h1:LKs22aDHbJv7ufXuPypzRO7rG3ALLJxzdCXDPutw4Qc= +cloud.google.com/go/documentai v1.23.2/go.mod h1:Q/wcRT+qnuXOpjAkvOV4A+IeQl04q2/ReT7SSbytLSo= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/domains v0.8.0/go.mod h1:M9i3MMDzGFXsydri9/vW+EWz9sWb4I6WyHqdlAk0idE= +cloud.google.com/go/domains v0.9.1/go.mod h1:aOp1c0MbejQQ2Pjf1iJvnVyT+z6R6s8pX66KaCSDYfE= +cloud.google.com/go/domains v0.9.2/go.mod h1:3YvXGYzZG1Temjbk7EyGCuGGiXHJwVNmwIf+E/cUp5I= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/edgecontainer v0.3.0/go.mod h1:FLDpP4nykgwwIfcLt6zInhprzw0lEi2P1fjO6Ie0qbc= +cloud.google.com/go/edgecontainer v1.0.0/go.mod h1:cttArqZpBB2q58W/upSG++ooo6EsblxDIolxa3jSjbY= +cloud.google.com/go/edgecontainer v1.1.1/go.mod h1:O5bYcS//7MELQZs3+7mabRqoWQhXCzenBu0R8bz2rwk= +cloud.google.com/go/edgecontainer v1.1.2/go.mod h1:wQRjIzqxEs9e9wrtle4hQPSR1Y51kqN75dgF7UllZZ4= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/essentialcontacts v1.5.0/go.mod h1:ay29Z4zODTuwliK7SnX8E86aUF2CTzdNtvv42niCX0M= +cloud.google.com/go/essentialcontacts v1.6.2/go.mod h1:T2tB6tX+TRak7i88Fb2N9Ok3PvY3UNbUsMag9/BARh4= +cloud.google.com/go/essentialcontacts v1.6.3/go.mod h1:yiPCD7f2TkP82oJEFXFTou8Jl8L6LBRPeBEkTaO0Ggo= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/eventarc v1.10.0/go.mod h1:u3R35tmZ9HvswGRBnF48IlYgYeBcPUCjkr4BTdem2Kw= +cloud.google.com/go/eventarc v1.11.0/go.mod h1:PyUjsUKPWoRBCHeOxZd/lbOOjahV41icXyUY5kSTvVY= +cloud.google.com/go/eventarc v1.12.1/go.mod h1:mAFCW6lukH5+IZjkvrEss+jmt2kOdYlN8aMx3sRJiAI= +cloud.google.com/go/eventarc v1.13.0/go.mod h1:mAFCW6lukH5+IZjkvrEss+jmt2kOdYlN8aMx3sRJiAI= +cloud.google.com/go/eventarc v1.13.1/go.mod h1:EqBxmGHFrruIara4FUQ3RHlgfCn7yo1HYsu2Hpt/C3Y= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= +cloud.google.com/go/filestore v1.5.0/go.mod h1:FqBXDWBp4YLHqRnVGveOkHDf8svj9r5+mUDLupOWEDs= +cloud.google.com/go/filestore v1.6.0/go.mod h1:di5unNuss/qfZTw2U9nhFqo8/ZDSc466dre85Kydllg= +cloud.google.com/go/filestore v1.7.1/go.mod h1:y10jsorq40JJnjR/lQ8AfFbbcGlw3g+Dp8oN7i7FjV4= +cloud.google.com/go/filestore v1.7.2/go.mod h1:TYOlyJs25f/omgj+vY7/tIG/E7BX369triSPzE4LdgE= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/firestore v1.11.0/go.mod h1:b38dKhgzlmNNGTNZZwe7ZRFEuRab1Hay3/DBsIGKKy4= +cloud.google.com/go/firestore v1.12.0/go.mod h1:b38dKhgzlmNNGTNZZwe7ZRFEuRab1Hay3/DBsIGKKy4= +cloud.google.com/go/firestore v1.13.0/go.mod h1:QojqqOh8IntInDUSTAh0c8ZsPYAr68Ma8c5DWOy8xb8= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/functions v1.10.0/go.mod h1:0D3hEOe3DbEvCXtYOZHQZmD+SzYsi1YbI7dGvHfldXw= +cloud.google.com/go/functions v1.12.0/go.mod h1:AXWGrF3e2C/5ehvwYo/GH6O5s09tOPksiKhz+hH8WkA= +cloud.google.com/go/functions v1.13.0/go.mod h1:EU4O007sQm6Ef/PwRsI8N2umygGqPBS/IZQKBQBcJ3c= +cloud.google.com/go/functions v1.15.1/go.mod h1:P5yNWUTkyU+LvW/S9O6V+V423VZooALQlqoXdoPz5AE= +cloud.google.com/go/functions v1.15.2/go.mod h1:CHAjtcR6OU4XF2HuiVeriEdELNcnvRZSk1Q8RMqy4lE= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gaming v1.9.0/go.mod h1:Fc7kEmCObylSWLO334NcO+O9QMDyz+TKC4v1D7X+Bc0= +cloud.google.com/go/gaming v1.10.1/go.mod h1:XQQvtfP8Rb9Rxnxm5wFVpAp9zCQkJi2bLIb7iHGwB3s= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkebackup v0.4.0/go.mod h1:byAyBGUwYGEEww7xsbnUTBHIYcOPy/PgUWUtOeRm9Vg= +cloud.google.com/go/gkebackup v1.3.0/go.mod h1:vUDOu++N0U5qs4IhG1pcOnD1Mac79xWy6GoBFlWCWBU= +cloud.google.com/go/gkebackup v1.3.1/go.mod h1:vUDOu++N0U5qs4IhG1pcOnD1Mac79xWy6GoBFlWCWBU= +cloud.google.com/go/gkebackup v1.3.2/go.mod h1:OMZbXzEJloyXMC7gqdSB+EOEQ1AKcpGYvO3s1ec5ixk= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkeconnect v0.7.0/go.mod h1:SNfmVqPkaEi3bF/B3CNZOAYPYdg7sU+obZ+QTky2Myw= +cloud.google.com/go/gkeconnect v0.8.1/go.mod h1:KWiK1g9sDLZqhxB2xEuPV8V9NYzrqTUmQR9shJHpOZw= +cloud.google.com/go/gkeconnect v0.8.2/go.mod h1:6nAVhwchBJYgQCXD2pHBFQNiJNyAd/wyxljpaa6ZPrY= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkehub v0.11.0/go.mod h1:JOWHlmN+GHyIbuWQPl47/C2RFhnFKH38jH9Ascu3n0E= +cloud.google.com/go/gkehub v0.12.0/go.mod h1:djiIwwzTTBrF5NaXCGv3mf7klpEMcST17VBTVVDcuaw= +cloud.google.com/go/gkehub v0.14.1/go.mod h1:VEXKIJZ2avzrbd7u+zeMtW00Y8ddk/4V9511C9CQGTY= +cloud.google.com/go/gkehub v0.14.2/go.mod h1:iyjYH23XzAxSdhrbmfoQdePnlMj2EWcvnR+tHdBQsCY= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/gkemulticloud v0.5.0/go.mod h1:W0JDkiyi3Tqh0TJr//y19wyb1yf8llHVto2Htf2Ja3Y= +cloud.google.com/go/gkemulticloud v0.6.1/go.mod h1:kbZ3HKyTsiwqKX7Yw56+wUGwwNZViRnxWK2DVknXWfw= +cloud.google.com/go/gkemulticloud v1.0.0/go.mod h1:kbZ3HKyTsiwqKX7Yw56+wUGwwNZViRnxWK2DVknXWfw= +cloud.google.com/go/gkemulticloud v1.0.1/go.mod h1:AcrGoin6VLKT/fwZEYuqvVominLriQBCKmbjtnbMjG8= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/grafeas v0.3.0/go.mod h1:P7hgN24EyONOTMyeJH6DxG4zD7fwiYa5Q6GUgyFSOU8= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/gsuiteaddons v1.5.0/go.mod h1:TFCClYLd64Eaa12sFVmUyG62tk4mdIsI7pAnSXRkcFo= +cloud.google.com/go/gsuiteaddons v1.6.1/go.mod h1:CodrdOqRZcLp5WOwejHWYBjZvfY0kOphkAKpF/3qdZY= +cloud.google.com/go/gsuiteaddons v1.6.2/go.mod h1:K65m9XSgs8hTF3X9nNTPi8IQueljSdYo9F+Mi+s4MyU= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iam v0.11.0/go.mod h1:9PiLDanza5D+oWFZiH1uG+RnRCfEGKoyl6yo4cgWZGY= +cloud.google.com/go/iam v0.12.0/go.mod h1:knyHGviacl11zrtZUoDuYpDgLjvr28sLQaG0YB2GYAY= +cloud.google.com/go/iam v0.13.0/go.mod h1:ljOg+rcNfzZ5d6f1nAUJ8ZIxOaZUVoS14bKCtaLZ/D0= +cloud.google.com/go/iam v1.0.1/go.mod h1:yR3tmSL8BcZB4bxByRv2jkSIahVmCtfKZwLYGBalRE8= +cloud.google.com/go/iam v1.1.0/go.mod h1:nxdHjaKfCr7fNYx/HJMM8LgiMugmveWlkatear5gVyk= +cloud.google.com/go/iam v1.1.1/go.mod h1:A5avdyVL2tCppe4unb0951eI9jreack+RJ0/d+KUZOU= +cloud.google.com/go/iam v1.1.2/go.mod h1:A5avdyVL2tCppe4unb0951eI9jreack+RJ0/d+KUZOU= +cloud.google.com/go/iam v1.1.3/go.mod h1:3khUlaBXfPKKe7huYgEpDn6FtgRyMEqbkvBxrQyY5SE= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/iap v1.6.0/go.mod h1:NSuvI9C/j7UdjGjIde7t7HBz+QTwBcapPE07+sSRcLk= +cloud.google.com/go/iap v1.7.0/go.mod h1:beqQx56T9O1G1yNPph+spKpNibDlYIiIixiqsQXxLIo= +cloud.google.com/go/iap v1.7.1/go.mod h1:WapEwPc7ZxGt2jFGB/C/bm+hP0Y6NXzOYGjpPnmMS74= +cloud.google.com/go/iap v1.8.1/go.mod h1:sJCbeqg3mvWLqjZNsI6dfAtbbV1DL2Rl7e1mTyXYREQ= +cloud.google.com/go/iap v1.9.0/go.mod h1:01OFxd1R+NFrg78S+hoPV5PxEzv22HXaNqUUlmNHFuY= +cloud.google.com/go/iap v1.9.1/go.mod h1:SIAkY7cGMLohLSdBR25BuIxO+I4fXJiL06IBL7cy/5Q= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/ids v1.3.0/go.mod h1:JBdTYwANikFKaDP6LtW5JAi4gubs57SVNQjemdt6xV4= +cloud.google.com/go/ids v1.4.1/go.mod h1:np41ed8YMU8zOgv53MMMoCntLTn2lF+SUzlM+O3u/jw= +cloud.google.com/go/ids v1.4.2/go.mod h1:3vw8DX6YddRu9BncxuzMyWn0g8+ooUjI2gslJ7FH3vk= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/iot v1.5.0/go.mod h1:mpz5259PDl3XJthEmh9+ap0affn/MqNSP4My77Qql9o= +cloud.google.com/go/iot v1.6.0/go.mod h1:IqdAsmE2cTYYNO1Fvjfzo9po179rAtJeVGUvkLN3rLE= +cloud.google.com/go/iot v1.7.1/go.mod h1:46Mgw7ev1k9KqK1ao0ayW9h0lI+3hxeanz+L1zmbbbk= +cloud.google.com/go/iot v1.7.2/go.mod h1:q+0P5zr1wRFpw7/MOgDXrG/HVA+l+cSwdObffkrpnSg= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/kms v1.8.0/go.mod h1:4xFEhYFqvW+4VMELtZyxomGSYtSQKzM178ylFW4jMAg= +cloud.google.com/go/kms v1.9.0/go.mod h1:qb1tPTgfF9RQP8e1wq4cLFErVuTJv7UsSC915J8dh3w= +cloud.google.com/go/kms v1.10.0/go.mod h1:ng3KTUtQQU9bPX3+QGLsflZIHlkbn8amFAMY63m8d24= +cloud.google.com/go/kms v1.10.1/go.mod h1:rIWk/TryCkR59GMC3YtHtXeLzd634lBbKenvyySAyYI= +cloud.google.com/go/kms v1.11.0/go.mod h1:hwdiYC0xjnWsKQQCQQmIQnS9asjYVSK6jtXm+zFqXLM= +cloud.google.com/go/kms v1.12.1/go.mod h1:c9J991h5DTl+kg7gi3MYomh12YEENGrf48ee/N/2CDM= +cloud.google.com/go/kms v1.15.0/go.mod h1:c9J991h5DTl+kg7gi3MYomh12YEENGrf48ee/N/2CDM= +cloud.google.com/go/kms v1.15.2/go.mod h1:3hopT4+7ooWRCjc2DxgnpESFxhIraaI2IpAVUEhbT/w= +cloud.google.com/go/kms v1.15.3/go.mod h1:AJdXqHxS2GlPyduM99s9iGqi2nwbviBbhV/hdmt4iOQ= +cloud.google.com/go/kms v1.15.5/go.mod h1:cU2H5jnp6G2TDpUGZyqTCoy1n16fbubHZjmVXSMtwDI= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/language v1.9.0/go.mod h1:Ns15WooPM5Ad/5no/0n81yUetis74g3zrbeJBE+ptUY= +cloud.google.com/go/language v1.10.1/go.mod h1:CPp94nsdVNiQEt1CNjF5WkTcisLiHPyIbMhvR8H2AW0= +cloud.google.com/go/language v1.11.0/go.mod h1:uDx+pFDdAKTY8ehpWbiXyQdz8tDSYLJbQcXsCkjYyvQ= +cloud.google.com/go/language v1.11.1/go.mod h1:Xyid9MG9WOX3utvDbpX7j3tXDmmDooMyMDqgUVpH17U= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo= +cloud.google.com/go/lifesciences v0.9.1/go.mod h1:hACAOd1fFbCGLr/+weUKRAJas82Y4vrL3O5326N//Wc= +cloud.google.com/go/lifesciences v0.9.2/go.mod h1:QHEOO4tDzcSAzeJg7s2qwnLM2ji8IRpQl4p6m5Z9yTA= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= +cloud.google.com/go/logging v1.8.1/go.mod h1:TJjR+SimHwuC8MZ9cjByQulAMgni+RkXeI3wwctHJEI= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= +cloud.google.com/go/longrunning v0.4.2/go.mod h1:OHrnaYyLUV6oqwh0xiS7e5sLQhP1m0QU9R+WhGDMgIQ= +cloud.google.com/go/longrunning v0.5.0/go.mod h1:0JNuqRShmscVAhIACGtskSAWtqtOoPkwP0YF1oVEchc= +cloud.google.com/go/longrunning v0.5.1/go.mod h1:spvimkwdz6SPWKEt/XBij79E9fiTkHSQl/fRUUQJYJc= +cloud.google.com/go/longrunning v0.5.2/go.mod h1:nqo6DQbNV2pXhGDbDMoN2bWz68MjZUzqv2YttZiveCs= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA= +cloud.google.com/go/managedidentities v1.6.1/go.mod h1:h/irGhTN2SkZ64F43tfGPMbHnypMbu4RB3yl8YcuEak= +cloud.google.com/go/managedidentities v1.6.2/go.mod h1:5c2VG66eCa0WIq6IylRk3TBW83l161zkFvCj28X7jn8= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/maps v0.6.0/go.mod h1:o6DAMMfb+aINHz/p/jbcY+mYeXBoZoxTfdSQ8VAJaCw= +cloud.google.com/go/maps v0.7.0/go.mod h1:3GnvVl3cqeSvgMcpRlQidXsPYuDGQ8naBis7MVzpXsY= +cloud.google.com/go/maps v1.3.0/go.mod h1:6mWTUv+WhnOwAgjVsSW2QPPECmW+s3PcRyOa9vgG/5s= +cloud.google.com/go/maps v1.4.0/go.mod h1:6mWTUv+WhnOwAgjVsSW2QPPECmW+s3PcRyOa9vgG/5s= +cloud.google.com/go/maps v1.4.1/go.mod h1:BxSa0BnW1g2U2gNdbq5zikLlHUuHW0GFWh7sgML2kIY= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/mediatranslation v0.7.0/go.mod h1:LCnB/gZr90ONOIQLgSXagp8XUW1ODs2UmUMvcgMfI2I= +cloud.google.com/go/mediatranslation v0.8.1/go.mod h1:L/7hBdEYbYHQJhX2sldtTO5SZZ1C1vkapubj0T2aGig= +cloud.google.com/go/mediatranslation v0.8.2/go.mod h1:c9pUaDRLkgHRx3irYE5ZC8tfXGrMYwNZdmDqKMSfFp8= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/memcache v1.9.0/go.mod h1:8oEyzXCu+zo9RzlEaEjHl4KkgjlNDaXbCQeQWlzNFJM= +cloud.google.com/go/memcache v1.10.1/go.mod h1:47YRQIarv4I3QS5+hoETgKO40InqzLP6kpNLvyXuyaA= +cloud.google.com/go/memcache v1.10.2/go.mod h1:f9ZzJHLBrmd4BkguIAa/l/Vle6uTHzHokdnzSWOdQ6A= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/metastore v1.10.0/go.mod h1:fPEnH3g4JJAk+gMRnrAnoqyv2lpUCqJPWOodSaf45Eo= +cloud.google.com/go/metastore v1.11.1/go.mod h1:uZuSo80U3Wd4zi6C22ZZliOUJ3XeM/MlYi/z5OAOWRA= +cloud.google.com/go/metastore v1.12.0/go.mod h1:uZuSo80U3Wd4zi6C22ZZliOUJ3XeM/MlYi/z5OAOWRA= +cloud.google.com/go/metastore v1.13.0/go.mod h1:URDhpG6XLeh5K+Glq0NOt74OfrPKTwS62gEPZzb5SOk= +cloud.google.com/go/metastore v1.13.1/go.mod h1:IbF62JLxuZmhItCppcIfzBBfUFq0DIB9HPDoLgWrVOU= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/monitoring v1.12.0/go.mod h1:yx8Jj2fZNEkL/GYZyTLS4ZtZEZN8WtDEiEqG4kLK50w= +cloud.google.com/go/monitoring v1.13.0/go.mod h1:k2yMBAB1H9JT/QETjNkgdCGD9bPF712XiLTVr+cBrpw= +cloud.google.com/go/monitoring v1.15.1/go.mod h1:lADlSAlFdbqQuwwpaImhsJXu1QSdd3ojypXrFSMr2rM= +cloud.google.com/go/monitoring v1.16.0/go.mod h1:Ptp15HgAyM1fNICAojDMoNc/wUmn67mLHQfyqbw+poY= +cloud.google.com/go/monitoring v1.16.1/go.mod h1:6HsxddR+3y9j+o/cMJH6q/KJ/CBTvM/38L/1m7bTRJ4= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkconnectivity v1.10.0/go.mod h1:UP4O4sWXJG13AqrTdQCD9TnLGEbtNRqjuaaA7bNjF5E= +cloud.google.com/go/networkconnectivity v1.11.0/go.mod h1:iWmDD4QF16VCDLXUqvyspJjIEtBR/4zq5hwnY2X3scM= +cloud.google.com/go/networkconnectivity v1.12.1/go.mod h1:PelxSWYM7Sh9/guf8CFhi6vIqf19Ir/sbfZRUwXh92E= +cloud.google.com/go/networkconnectivity v1.13.0/go.mod h1:SAnGPes88pl7QRLUen2HmcBSE9AowVAcdug8c0RSBFk= +cloud.google.com/go/networkconnectivity v1.14.0/go.mod h1:SAnGPes88pl7QRLUen2HmcBSE9AowVAcdug8c0RSBFk= +cloud.google.com/go/networkconnectivity v1.14.1/go.mod h1:LyGPXR742uQcDxZ/wv4EI0Vu5N6NKJ77ZYVnDe69Zug= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networkmanagement v1.6.0/go.mod h1:5pKPqyXjB/sgtvB5xqOemumoQNB7y95Q7S+4rjSOPYY= +cloud.google.com/go/networkmanagement v1.8.0/go.mod h1:Ho/BUGmtyEqrttTgWEe7m+8vDdK74ibQc+Be0q7Fof0= +cloud.google.com/go/networkmanagement v1.9.0/go.mod h1:UTUaEU9YwbCAhhz3jEOHr+2/K/MrBk2XxOLS89LQzFw= +cloud.google.com/go/networkmanagement v1.9.1/go.mod h1:CCSYgrQQvW73EJawO2QamemYcOb57LvrDdDU51F0mcI= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/networksecurity v0.7.0/go.mod h1:mAnzoxx/8TBSyXEeESMy9OOYwo1v+gZ5eMRnsT5bC8k= +cloud.google.com/go/networksecurity v0.8.0/go.mod h1:B78DkqsxFG5zRSVuwYFRZ9Xz8IcQ5iECsNrPn74hKHU= +cloud.google.com/go/networksecurity v0.9.1/go.mod h1:MCMdxOKQ30wsBI1eI659f9kEp4wuuAueoC9AJKSPWZQ= +cloud.google.com/go/networksecurity v0.9.2/go.mod h1:jG0SeAttWzPMUILEHDUvFYdQTl8L/E/KC8iZDj85lEI= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/notebooks v1.7.0/go.mod h1:PVlaDGfJgj1fl1S3dUwhFMXFgfYGhYQt2164xOMONmE= +cloud.google.com/go/notebooks v1.8.0/go.mod h1:Lq6dYKOYOWUCTvw5t2q1gp1lAp0zxAxRycayS0iJcqQ= +cloud.google.com/go/notebooks v1.9.1/go.mod h1:zqG9/gk05JrzgBt4ghLzEepPHNwE5jgPcHZRKhlC1A8= +cloud.google.com/go/notebooks v1.10.0/go.mod h1:SOPYMZnttHxqot0SGSFSkRrwE29eqnKPBJFqgWmiK2k= +cloud.google.com/go/notebooks v1.10.1/go.mod h1:5PdJc2SgAybE76kFQCWrTfJolCOUQXF97e+gteUUA6A= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/optimization v1.3.1/go.mod h1:IvUSefKiwd1a5p0RgHDbWCIbDFgKuEdB+fPPuP0IDLI= +cloud.google.com/go/optimization v1.4.1/go.mod h1:j64vZQP7h9bO49m2rVaTVoNM0vEBEN5eKPUPbZyXOrk= +cloud.google.com/go/optimization v1.5.0/go.mod h1:evo1OvTxeBRBu6ydPlrIRizKY/LJKo/drDMMRKqGEUU= +cloud.google.com/go/optimization v1.5.1/go.mod h1:NC0gnUD5MWVAF7XLdoYVPmYYVth93Q6BUzqAq3ZwtV8= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orchestration v1.6.0/go.mod h1:M62Bevp7pkxStDfFfTuCOaXgaaqRAga1yKyoMtEoWPQ= +cloud.google.com/go/orchestration v1.8.1/go.mod h1:4sluRF3wgbYVRqz7zJ1/EUNc90TTprliq9477fGobD8= +cloud.google.com/go/orchestration v1.8.2/go.mod h1:T1cP+6WyTmh6LSZzeUhvGf0uZVmJyTx7t8z7Vg87+A0= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/orgpolicy v1.10.0/go.mod h1:w1fo8b7rRqlXlIJbVhOMPrwVljyuW5mqssvBtU18ONc= +cloud.google.com/go/orgpolicy v1.11.0/go.mod h1:2RK748+FtVvnfuynxBzdnyu7sygtoZa1za/0ZfpOs1M= +cloud.google.com/go/orgpolicy v1.11.1/go.mod h1:8+E3jQcpZJQliP+zaFfayC2Pg5bmhuLK755wKhIIUCE= +cloud.google.com/go/orgpolicy v1.11.2/go.mod h1:biRDpNwfyytYnmCRWZWxrKF22Nkz9eNVj9zyaBdpm1o= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/osconfig v1.11.0/go.mod h1:aDICxrur2ogRd9zY5ytBLV89KEgT2MKB2L/n6x1ooPw= +cloud.google.com/go/osconfig v1.12.0/go.mod h1:8f/PaYzoS3JMVfdfTubkowZYGmAhUCjjwnjqWI7NVBc= +cloud.google.com/go/osconfig v1.12.1/go.mod h1:4CjBxND0gswz2gfYRCUoUzCm9zCABp91EeTtWXyz0tE= +cloud.google.com/go/osconfig v1.12.2/go.mod h1:eh9GPaMZpI6mEJEuhEjUJmaxvQ3gav+fFEJon1Y8Iw0= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/oslogin v1.9.0/go.mod h1:HNavntnH8nzrn8JCTT5fj18FuJLFJc4NaZJtBnQtKFs= +cloud.google.com/go/oslogin v1.10.1/go.mod h1:x692z7yAue5nE7CsSnoG0aaMbNoRJRXO4sn73R+ZqAs= +cloud.google.com/go/oslogin v1.11.0/go.mod h1:8GMTJs4X2nOAUVJiPGqIWVcDaF0eniEto3xlOxaboXE= +cloud.google.com/go/oslogin v1.11.1/go.mod h1:OhD2icArCVNUxKqtK0mcSmKL7lgr0LVlQz+v9s1ujTg= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/phishingprotection v0.7.0/go.mod h1:8qJI4QKHoda/sb/7/YmMQ2omRLSLYSu9bU0EKCNI+Lk= +cloud.google.com/go/phishingprotection v0.8.1/go.mod h1:AxonW7GovcA8qdEk13NfHq9hNx5KPtfxXNeUxTDxB6I= +cloud.google.com/go/phishingprotection v0.8.2/go.mod h1:LhJ91uyVHEYKSKcMGhOa14zMMWfbEdxG032oT6ECbC8= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/policytroubleshooter v1.5.0/go.mod h1:Rz1WfV+1oIpPdN2VvvuboLVRsB1Hclg3CKQ53j9l8vw= +cloud.google.com/go/policytroubleshooter v1.6.0/go.mod h1:zYqaPTsmfvpjm5ULxAyD/lINQxJ0DDsnWOP/GZ7xzBc= +cloud.google.com/go/policytroubleshooter v1.7.1/go.mod h1:0NaT5v3Ag1M7U5r0GfDCpUFkWd9YqpubBWsQlhanRv0= +cloud.google.com/go/policytroubleshooter v1.8.0/go.mod h1:tmn5Ir5EToWe384EuboTcVQT7nTag2+DuH3uHmKd1HU= +cloud.google.com/go/policytroubleshooter v1.9.0/go.mod h1:+E2Lga7TycpeSTj2FsH4oXxTnrbHJGRlKhVZBLGgU64= +cloud.google.com/go/policytroubleshooter v1.9.1/go.mod h1:MYI8i0bCrL8cW+VHN1PoiBTyNZTstCg2WUw2eVC4c4U= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= +cloud.google.com/go/privatecatalog v0.7.0/go.mod h1:2s5ssIFO69F5csTXcwBP7NPFTZvps26xGzvQ2PQaBYg= +cloud.google.com/go/privatecatalog v0.8.0/go.mod h1:nQ6pfaegeDAq/Q5lrfCQzQLhubPiZhSaNhIgfJlnIXs= +cloud.google.com/go/privatecatalog v0.9.1/go.mod h1:0XlDXW2unJXdf9zFz968Hp35gl/bhF4twwpXZAW50JA= +cloud.google.com/go/privatecatalog v0.9.2/go.mod h1:RMA4ATa8IXfzvjrhhK8J6H4wwcztab+oZph3c6WmtFc= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsub v1.28.0/go.mod h1:vuXFpwaVoIPQMGXqRyUQigu/AX1S3IWugR9xznmcXX8= +cloud.google.com/go/pubsub v1.30.0/go.mod h1:qWi1OPS0B+b5L+Sg6Gmc9zD1Y+HaM0MdUr7LsupY1P4= +cloud.google.com/go/pubsub v1.32.0/go.mod h1:f+w71I33OMyxf9VpMVcZbnG5KSUkCOUHYpFd5U1GdRc= +cloud.google.com/go/pubsub v1.33.0/go.mod h1:f+w71I33OMyxf9VpMVcZbnG5KSUkCOUHYpFd5U1GdRc= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/pubsublite v1.6.0/go.mod h1:1eFCS0U11xlOuMFV/0iBqw3zP12kddMeCbj/F3FSj9k= +cloud.google.com/go/pubsublite v1.7.0/go.mod h1:8hVMwRXfDfvGm3fahVbtDbiLePT3gpoiJYJY+vxWxVM= +cloud.google.com/go/pubsublite v1.8.1/go.mod h1:fOLdU4f5xldK4RGJrBMm+J7zMWNj/k4PxwEZXy39QS0= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recaptchaenterprise/v2 v2.6.0/go.mod h1:RPauz9jeLtB3JVzg6nCbe12qNoaa8pXc4d/YukAmcnA= +cloud.google.com/go/recaptchaenterprise/v2 v2.7.0/go.mod h1:19wVj/fs5RtYtynAPJdDTb69oW0vNHYDBTbB4NvMD9c= +cloud.google.com/go/recaptchaenterprise/v2 v2.7.2/go.mod h1:kR0KjsJS7Jt1YSyWFkseQ756D45kaYNTlDPPaRAvDBU= +cloud.google.com/go/recaptchaenterprise/v2 v2.8.0/go.mod h1:QuE8EdU9dEnesG8/kG3XuJyNsjEqMlMzg3v3scCJ46c= +cloud.google.com/go/recaptchaenterprise/v2 v2.8.1/go.mod h1:JZYZJOeZjgSSTGP4uz7NlQ4/d1w5hGmksVgM0lbEij0= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommendationengine v0.7.0/go.mod h1:1reUcE3GIu6MeBz/h5xZJqNLuuVjNg1lmWMPyjatzac= +cloud.google.com/go/recommendationengine v0.8.1/go.mod h1:MrZihWwtFYWDzE6Hz5nKcNz3gLizXVIDI/o3G1DLcrE= +cloud.google.com/go/recommendationengine v0.8.2/go.mod h1:QIybYHPK58qir9CV2ix/re/M//Ty10OxjnnhWdaKS1Y= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/recommender v1.9.0/go.mod h1:PnSsnZY7q+VL1uax2JWkt/UegHssxjUVVCrX52CuEmQ= +cloud.google.com/go/recommender v1.10.1/go.mod h1:XFvrE4Suqn5Cq0Lf+mCP6oBHD/yRMA8XxP5sb7Q7gpA= +cloud.google.com/go/recommender v1.11.0/go.mod h1:kPiRQhPyTJ9kyXPCG6u/dlPLbYfFlkwHNRwdzPVAoII= +cloud.google.com/go/recommender v1.11.1/go.mod h1:sGwFFAyI57v2Hc5LbIj+lTwXipGu9NW015rkaEM5B18= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/redis v1.11.0/go.mod h1:/X6eicana+BWcUda5PpwZC48o37SiFVTFSs0fWAJ7uQ= +cloud.google.com/go/redis v1.13.1/go.mod h1:VP7DGLpE91M6bcsDdMuyCm2hIpB6Vp2hI090Mfd1tcg= +cloud.google.com/go/redis v1.13.2/go.mod h1:0Hg7pCMXS9uz02q+LoEVl5dNHUkIQv+C/3L76fandSA= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcemanager v1.5.0/go.mod h1:eQoXNAiAvCf5PXxWxXjhKQoTMaUSNrEfg+6qdf/wots= +cloud.google.com/go/resourcemanager v1.6.0/go.mod h1:YcpXGRs8fDzcUl1Xw8uOVmI8JEadvhRIkoXXUNVYcVo= +cloud.google.com/go/resourcemanager v1.7.0/go.mod h1:HlD3m6+bwhzj9XCouqmeiGuni95NTrExfhoSrkC/3EI= +cloud.google.com/go/resourcemanager v1.9.1/go.mod h1:dVCuosgrh1tINZ/RwBufr8lULmWGOkPS8gL5gqyjdT8= +cloud.google.com/go/resourcemanager v1.9.2/go.mod h1:OujkBg1UZg5lX2yIyMo5Vz9O5hf7XQOSV7WxqxxMtQE= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/resourcesettings v1.5.0/go.mod h1:+xJF7QSG6undsQDfsCJyqWXyBwUoJLhetkRMDRnIoXA= +cloud.google.com/go/resourcesettings v1.6.1/go.mod h1:M7mk9PIZrC5Fgsu1kZJci6mpgN8o0IUzVx3eJU3y4Jw= +cloud.google.com/go/resourcesettings v1.6.2/go.mod h1:mJIEDd9MobzunWMeniaMp6tzg4I2GvD3TTmPkc8vBXk= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/retail v1.12.0/go.mod h1:UMkelN/0Z8XvKymXFbD4EhFJlYKRx1FGhQkVPU5kF14= +cloud.google.com/go/retail v1.14.1/go.mod h1:y3Wv3Vr2k54dLNIrCzenyKG8g8dhvhncT2NcNjb/6gE= +cloud.google.com/go/retail v1.14.2/go.mod h1:W7rrNRChAEChX336QF7bnMxbsjugcOCPU44i5kbLiL8= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/run v0.8.0/go.mod h1:VniEnuBwqjigv0A7ONfQUaEItaiCRVujlMqerPPiktM= +cloud.google.com/go/run v0.9.0/go.mod h1:Wwu+/vvg8Y+JUApMwEDfVfhetv30hCG4ZwDR/IXl2Qg= +cloud.google.com/go/run v1.2.0/go.mod h1:36V1IlDzQ0XxbQjUx6IYbw8H3TJnWvhii963WW3B/bo= +cloud.google.com/go/run v1.3.0/go.mod h1:S/osX/4jIPZGg+ssuqh6GNgg7syixKe3YnprwehzHKU= +cloud.google.com/go/run v1.3.1/go.mod h1:cymddtZOzdwLIAsmS6s+Asl4JoXIDm/K1cpZTxV4Q5s= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/scheduler v1.8.0/go.mod h1:TCET+Y5Gp1YgHT8py4nlg2Sew8nUHMqcpousDgXJVQc= +cloud.google.com/go/scheduler v1.9.0/go.mod h1:yexg5t+KSmqu+njTIh3b7oYPheFtBWGcbVUYF1GGMIc= +cloud.google.com/go/scheduler v1.10.1/go.mod h1:R63Ldltd47Bs4gnhQkmNDse5w8gBRrhObZ54PxgR2Oo= +cloud.google.com/go/scheduler v1.10.2/go.mod h1:O3jX6HRH5eKCA3FutMw375XHZJudNIKVonSCHv7ropY= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/secretmanager v1.10.0/go.mod h1:MfnrdvKMPNra9aZtQFvBcvRU54hbPD8/HayQdlUgJpU= +cloud.google.com/go/secretmanager v1.11.1/go.mod h1:znq9JlXgTNdBeQk9TBW/FnR/W4uChEKGeqQWAJ8SXFw= +cloud.google.com/go/secretmanager v1.11.2/go.mod h1:MQm4t3deoSub7+WNwiC4/tRYgDBHJgJPvswqQVB1Vss= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/security v1.12.0/go.mod h1:rV6EhrpbNHrrxqlvW0BWAIawFWq3X90SduMJdFwtLB8= +cloud.google.com/go/security v1.13.0/go.mod h1:Q1Nvxl1PAgmeW0y3HTt54JYIvUdtcpYKVfIB8AOMZ+0= +cloud.google.com/go/security v1.15.1/go.mod h1:MvTnnbsWnehoizHi09zoiZob0iCHVcL4AUBj76h9fXA= +cloud.google.com/go/security v1.15.2/go.mod h1:2GVE/v1oixIRHDaClVbHuPcZwAqFM28mXuAKCfMgYIg= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/securitycenter v1.18.1/go.mod h1:0/25gAzCM/9OL9vVx4ChPeM/+DlfGQJDwBy/UC8AKK0= +cloud.google.com/go/securitycenter v1.19.0/go.mod h1:LVLmSg8ZkkyaNy4u7HCIshAngSQ8EcIRREP3xBnyfag= +cloud.google.com/go/securitycenter v1.23.0/go.mod h1:8pwQ4n+Y9WCWM278R8W3nF65QtY172h4S8aXyI9/hsQ= +cloud.google.com/go/securitycenter v1.23.1/go.mod h1:w2HV3Mv/yKhbXKwOCu2i8bCuLtNP1IMHuiYQn4HJq5s= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicecontrol v1.10.0/go.mod h1:pQvyvSRh7YzUF2efw7H87V92mxU8FnFDawMClGCNuAA= +cloud.google.com/go/servicecontrol v1.11.0/go.mod h1:kFmTzYzTUIuZs0ycVqRHNaNhgR+UMUpw9n02l/pY+mc= +cloud.google.com/go/servicecontrol v1.11.1/go.mod h1:aSnNNlwEFBY+PWGQ2DoM0JJ/QUXqV5/ZD9DOLB7SnUk= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicedirectory v1.8.0/go.mod h1:srXodfhY1GFIPvltunswqXpVxFPpZjf8nkKQT7XcXaY= +cloud.google.com/go/servicedirectory v1.9.0/go.mod h1:29je5JjiygNYlmsGz8k6o+OZ8vd4f//bQLtvzkPPT/s= +cloud.google.com/go/servicedirectory v1.10.1/go.mod h1:Xv0YVH8s4pVOwfM/1eMTl0XJ6bzIOSLDt8f8eLaGOxQ= +cloud.google.com/go/servicedirectory v1.11.0/go.mod h1:Xv0YVH8s4pVOwfM/1eMTl0XJ6bzIOSLDt8f8eLaGOxQ= +cloud.google.com/go/servicedirectory v1.11.1/go.mod h1:tJywXimEWzNzw9FvtNjsQxxJ3/41jseeILgwU/QLrGI= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/servicemanagement v1.6.0/go.mod h1:aWns7EeeCOtGEX4OvZUWCCJONRZeFKiptqKf1D0l/Jc= +cloud.google.com/go/servicemanagement v1.8.0/go.mod h1:MSS2TDlIEQD/fzsSGfCdJItQveu9NXnUniTrq/L8LK4= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/serviceusage v1.5.0/go.mod h1:w8U1JvqUqwJNPEOTQjrMHkw3IaIFLoLsPLvsE3xueec= +cloud.google.com/go/serviceusage v1.6.0/go.mod h1:R5wwQcbOWsyuOfbP9tGdAnCAc6B9DRwPG1xtWMDeuPA= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/shell v1.6.0/go.mod h1:oHO8QACS90luWgxP3N9iZVuEiSF84zNyLytb+qE2f9A= +cloud.google.com/go/shell v1.7.1/go.mod h1:u1RaM+huXFaTojTbW4g9P5emOrrmLE69KrxqQahKn4g= +cloud.google.com/go/shell v1.7.2/go.mod h1:KqRPKwBV0UyLickMn0+BY1qIyE98kKyI216sH/TuHmc= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/spanner v1.44.0/go.mod h1:G8XIgYdOK+Fbcpbs7p2fiprDw4CaZX63whnSMLVBxjk= +cloud.google.com/go/spanner v1.45.0/go.mod h1:FIws5LowYz8YAE1J8fOS7DJup8ff7xJeetWEo5REA2M= +cloud.google.com/go/spanner v1.47.0/go.mod h1:IXsJwVW2j4UKs0eYDqodab6HgGuA1bViSqW4uH9lfUI= +cloud.google.com/go/spanner v1.49.0/go.mod h1:eGj9mQGK8+hkgSVbHNQ06pQ4oS+cyc4tXXd6Dif1KoM= +cloud.google.com/go/spanner v1.50.0/go.mod h1:eGj9mQGK8+hkgSVbHNQ06pQ4oS+cyc4tXXd6Dif1KoM= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= +cloud.google.com/go/speech v1.14.1/go.mod h1:gEosVRPJ9waG7zqqnsHpYTOoAS4KouMRLDFMekpJ0J0= +cloud.google.com/go/speech v1.15.0/go.mod h1:y6oH7GhqCaZANH7+Oe0BhgIogsNInLlz542tg3VqeYI= +cloud.google.com/go/speech v1.17.1/go.mod h1:8rVNzU43tQvxDaGvqOhpDqgkJTFowBpDvCJ14kGlJYo= +cloud.google.com/go/speech v1.19.0/go.mod h1:8rVNzU43tQvxDaGvqOhpDqgkJTFowBpDvCJ14kGlJYo= +cloud.google.com/go/speech v1.19.1/go.mod h1:WcuaWz/3hOlzPFOVo9DUsblMIHwxP589y6ZMtaG+iAA= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storage v1.28.1/go.mod h1:Qnisd4CqDdo6BGs2AD5LLnEsmSQ80wQ5ogcBBKhU86Y= +cloud.google.com/go/storage v1.29.0/go.mod h1:4puEjyTKnku6gfKoTfNOU/W+a9JyuVNxjpS5GBrB8h4= +cloud.google.com/go/storage v1.30.1/go.mod h1:NfxhC0UJE1aXSx7CIIbCf7y9HKT7BiccwkR7+P7gN8E= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/storagetransfer v1.7.0/go.mod h1:8Giuj1QNb1kfLAiWM1bN6dHzfdlDAVC9rv9abHot2W4= +cloud.google.com/go/storagetransfer v1.8.0/go.mod h1:JpegsHHU1eXg7lMHkvf+KE5XDJ7EQu0GwNJbbVGanEw= +cloud.google.com/go/storagetransfer v1.10.0/go.mod h1:DM4sTlSmGiNczmV6iZyceIh2dbs+7z2Ayg6YAiQlYfA= +cloud.google.com/go/storagetransfer v1.10.1/go.mod h1:rS7Sy0BtPviWYTTJVWCSV4QrbBitgPeuK4/FKa4IdLs= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/talent v1.5.0/go.mod h1:G+ODMj9bsasAEJkQSzO2uHQWXHHXUomArjWQQYkqK6c= +cloud.google.com/go/talent v1.6.2/go.mod h1:CbGvmKCG61mkdjcqTcLOkb2ZN1SrQI8MDyma2l7VD24= +cloud.google.com/go/talent v1.6.3/go.mod h1:xoDO97Qd4AK43rGjJvyBHMskiEf3KulgYzcH6YWOVoo= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/texttospeech v1.6.0/go.mod h1:YmwmFT8pj1aBblQOI3TfKmwibnsfvhIBzPXcW4EBovc= +cloud.google.com/go/texttospeech v1.7.1/go.mod h1:m7QfG5IXxeneGqTapXNxv2ItxP/FS0hCZBwXYqucgSk= +cloud.google.com/go/texttospeech v1.7.2/go.mod h1:VYPT6aTOEl3herQjFHYErTlSZJ4vB00Q2ZTmuVgluD4= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/tpu v1.5.0/go.mod h1:8zVo1rYDFuW2l4yZVY0R0fb/v44xLh3llq7RuV61fPM= +cloud.google.com/go/tpu v1.6.1/go.mod h1:sOdcHVIgDEEOKuqUoi6Fq53MKHJAtOwtz0GuKsWSH3E= +cloud.google.com/go/tpu v1.6.2/go.mod h1:NXh3NDwt71TsPZdtGWgAG5ThDfGd32X1mJ2cMaRlVgU= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/trace v1.8.0/go.mod h1:zH7vcsbAhklH8hWFig58HvxcxyQbaIqMarMg9hn5ECA= +cloud.google.com/go/trace v1.9.0/go.mod h1:lOQqpE5IaWY0Ixg7/r2SjixMuc6lfTFeO4QGM4dQWOk= +cloud.google.com/go/trace v1.10.1/go.mod h1:gbtL94KE5AJLH3y+WVpfWILmqgc6dXcqgNXdOPAQTYk= +cloud.google.com/go/trace v1.10.2/go.mod h1:NPXemMi6MToRFcSxRl2uDnu/qAlAQ3oULUphcHGh1vA= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/translate v1.5.0/go.mod h1:29YDSYveqqpA1CQFD7NQuP49xymq17RXNaUDdc0mNu0= +cloud.google.com/go/translate v1.6.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/translate v1.7.0/go.mod h1:lMGRudH1pu7I3n3PETiOB2507gf3HnfLV8qlkHZEyos= +cloud.google.com/go/translate v1.8.1/go.mod h1:d1ZH5aaOA0CNhWeXeC8ujd4tdCFw8XoNWRljklu5RHs= +cloud.google.com/go/translate v1.8.2/go.mod h1:d1ZH5aaOA0CNhWeXeC8ujd4tdCFw8XoNWRljklu5RHs= +cloud.google.com/go/translate v1.9.0/go.mod h1:d1ZH5aaOA0CNhWeXeC8ujd4tdCFw8XoNWRljklu5RHs= +cloud.google.com/go/translate v1.9.1/go.mod h1:TWIgDZknq2+JD4iRcojgeDtqGEp154HN/uL6hMvylS8= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/video v1.12.0/go.mod h1:MLQew95eTuaNDEGriQdcYn0dTwf9oWiA4uYebxM5kdg= +cloud.google.com/go/video v1.13.0/go.mod h1:ulzkYlYgCp15N2AokzKjy7MQ9ejuynOJdf1tR5lGthk= +cloud.google.com/go/video v1.14.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/video v1.15.0/go.mod h1:SkgaXwT+lIIAKqWAJfktHT/RbgjSuY6DobxEp0C5yTQ= +cloud.google.com/go/video v1.17.1/go.mod h1:9qmqPqw/Ib2tLqaeHgtakU+l5TcJxCJbhFXM7UJjVzU= +cloud.google.com/go/video v1.19.0/go.mod h1:9qmqPqw/Ib2tLqaeHgtakU+l5TcJxCJbhFXM7UJjVzU= +cloud.google.com/go/video v1.20.0/go.mod h1:U3G3FTnsvAGqglq9LxgqzOiBc/Nt8zis8S+850N2DUM= +cloud.google.com/go/video v1.20.1/go.mod h1:3gJS+iDprnj8SY6pe0SwLeC5BUW80NjhwX7INWEuWGU= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/videointelligence v1.10.0/go.mod h1:LHZngX1liVtUhZvi2uNS0VQuOzNi2TkY1OakiuoUOjU= +cloud.google.com/go/videointelligence v1.11.1/go.mod h1:76xn/8InyQHarjTWsBR058SmlPCwQjgcvoW0aZykOvo= +cloud.google.com/go/videointelligence v1.11.2/go.mod h1:ocfIGYtIVmIcWk1DsSGOoDiXca4vaZQII1C85qtoplc= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vision/v2 v2.6.0/go.mod h1:158Hes0MvOS9Z/bDMSFpjwsUrZ5fPrdwuyyvKSGAGMY= +cloud.google.com/go/vision/v2 v2.7.0/go.mod h1:H89VysHy21avemp6xcf9b9JvZHVehWbET0uT/bcuY/0= +cloud.google.com/go/vision/v2 v2.7.2/go.mod h1:jKa8oSYBWhYiXarHPvP4USxYANYUEdEsQrloLjrSwJU= +cloud.google.com/go/vision/v2 v2.7.3/go.mod h1:V0IcLCY7W+hpMKXK1JYE0LV5llEqVmj+UJChjvA1WsM= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmmigration v1.5.0/go.mod h1:E4YQ8q7/4W9gobHjQg4JJSgXXSgY21nA5r8swQV+Xxc= +cloud.google.com/go/vmmigration v1.6.0/go.mod h1:bopQ/g4z+8qXzichC7GW1w2MjbErL54rk3/C843CjfY= +cloud.google.com/go/vmmigration v1.7.1/go.mod h1:WD+5z7a/IpZ5bKK//YmT9E047AD+rjycCAvyMxGJbro= +cloud.google.com/go/vmmigration v1.7.2/go.mod h1:iA2hVj22sm2LLYXGPT1pB63mXHhrH1m/ruux9TwWLd8= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vmwareengine v0.2.2/go.mod h1:sKdctNJxb3KLZkE/6Oui94iw/xs9PRNC2wnNLXsHvH8= +cloud.google.com/go/vmwareengine v0.3.0/go.mod h1:wvoyMvNWdIzxMYSpH/R7y2h5h3WFkx6d+1TIsP39WGY= +cloud.google.com/go/vmwareengine v0.4.1/go.mod h1:Px64x+BvjPZwWuc4HdmVhoygcXqEkGHXoa7uyfTgSI0= +cloud.google.com/go/vmwareengine v1.0.0/go.mod h1:Px64x+BvjPZwWuc4HdmVhoygcXqEkGHXoa7uyfTgSI0= +cloud.google.com/go/vmwareengine v1.0.1/go.mod h1:aT3Xsm5sNx0QShk1Jc1B8OddrxAScYLwzVoaiXfdzzk= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/vpcaccess v1.6.0/go.mod h1:wX2ILaNhe7TlVa4vC5xce1bCnqE3AeH27RV31lnmZes= +cloud.google.com/go/vpcaccess v1.7.1/go.mod h1:FogoD46/ZU+JUBX9D606X21EnxiszYi2tArQwLY4SXs= +cloud.google.com/go/vpcaccess v1.7.2/go.mod h1:mmg/MnRHv+3e8FJUjeSibVFvQF1cCy2MsFaFqxeY1HU= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/webrisk v1.8.0/go.mod h1:oJPDuamzHXgUc+b8SiHRcVInZQuybnvEW72PqTc7sSg= +cloud.google.com/go/webrisk v1.9.1/go.mod h1:4GCmXKcOa2BZcZPn6DCEvE7HypmEJcJkr4mtM+sqYPc= +cloud.google.com/go/webrisk v1.9.2/go.mod h1:pY9kfDgAqxUpDBOrG4w8deLfhvJmejKB0qd/5uQIPBc= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/websecurityscanner v1.5.0/go.mod h1:Y6xdCPy81yi0SQnDY1xdNTNpfY1oAgXUlcfN3B3eSng= +cloud.google.com/go/websecurityscanner v1.6.1/go.mod h1:Njgaw3rttgRHXzwCB8kgCYqv5/rGpFCsBOvPbYgszpg= +cloud.google.com/go/websecurityscanner v1.6.2/go.mod h1:7YgjuU5tun7Eg2kpKgGnDuEOXWIrh8x8lWrJT4zfmas= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= +cloud.google.com/go/workflows v1.10.0/go.mod h1:fZ8LmRmZQWacon9UCX1r/g/DfAXx5VcPALq2CxzdePw= +cloud.google.com/go/workflows v1.11.1/go.mod h1:Z+t10G1wF7h8LgdY/EmRcQY8ptBD/nvofaL6FqlET6g= +cloud.google.com/go/workflows v1.12.0/go.mod h1:PYhSk2b6DhZ508tj8HXKaBh+OFe+xdl0dHF/tJdzPQM= +cloud.google.com/go/workflows v1.12.1/go.mod h1:5A95OhD/edtOhQd/O741NSfIMezNTbCwLM1P1tBRGHM= +collectd.org v0.3.0/go.mod h1:A/8DzQBkF6abtvrT2j/AU/4tiBgJWYyh0y/oB/4MlWE= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= -github.com/Azure/azure-pipeline-go v0.2.1/go.mod h1:UGSo8XybXnIGZ3epmeBw7Jdz+HiUVpqIlpz/HKHylF4= -github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuIlp9AfUH5G1tvCHc= -github.com/Azure/azure-storage-blob-go v0.7.0/go.mod h1:f9YQKtsG1nMisotuTPpO0tjNuEjKRYAcJU8/ydDI++4= -github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= -github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0= -github.com/Azure/go-autorest/autorest/adal v0.8.0/go.mod h1:Z6vX6WXXuyieHAXwMj0S6HY6e6wcHn37qQMBQlvY3lc= -github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA= -github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g= -github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM= -github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc= -github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk= +gioui.org v0.0.0-20210308172011-57750fc8a0a6/go.mod h1:RSH6KIUZ0p2xy5zHDxgAM4zumjgTw83q2ge/PI+yyw8= +git.sr.ht/~sbinet/gg v0.3.1/go.mod h1:KGYtlADtqsqANL9ueOFkWymvzUvLMQllU5Ixo+8v3pc= +github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= +github.com/Azure/azure-sdk-for-go/sdk/azcore v0.21.1/go.mod h1:fBF9PQNqB8scdgpZ3ufzaLntG0AG7C1WjPMsiFOmfHM= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.0.0/go.mod h1:uGG2W01BaETf0Ozp+QxxKJdMBNRWPdstHG0Fmdwn1/U= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q= +github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.0.0/go.mod h1:+6sju8gk8FRmSajX3Oz4G5Gm7P+mbqE9FVaXXFYTkCM= +github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0/go.mod h1:OQeznEEkTZ9OrhHJoDD8ZDq51FHgXjqtP9z6bEwBq9U= +github.com/Azure/azure-sdk-for-go/sdk/internal v0.8.3/go.mod h1:KLF4gFr6DcKFZwSuH8w8yEK6DpFl3LP5rhdvAb7Yz5I= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.0.0/go.mod h1:eWRD7oawr1Mu1sLCawqVc0CUiF43ia3qQMxLscsKQ9w= +github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0/go.mod h1:okt5dMMTOFjX/aovMlrjvvXoPMBVSPzk9185BT0+eZM= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/internal v1.0.0/go.mod h1:ceIuwmxDWptoW3eCqSXlnPsZFKh4X+R38dWPv7GS9Vs= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.0.0/go.mod h1:s1tW/At+xHqjNFvWU4G0c0Qv33KOhvbGNj0RCTQDV8s= +github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.2.0/go.mod h1:c+Lifp3EDEamAkPVzMooRNOK6CZjNSdEnf1A7jsI9u4= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v0.3.0/go.mod h1:tPaiy8S5bQ+S5sOiDlINkp7+Ef339+Nz5L5XO+cnOHo= +github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.2.0/go.mod h1:+6KLcKIVgxoBDMqMO/Nvy7bZ9a0nbU3I1DtFQK3YvB4= +github.com/AzureAD/microsoft-authentication-library-for-go v0.4.0/go.mod h1:Vt9sXTKwMyGcOxSmLDMnGPgqsUg7m8pe215qMLrDXw4= +github.com/AzureAD/microsoft-authentication-library-for-go v1.0.0/go.mod h1:kgDmCTgBzIEPFElEF+FK0SdjAor06dRq2Go927dnQ6o= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= +github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +github.com/CloudyKit/fastprinter v0.0.0-20170127035650-74b38d55f37a/go.mod h1:EFZQ978U7x8IRnstaskI3IysnWY5Ao3QgZUKOXlsAdw= +github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno= +github.com/CloudyKit/jet v2.1.3-0.20180809161101-62edd43e4f88+incompatible/go.mod h1:HPYO+50pSWkPoj9Q/eq0aRGByCL6ScRlUmiEX5Zgm+w= +github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo= +github.com/DATA-DOG/go-sqlmock v1.3.3/go.mod h1:f/Ixk793poVmq4qj/V1dPUg2JEAKC73Q5eFN3EC/SaM= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8= +github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/GoogleCloudPlatform/cloudsql-proxy v0.0.0-20190129172621-c8b1d7a94ddf/go.mod h1:aJ4qN3TfrelA6NZ6AXsXRfmEVaYin3EDbSPJrKS8OXo= +github.com/HdrHistogram/hdrhistogram-go v1.1.2/go.mod h1:yDgFjdqOqDEKOvasDdhWNXYg9BVp4O+o5f6V/ehm6Oo= +github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk= +github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY= +github.com/Joker/jade v1.0.1-0.20190614124447-d475f43051e7/go.mod h1:6E6s8o2AE4KhCrqr6GRJjdC/gNfTdxkIXvuGZZda2VM= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/OneOfOne/xxhash v1.2.5 h1:zl/OfRA6nftbBK9qTohYBJ5xvw6C/oNKizR7cZGl3cI= -github.com/OneOfOne/xxhash v1.2.5/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q= +github.com/OneOfOne/xxhash v1.2.8 h1:31czK/TI9sNkxIKfaUfGlU47BAxQ0ztGgd9vPyqimf8= +github.com/SaveTheRbtz/mph v0.1.1-0.20240117162131-4166ec7869bc h1:DCHzPQOcU/7gwDTWbFQZc5qHMPS1g0xTO56k8NXsv9M= +github.com/SaveTheRbtz/mph v0.1.1-0.20240117162131-4166ec7869bc/go.mod h1:LJM5a3zcIJ/8TmZwlUczvROEJT8ntOdhdG9jjcR1B0I= +github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0= github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= -github.com/VictoriaMetrics/fastcache v1.5.3/go.mod h1:+jv9Ckb+za/P1ZRg/sulP5Ni1v49daAVERr0H3CuscE= -github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +github.com/aclements/go-gg v0.0.0-20170118225347-6dbb4e4fefb0/go.mod h1:55qNq4vcpkIuHowELi5C8e+1yUHtoLoOUR9QU5j7Tes= +github.com/aclements/go-moremath v0.0.0-20210112150236-f10218a38794/go.mod h1:7e+I0LQFUI9AXWxOfsQROs9xPhoJtbsyWcjJqDd4KPY= +github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY= +github.com/ajstarks/deck v0.0.0-20200831202436-30c9fc6549a9/go.mod h1:JynElWSGnm/4RlzPXRlREEwqTHAN3T56Bv2ITsFT3gY= +github.com/ajstarks/deck/generate v0.0.0-20210309230005-c3f852c02e19/go.mod h1:T13YZdzov6OU0A1+RfKZiZN9ca6VeKdBdyDV+BY97Tk= github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= +github.com/ajstarks/svgo v0.0.0-20210923152817-c3b6e2f0c527/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw= +github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b/go.mod h1:1KcenG0jGWcpt8ov532z81sp/kMMUG485J2InIOyADM= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8= github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= +github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= -github.com/aristanetworks/goarista v0.0.0-20170210015632-ea17b1a17847/go.mod h1:D/tb0zPVXnP7fmsLZjtdUhSsumbK/ij54UXjjVgMGxQ= +github.com/apache/arrow/go/arrow v0.0.0-20191024131854-af6fa24be0db/go.mod h1:VTxUBvSJ3s3eHAg65PNgrsn5BtqCRPdmyXh6rAfdxN0= +github.com/apache/arrow/go/v10 v10.0.1/go.mod h1:YvhnlEePVnBS4+0z3fhPfUy7W1Ikj0Ih0vcRo/gZ1M0= +github.com/apache/arrow/go/v11 v11.0.0/go.mod h1:Eg5OsL5H+e299f7u5ssuXsuHQVEGC4xei5aX110hRiI= +github.com/apache/arrow/go/v12 v12.0.0/go.mod h1:d+tV/eHZZ7Dz7RPrFKtPK02tpr+c9/PEd/zm8mDS9Vg= +github.com/apache/thrift v0.16.0/go.mod h1:PHK3hniurgQaNMZYaCLEqXKsYK8upmhPbmdP2FXSqgU= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/aws/aws-sdk-go-v2 v1.2.0/go.mod h1:zEQs02YRBw1DjK0PoJv3ygDYOFTre1ejlJWl8FwAuQo= +github.com/aws/aws-sdk-go-v2 v1.21.2/go.mod h1:ErQhvNuEMhJjweavOYhxVkn2RUx7kQXVATHrjKtxIpM= +github.com/aws/aws-sdk-go-v2 v1.23.1/go.mod h1:i1XDttT4rnf6vxc9AuskLc6s7XBee8rlLilKlc03uAA= +github.com/aws/aws-sdk-go-v2/config v1.1.1/go.mod h1:0XsVy9lBI/BCXm+2Tuvt39YmdHwS5unDQmxZOYe8F5Y= +github.com/aws/aws-sdk-go-v2/config v1.18.45/go.mod h1:ZwDUgFnQgsazQTnWfeLWk5GjeqTQTL8lMkoE1UXzxdE= +github.com/aws/aws-sdk-go-v2/config v1.25.5/go.mod h1:Bf4gDvy4ZcFIK0rqDu1wp9wrubNba2DojiPB2rt6nvI= +github.com/aws/aws-sdk-go-v2/credentials v1.1.1/go.mod h1:mM2iIjwl7LULWtS6JCACyInboHirisUUdkBPoTHMOUo= +github.com/aws/aws-sdk-go-v2/credentials v1.13.43/go.mod h1:zWJBz1Yf1ZtX5NGax9ZdNjhhI4rgjfgsyk6vTY1yfVg= +github.com/aws/aws-sdk-go-v2/credentials v1.16.4/go.mod h1:Kdh/okh+//vQ/AjEt81CjvkTo64+/zIE4OewP7RpfXk= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.0.2/go.mod h1:3hGg3PpiEjHnrkrlasTfxFqUsZ2GCk/fMUn4CbKgSkM= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.13/go.mod h1:f/Ib/qYjhV2/qdsf79H3QP/eRE4AkVyEf6sk7XfZ1tg= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.14.5/go.mod h1:VhnExhw6uXy9QzetvpXDolo1/hjhx4u9qukBGkuUwjs= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.43/go.mod h1:auo+PiyLl0n1l8A0e8RIeR8tOzYPfZZH/JNlrJ8igTQ= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.2.4/go.mod h1:xEhvbJcyUf/31yfGSQBe01fukXwXJ0gxDp7rLfymWE0= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.37/go.mod h1:Qe+2KtKml+FEsQF/DHmDV+xjtche/hwoF75EG4UlHW8= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.5.4/go.mod h1:dYvTNAggxDZy6y1AF7YDwXsPuHFy/VNEpEI/2dWK9IU= +github.com/aws/aws-sdk-go-v2/internal/ini v1.3.45/go.mod h1:lD5M20o09/LCuQ2mE62Mb/iSdSlCNuj6H5ci7tW7OsE= +github.com/aws/aws-sdk-go-v2/internal/ini v1.7.1/go.mod h1:6fQQgfuGmw8Al/3M2IgIllycxV7ZW7WCdVSqfBeUiCY= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.10.1/go.mod h1:l9ymW25HOqymeU2m1gbUQ3rUIsTwKs8gYHXkqDQUhiI= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.0.2/go.mod h1:45MfaXZ0cNbeuT0KQ1XJylq8A6+OpVV2E5kvY/Kq+u8= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.37/go.mod h1:vBmDnwWXWxNPFRMmG2m/3MKOe+xEcMDo1tanpaWCcck= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.10.4/go.mod h1:aYCGNjyUCUelhofxlZyj63srdxWUSsBSGg5l6MCuXuE= +github.com/aws/aws-sdk-go-v2/service/kms v1.26.3/go.mod h1:N3++/sLV97B8Zliz7KRqNcojOX7iMBZWKiuit5FKtH0= +github.com/aws/aws-sdk-go-v2/service/route53 v1.1.1/go.mod h1:rLiOUrPLW/Er5kRcQ7NkwbjlijluLsrIbu/iyl35RO4= +github.com/aws/aws-sdk-go-v2/service/route53 v1.30.2/go.mod h1:TQZBt/WaQy+zTHoW++rnl8JBrmZ0VO6EUbVua1+foCA= +github.com/aws/aws-sdk-go-v2/service/sso v1.1.1/go.mod h1:SuZJxklHxLAXgLTc1iFXbEWkXs7QRTQpCLGaKIprQW0= +github.com/aws/aws-sdk-go-v2/service/sso v1.15.2/go.mod h1:gsL4keucRCgW+xA85ALBpRFfdSLH4kHOVSnLMSuBECo= +github.com/aws/aws-sdk-go-v2/service/sso v1.17.3/go.mod h1:oA6VjNsLll2eVuUoF2D+CMyORgNzPEW/3PyUdq6WQjI= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.17.3/go.mod h1:a7bHA82fyUXOm+ZSWKU6PIoBxrjSprdLoM8xPYvzYVg= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.20.1/go.mod h1:hHL974p5auvXlZPIjJTblXJpbkfK4klBczlsEaMCGVY= +github.com/aws/aws-sdk-go-v2/service/sts v1.1.1/go.mod h1:Wi0EBZwiz/K44YliU0EKxqTCJGUfYTWXrrBwkq736bM= +github.com/aws/aws-sdk-go-v2/service/sts v1.23.2/go.mod h1:Eows6e1uQEsc4ZaHANmsPRzAKcVDrcmjjWiih2+HUUQ= +github.com/aws/aws-sdk-go-v2/service/sts v1.25.4/go.mod h1:feTnm2Tk/pJxdX+eooEsxvlvTWBvDm6CasRZ+JOs2IY= +github.com/aws/smithy-go v1.1.0/go.mod h1:EzMw8dbp/YJL4A5/sbhGddag+NPT7q084agLbB9LgIw= +github.com/aws/smithy-go v1.15.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= +github.com/aws/smithy-go v1.17.0/go.mod h1:NukqUGpCZIILqqiV0NIjeFh24kd/FAa4beRb6nbIUPE= +github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g= github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= -github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A= +github.com/benbjohnson/clock v1.3.5 h1:VvXlSJBzZpA/zum6Sj74hxwYI2DIxRWuNIoXAzHZz5o= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.5.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo= github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA= -github.com/btcsuite/btcd v0.0.0-20171128150713-2e60448ffcc6/go.mod h1:Dmm/EzmjnCiweXmzRIAiUWCInVmPgjkzgv5k4tVyXiQ= -github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c= +github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps= +github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/boombuler/barcode v1.0.1/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8= +github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU= github.com/btcsuite/btcd/btcec/v2 v2.2.1 h1:xP60mv8fvp+0khmrN0zTdPC3cNm24rfeE6lh2R/Yv3E= github.com/btcsuite/btcd/btcec/v2 v2.2.1/go.mod h1:9/CSmJxmuvqzX9Wh2fXMWToLOHhPd11lSPuIupwTkI8= -github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= -github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= -github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= -github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= -github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= -github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= -github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= -github.com/bytecodealliance/wasmtime-go v0.22.0/go.mod h1:q320gUxqyI8yB+ZqRuaJOEnGkAnHh6WtJjMaT2CW4wI= -github.com/c-bata/go-prompt v0.2.5/go.mod h1:vFnjEGDIIA/Lib7giyE4E9c50Lvl8j0S+7FVlAwDAVw= -github.com/cenkalti/backoff/v4 v4.2.0 h1:HN5dHm3WBOgndBH6E8V0q2jIYIR3s9yglV8k/+MN3u4= -github.com/cenkalti/backoff/v4 v4.2.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2 h1:KdUfX2zKommPRa+PD0sWZUyXe9w277ABlgELO7H04IM= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.2/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/bytecodealliance/wasmtime-go/v7 v7.0.0/go.mod h1:bu6fic7trDt20w+LMooX7j3fsOwv4/ln6j8gAdP6vmA= +github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOCSiVIqS34= +github.com/c-bata/go-prompt v0.2.6/go.mod h1:/LMAke8wD2FsNu9EXNdHxNLbd9MedkPnCdfpU9wwHfY= +github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM= +github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.0.1-0.20190104013014-3767db7a7e18/go.mod h1:HD5P3vAIAh+Y2GAxg0PrPN1P8WkepXGpjbUPDHJqqKM= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/logex v1.2.0/go.mod h1:9+9sk7u7pGNWYMkh0hdiL++6OeibzJccyQU4p4MedaY= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/readline v1.5.0/go.mod h1:x22KAscuvRqlLoK9CsoYsmxoXZMMFVyOl86cAH8qUic= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/chzyer/test v0.0.0-20210722231415-061457976a23/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cloudflare/cloudflare-go v0.10.2-0.20190916151808-a80f83b9add9/go.mod h1:1MxXX1Ux4x6mqPmjkUgTP1CdXIBXKX7T+Jk9Gxrmx+U= +github.com/cloudflare/cloudflare-go v0.14.0/go.mod h1:EnwdgGMaFOruiPZRFSgn+TsQ3hQ7C/YWzIGLeu5c304= +github.com/cloudflare/cloudflare-go v0.79.0/go.mod h1:gkHQf9xEubaQPEuerBuoinR9P8bf8a05Lq0X6WKy1Oc= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230310173818-32f1caf87195/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230428030218-4003588d1b74/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cockroachdb/datadriven v1.0.0/go.mod h1:5Ib8Meh+jk1RlHIXej6Pzevx/NLlNvQB9pmSBZErGA4= +github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/errors v1.6.1/go.mod h1:tm6FTP5G81vwJ5lC0SizQo374JNCOPrHyXGitRJoDqM= +github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= +github.com/cockroachdb/errors v1.9.1 h1:yFVvsI0VxmRShfawbt/laCIDy/mtTqqnvoNgiy5bEV8= +github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk= +github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= +github.com/cockroachdb/logtags v0.0.0-20211118104740-dabe8e521a4f/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ= +github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM= +github.com/consensys/bavard v0.1.8-0.20210406032232-f3452dc9b572/go.mod h1:Bpd0/3mZuaj6Sj+PqrmIquiOKy397AKGThQPaGzNXAQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.4.1-0.20210426202927-39ac3d4b3f1f/go.mod h1:815PAHg3wvysy0SyIqanF8gZ0Y1wjk/hrDHD/iT88+Q= +github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= @@ -131,34 +1130,71 @@ github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1 github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20230601170251-1830d0757c80/go.mod h1:gzbVz57IDJgQ9rLQwfSk696JGWof8ftznEL9GoAv3NI= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4= +github.com/dave/astrid v0.0.0-20170323122508-8c2895878b14/go.mod h1:Sth2QfxfATb/nW4EsrSi2KyJmbcniZ8TgTaji17D6ms= +github.com/dave/brenda v1.1.0/go.mod h1:4wCUr6gSlu5/1Tk7akE5X7UorwiQ8Rij0SKH3/BGMOM= +github.com/dave/courtney v0.3.0/go.mod h1:BAv3hA06AYfNUjfjQr+5gc6vxeBVOupLqrColj+QSD8= +github.com/dave/dst v0.27.2/go.mod h1:jHh6EOibnHgcUW3WjKHisiooEkYwqpHLBSX1iOBhEyc= +github.com/dave/gopackages v0.0.0-20170318123100-46e7023ec56e/go.mod h1:i00+b/gKdIDIxuLDFob7ustLAVqhsZRk2qVZrArELGQ= +github.com/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg= +github.com/dave/jennifer v1.5.0/go.mod h1:4MnyiFIlZS3l5tSDn8VnzE6ffAhYBMB2SZntBsZGUok= +github.com/dave/kerr v0.0.0-20170318121727-bc25dd6abe8e/go.mod h1:qZqlPyPvfsDJt+3wHJ1EvSXDuVjFTK0j2p/ca+gtsb8= +github.com/dave/patsy v0.0.0-20210517141501-957256f50cba/go.mod h1:qfR88CgEGLoiqDaE+xxDCi5QA5v4vUoW0UCX2Nd5Tlc= +github.com/dave/rebecca v0.9.1/go.mod h1:N6XYdMD/OKw3lkF3ywh8Z6wPGuwNFDNtWYEMFWEmXBA= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1owhMVTHFZIlnvd4= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc= +github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo= +github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= +github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y= +github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0= +github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M= +github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw= +github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= github.com/dgraph-io/badger/v2 v2.2007.4 h1:TRWBQg8UrlUhaFdco01nO2uXwzKS7zd+HVdwV/GHc4o= github.com/dgraph-io/badger/v2 v2.2007.4/go.mod h1:vSw/ax2qojzbN6eXHIx6KPKtCSHJN/Uz0X0VPruTIhk= github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E= github.com/dgraph-io/ristretto v0.1.0 h1:Jv3CGQHp9OjuMBSne1485aDpUkTKEcUqF+jm/LuerPI= github.com/dgraph-io/ristretto v0.1.0/go.mod h1:fux0lOrBhrVCJd3lcTHsIJhq1T2rokOu6v9Vcb3Q9ug= github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= +github.com/dgryski/go-bitstream v0.0.0-20180413035011-3522498ce2c8/go.mod h1:VMaSuZ+SZcx/wljOQKvp5srsbCiKDEb6K2wC4+PiBmQ= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA= github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= -github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= +github.com/dlclark/regexp2 v1.7.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/dnaeon/go-vcr v1.1.0/go.mod h1:M7tiix8f0r6mKKJ3Yq/kqU1OYf3MnfmBWVbPx/yU9ko= +github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ= +github.com/docker/docker v1.6.2/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= +github.com/dop251/goja v0.0.0-20211022113120-dc8c55024d06/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk= +github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf/go.mod h1:R9ET47fwRVRPZnOGvHxxhuZcbrMCuiqOz3Rlrh4KSnk= +github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127/go.mod h1:QMWlm50DNe14hD7t24KEqZuUdC9sOTy8W6XbCU1mlw4= +github.com/dop251/goja_nodejs v0.0.0-20210225215109-d91c329300e7/go.mod h1:hn7BA7c8pLvoGndExHudxTDKZ84Pyvv+90pbBjbTz0Y= +github.com/dop251/goja_nodejs v0.0.0-20211022123610-8dd9abb0616d/go.mod h1:DngW8aVqWbuLRMHItjPUyqdj+HWPvnQe8V8y1nDpIbM= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts= +github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= github.com/ef-ds/deque v1.0.4 h1:iFAZNmveMT9WERAkqLJ+oaABF9AcVQ5AjXem/hroniI= github.com/ef-ds/deque v1.0.4/go.mod h1:gXDnTC3yqvBcHbq2lcExjtAcVrOnJCbMcZXmuj8Z4tg= -github.com/elastic/gosigar v0.8.1-0.20180330100440-37f05ff46ffa/go.mod h1:cdorVVzy1fhmEqmtgqkoE3bYtCfSCkVyjTyCIo22xvs= +github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= @@ -167,62 +1203,153 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= +github.com/envoyproxy/go-control-plane v0.11.0/go.mod h1:VnHyVMpzcLvCFt9yUz1UnCwHLhwx1WguiVDV7pTG/tI= +github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f/go.mod h1:sfYdkwUW4BA3PbKjySwjJy+O4Pu0h62rlqCMHNk+K+Q= +github.com/envoyproxy/go-control-plane v0.11.1/go.mod h1:uhMcXKCQMEJHiAb0w+YGefQLaTEw+YhGluxZkrTmD0g= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/ethereum/go-ethereum v1.9.9/go.mod h1:a9TqabFudpDu1nucId+k9S8R9whYaHnGBLKFouA5EAo= -github.com/ethereum/go-ethereum v1.12.1 h1:1kXDPxhLfyySuQYIfRxVBGYuaHdxNNxevA73vjIwsgk= -github.com/ethereum/go-ethereum v1.12.1/go.mod h1:zKetLweqBR8ZS+1O9iJWI8DvmmD2NzD19apjEWDCsnw= -github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= +github.com/envoyproxy/protoc-gen-validate v0.10.0/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss= +github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss= +github.com/envoyproxy/protoc-gen-validate v1.0.1/go.mod h1:0vj8bNkYbSTNS2PIyH87KZaeN4x9zpL9Qt8fQC7d+vs= +github.com/envoyproxy/protoc-gen-validate v1.0.2/go.mod h1:GpiZQP3dDbg4JouG/NNS7QWXpgx6x8QiMKdmN72jogE= +github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw= +github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg= +github.com/ethereum/go-ethereum v1.13.5 h1:U6TCRciCqZRe4FPXmy1sMGxTfuk8P7u2UoinF3VbaFk= +github.com/ethereum/go-ethereum v1.13.5/go.mod h1:yMTu38GSuyxaYzQMViqNmQ1s3cE84abZexQmTgenWk0= +github.com/ethereum/go-ethereum v1.13.10 h1:Ppdil79nN+Vc+mXfge0AuUgmKWuVv4eMqzoIVSdqZek= +github.com/ethereum/go-ethereum v1.13.10/go.mod h1:sc48XYQxCzH3fG9BcrXCOOgQk2JfZzNAmIKnceogzsA= +github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= +github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= +github.com/fjl/gencodec v0.0.0-20220412091415-8bb9e558978c/go.mod h1:AzA8Lj6YtixmJWL+wkKoBGsLWy9gFrAzi4g+5bCKwpY= +github.com/fjl/gencodec v0.0.0-20230517082657-f9840df7b83e/go.mod h1:AzA8Lj6YtixmJWL+wkKoBGsLWy9gFrAzi4g+5bCKwpY= +github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/flosch/pongo2 v0.0.0-20190707114632-bbf5a6c351f4/go.mod h1:T9YF2M40nIgbVgp3rreNmTged+9HrbNTIQf1PsaIiTA= github.com/fogleman/gg v1.2.1-0.20190220221249-0403632d5b90/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= +github.com/fogleman/gg v1.3.0/go.mod h1:R/bRT+9gY/C5z7JzPU0zXsXHKM4/ayA+zqcVNZzPa1k= github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/fxamacker/cbor/v2 v2.2.1-0.20210927235116-3d6d5d1de29b/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo= +github.com/fxamacker/cbor/v2 v2.4.1-0.20220515183430-ad2eae63303f/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo= github.com/fxamacker/cbor/v2 v2.4.1-0.20230228173756-c0c9f774e40c h1:5tm/Wbs9d9r+qZaUFXk59CWDD0+77PBqDREffYkyi5c= github.com/fxamacker/cbor/v2 v2.4.1-0.20230228173756-c0c9f774e40c/go.mod h1:TA1xS00nchWmaBnEIxPSE5oHLuJBAVvqrtAnWBwBCVo= -github.com/fxamacker/circlehash v0.1.0/go.mod h1:3aq3OfVvsWtkWMb6A1owjOQFA+TLsD5FgJflnaQwtMM= github.com/fxamacker/circlehash v0.3.0 h1:XKdvTtIJV9t7DDUtsf0RIpC1OcxZtPbmgIH7ekx28WA= github.com/fxamacker/circlehash v0.3.0/go.mod h1:3aq3OfVvsWtkWMb6A1owjOQFA+TLsD5FgJflnaQwtMM= +github.com/garslo/gogen v0.0.0-20170306192744-1d203ffc1f61/go.mod h1:Q0X6pkwTILDlzrGEckF6HKjXe48EgsY/l7K7vhY4MW8= +github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.0.0-20230607174250-df487255f46b/go.mod h1:CDncRYVRSDqwakm282WEkjfaAj1hxU/v5RXxk5nXOiI= +github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= +github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= +github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c= +github.com/getsentry/sentry-go v0.18.0 h1:MtBW5H9QgdcJabtZcuJG80BMOwaBpkRDZkxRkNC1sN0= +github.com/getsentry/sentry-go v0.18.0/go.mod h1:Kgon4Mby+FJ7ZWHFUAZgVaIa8sxHtnRJRLTXZr51aKQ= +github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= +github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= github.com/glebarez/go-sqlite v1.21.1 h1:7MZyUPh2XTrHS7xNEHQbrhfMZuPSzhkm2A1qgg0y5NY= github.com/glebarez/go-sqlite v1.21.1/go.mod h1:ISs8MF6yk5cL4n/43rSOmVMGJJjHYr7L2MbZZ5Q4E2E= +github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ= +github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc= +github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE= +github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24= +github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= +github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs= +github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-fonts/dejavu v0.1.0/go.mod h1:4Wt4I4OU2Nq9asgDCteaAaWZOV24E+0/Pwo0gppep4g= +github.com/go-fonts/latin-modern v0.2.0/go.mod h1:rQVLdDMK+mK1xscDwsqM5J8U2jrRa3T0ecnM9pNujks= +github.com/go-fonts/latin-modern v0.3.0/go.mod h1:ysEQXnuT/sCDOAONxC7ImeEDVINbltClhasMAqEtRK0= +github.com/go-fonts/liberation v0.1.1/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/liberation v0.2.0/go.mod h1:K6qoJYypsmfVjWg8KOVDQhLc8UDgIK2HYqyqAO9z7GY= +github.com/go-fonts/liberation v0.3.0/go.mod h1:jdJ+cqF+F4SUL2V+qxBth8fvBpBDS7yloUL5Fi8GTGY= +github.com/go-fonts/stix v0.1.0/go.mod h1:w/c1f0ldAUlJmLBvlbkvVXLAD+tAMqobIIQpmnUIzUY= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.12.0 h1:e4o3o3IsBfAKQh5Qbbiqyfu97Ku7jrO/JbohvztANh4= +github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU= +github.com/go-latex/latex v0.0.0-20210118124228-b3d85cf34e07/go.mod h1:CO1AlKB2CSIqUrmQPqA0gdRIlnLEY0gK5JGjh37zN5U= +github.com/go-latex/latex v0.0.0-20210823091927-c0d11ff05a81/go.mod h1:SX0U8uGpxhq9o2S/CELCSUxEWWAuoCUcVCQWv7G2OCk= +github.com/go-latex/latex v0.0.0-20230307184459-12ec69307ad9/go.mod h1:gWuR/CrFDDeVRFQwHPvsv9soJVB/iqymhuZQuJ3a9OM= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logfmt/logfmt v0.5.1 h1:otpy5pqBCBZ1ng9RQ0dPu4PN7ba75Y/aA+UpowDyNVA= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0= github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= +github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8= github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= +github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= +github.com/go-pdf/fpdf v0.5.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= +github.com/go-pdf/fpdf v0.6.0/go.mod h1:HzcnA+A23uwogo0tp9yU+l3V+KXhiESpt1PMayhOh5M= github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg= +github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= -github.com/go-test/deep v1.0.5/go.mod h1:QV8Hv/iy04NyLBxAdO9njL0iVPN1S4d/A3NVv1V36o8= -github.com/go-test/deep v1.1.0 h1:WOcxcdHcvdgThNXjw0t76K42FXTU7HpNQWHpA2HHNlg= -github.com/go-test/deep v1.1.0/go.mod h1:5C2ZWiW0ErCdrYzpqxLbTX7MG14M9iiw8DgHncVwcsE= +github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= +github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= +github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= +github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= +github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= +github.com/goccy/go-json v0.9.11/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= +github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gofrs/uuid v3.3.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= +github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM= +github.com/golang-jwt/jwt v3.2.1+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-jwt/jwt/v4 v4.2.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= +github.com/golang-jwt/jwt/v4 v4.3.0/go.mod h1:/xlHOz8bRuivTWchD4jCa+NbatV+wEUSzwAxVc6locg= +github.com/golang-jwt/jwt/v4 v4.4.3/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= +github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= -github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= +github.com/golang/glog v1.1.2 h1:DVjP2PbBOzHyzA+dn3WhHIq4NdVu3Q+pvivFICf/7fo= +github.com/golang/glog v1.1.2/go.mod h1:zR+okUeTbrL6EL3xHUDxZuEtGv04p5shwip1+mL/rLQ= +github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68= +github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= @@ -235,7 +1362,6 @@ github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2-0.20190517061210-b285ee9cfc6c/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= @@ -253,12 +1379,24 @@ github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golangci/lint-1 v0.0.0-20181222135242-d2cdd8c08219/go.mod h1:/X8TswGSh1pIozq4ZwCfxS0WA5JGXguxk94ar/4c87Y= +github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4= +github.com/gonum/blas v0.0.0-20181208220705-f22b278b28ac/go.mod h1:P32wAyui1PQ58Oce/KYkOqQv8cVw1zAapXOl+dRFGbc= +github.com/gonum/floats v0.0.0-20181209220543-c233463c7e82/go.mod h1:PxC8OnwL11+aosOB5+iEPoV3picfs8tUpkVd0pDo+Kg= +github.com/gonum/internal v0.0.0-20181124074243-f884aa714029/go.mod h1:Pu4dmpkhSyOzRwuXkOgAvijx4o+4YMUJJo9OvPYMkks= +github.com/gonum/lapack v0.0.0-20181123203213-e4cdc5a0bff9/go.mod h1:XA3DeT6rxh2EAE789SSiSJNqxPaC0aE9J8NTOI0Jo/A= +github.com/gonum/matrix v0.0.0-20181209220409-c518dec07be9/go.mod h1:0EXg4mc1CNP0HCqCz+K4ts155PXIlUywf0wqN+GfPZw= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/flatbuffers v1.11.0/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= +github.com/google/flatbuffers v2.0.8+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= @@ -271,11 +1409,22 @@ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-pkcs11 v0.2.0/go.mod h1:6eQoGcuNJpa7jnd5pMGdkSaQpNDYvPlXWMcjXXThLlY= +github.com/google/go-pkcs11 v0.2.1-0.20230907215043-c6f79328ddf9/go.mod h1:6eQoGcuNJpa7jnd5pMGdkSaQpNDYvPlXWMcjXXThLlY= +github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= +github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= +github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= @@ -291,79 +1440,160 @@ github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U= +github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg= +github.com/google/pprof v0.0.0-20230602150820-91b7bce49751 h1:hR7/MlvK23p6+lIw9SN1TigNLn9ZnF3W4SYRKq2gAHs= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/s2a-go v0.1.0/go.mod h1:OJpEgntRZo8ugHpF9hkoLJbS5dSI20XZeXJ9JVywLlM= +github.com/google/s2a-go v0.1.3/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A= +github.com/google/s2a-go v0.1.4/go.mod h1:Ej+mSEMGRnqRzjc7VtF+jdBwYG5fuJfiZ8ELkjEwM0A= +github.com/google/s2a-go v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= +github.com/google/safehtml v0.0.2/go.mod h1:L4KWwDsUJdECRAEpZoBn3O64bQaywRscowZjJAzjHnU= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= +github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU= +github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= +github.com/googleapis/enterprise-certificate-proxy v0.2.1/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.3/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.4/go.mod h1:AwSRAtLfXpU5Nm3pW+v7rGDHp09LsPtGY9MduiEsR9k= +github.com/googleapis/enterprise-certificate-proxy v0.2.5/go.mod h1:RxW0N9901Cko1VOCW3SXCpWP+mlIEkk2tP7jnHy9a3w= +github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= +github.com/googleapis/gax-go v0.0.0-20161107002406-da06d194a00e/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/gax-go/v2 v2.7.1/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/gax-go/v2 v2.8.0/go.mod h1:4orTrqY6hXxxaUL4LHIPl6lGo8vAE38/qKbhSAKP6QI= +github.com/googleapis/gax-go/v2 v2.10.0/go.mod h1:4UOEnMCrxsSqQ940WnTiD6qJ63le2ev3xfyagutxiPw= +github.com/googleapis/gax-go/v2 v2.11.0/go.mod h1:DxmR61SGKkGLa2xigwuZIQpkCI2S5iydzRfb3peWZJI= +github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/gorilla/websocket v1.4.1-0.20190629185528-ae1634f6a989/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= -github.com/graph-gophers/graphql-go v0.0.0-20191115155744-f33e81362277/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= +github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc= +github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/graph-gophers/graphql-go v1.3.0/go.mod h1:9CQHMSxwO4MprSdzoIEobiHpoLtHm77vfxsvsIN5Vuc= +github.com/grpc-ecosystem/go-grpc-middleware v1.0.0 h1:Iju5GlWwrvL6UBg4zJJt3btmonfrMlCDdsejg4CZE7c= github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0 h1:pRhl55Yx1eC7BZ1N+BBWwnKaMyD8uC+34TLdndZMAKk= +github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.1.0/go.mod h1:XKMd7iuf/RGPSMJ/U4HP0zS2Z9Fh8Ps9a+6X26m/tmI= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3 h1:lLT7ZLSzGLI08vc9cpd+tYmNWjdKDqyr/2L+f6U12Fk= github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= -github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU= -github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 h1:Wqo399gCIufwto+VfwCSvsnfGpF/w5E9CNxSwbpD6No= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0/go.mod h1:qmOFXW2epJhM0qSnUUYpldc7gVz2KMQwJ/QYCDIa7XU= +github.com/guptarohit/asciigraph v0.5.5/go.mod h1:dYl5wwK4gNsnFf9Zp+l06rFiDZ5YtXM6x7SRWZ3KGag= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= +github.com/hashicorp/go-hclog v0.9.2/go.mod h1:5CU+agLiy3J7N7QjHK5d05KxGsuXiQLrjA0H7acj2lQ= +github.com/hashicorp/go-hclog v1.2.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= -github.com/hashicorp/golang-lru v0.0.0-20160813221303-0a025b7e63ad/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/go-retryablehttp v0.7.4/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8= +github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs= github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru v1.0.2 h1:dV3g9Z/unq5DpblPpw+Oqcv4dU/1omnb4Ok8iPY6p1c= +github.com/hashicorp/golang-lru v1.0.2/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru/v2 v2.0.2 h1:Dwmkdr5Nc/oBiXgJS3CDHNhJtIHkuZ3DZF5twqnfBdU= +github.com/hashicorp/golang-lru/v2 v2.0.2/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= +github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= +github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc= +github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= +github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= +github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= github.com/holiman/uint256 v1.2.3 h1:K8UWO1HUJpRMXBxbmaY1Y8IAMZC/RsKB+ArEnnK4l5o= github.com/holiman/uint256 v1.2.3/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/huin/goupnp v0.0.0-20161224104101-679507af18f3/go.mod h1:MZ2ZmwcBpvOoJ22IJsc7va19ZwoheaBk43rKg12SKag= +github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/hydrogen18/memlistener v0.0.0-20141126152155-54553eb933fb/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= +github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20220319035150-800ac71e25c2/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= +github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= -github.com/influxdata/influxdb v1.2.3-0.20180221223340-01288bdb0883/go.mod h1:qZna6X/4elxqT3yI9iZYdZrWWdeFOOprn86kgg4+IzY= +github.com/influxdata/flux v0.65.1/go.mod h1:J754/zds0vvpfwuq7Gc2wRdVwEodfpCFM7mYlOw2LqY= +github.com/influxdata/influxdb v1.8.3/go.mod h1:JugdFhsvvI8gadxOI6noqNeeBHvWNTbfYGtiAn+2jhI= +github.com/influxdata/influxdb-client-go/v2 v2.4.0/go.mod h1:vLNHdxTJkIf2mSLvGrpj8TCcISApPoXkaxP8g9uRlW8= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/influxdata/influxql v1.1.1-0.20200828144457-65d3ef77d385/go.mod h1:gHp9y86a/pxhjJ+zMjNXiQAA197Xk9wLxaz+fGG+kWk= +github.com/influxdata/line-protocol v0.0.0-20180522152040-32c6aa80de5e/go.mod h1:4kt73NQhadE3daL3WhR5EJ/J2ocX0PZzwxQ0gXJ7oFE= +github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= +github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= +github.com/influxdata/promql/v2 v2.12.0/go.mod h1:fxOPu+DY0bqCTCECchSRtWfc+0X19ybifQhZoQNF5D8= +github.com/influxdata/roaring v0.4.13-0.20180809181101-fc520f41fab6/go.mod h1:bSgUQ7q5ZLSO+bKBGqJiCBGAl+9DxyW63zLTujjUlOE= +github.com/influxdata/tdigest v0.0.0-20181121200506-bf2b5ad3c0a9/go.mod h1:Js0mqiSBE6Ffsg94weZZ2c+v/ciT8QRHFOap7EKDrR0= +github.com/influxdata/usage-client v0.0.0-20160829180054-6d3895376368/go.mod h1:Wbbw6tYNvwa5dlB6304Sd+82Z3f7PmVZHVKU637d4po= github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs= github.com/ipfs/bbloom v0.0.4/go.mod h1:cS9YprKXpoZ9lT0n/Mw/a6/aFV6DTjTLYHeA+gyqMG0= -github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= -github.com/ipfs/go-block-format v0.0.3 h1:r8t66QstRp/pd/or4dpnbVfXT5Gt7lOqRvC+/dDTpMc= -github.com/ipfs/go-block-format v0.0.3/go.mod h1:4LmD4ZUw0mhO+JSKdpWwrzATiEfM7WWgQ8H5l6P8MVk= -github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= -github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/boxo v0.10.0 h1:tdDAxq8jrsbRkYoF+5Rcqyeb91hgWe2hp7iLu7ORZLY= +github.com/ipfs/boxo v0.17.1-0.20240131173518-89bceff34bf1 h1:5H/HYvdmbxp09+sAvdqJzyrWoyCS6OroeW9Ym06Tb+0= +github.com/ipfs/boxo v0.17.1-0.20240131173518-89bceff34bf1/go.mod h1:pIZgTWdm3k3pLF9Uq6MB8JEcW07UDwNJjlXW1HELW80= +github.com/ipfs/go-block-format v0.1.2 h1:GAjkfhVx1f4YTODS6Esrj1wt2HhrtwTnhEr+DyPUaJo= +github.com/ipfs/go-block-format v0.1.2/go.mod h1:mACVcrxarQKstUU3Yf/RdwbC4DzPV6++rO2a3d+a/KE= +github.com/ipfs/go-block-format v0.2.0 h1:ZqrkxBA2ICbDRbK8KJs/u0O3dlp6gmAuuXUJNiW1Ycs= +github.com/ipfs/go-block-format v0.2.0/go.mod h1:+jpL11nFx5A/SPpsoBn6Bzkra/zaArfSmsknbPMYgzM= github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog= -github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= -github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= -github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= +github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s= +github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/ipfs/go-datastore v0.5.0/go.mod h1:9zhEApYMTl17C8YDp7JmU7sQZi2/wqiYh73hakZ90Bk= github.com/ipfs/go-datastore v0.6.0 h1:JKyz+Gvz1QEZw0LsX1IBn+JFCJQH4SJVFtM4uWU0Myk= github.com/ipfs/go-datastore v0.6.0/go.mod h1:rt5M3nNbSO/8q1t4LNkLyUwRs8HupMeN/8O4Vn9YAT8= github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps= -github.com/ipfs/go-ipfs-blockstore v1.2.0 h1:n3WTeJ4LdICWs/0VSfjHrlqpPpl6MZ+ySd3j8qz0ykw= -github.com/ipfs/go-ipfs-blockstore v1.2.0/go.mod h1:eh8eTFLiINYNSNawfZOC7HOxNTxpB1PFuA5E1m/7exE= +github.com/ipfs/go-ipfs-blockstore v1.3.0 h1:m2EXaWgwTzAfsmt5UdJ7Is6l4gJcaM/A12XwJyvYvMM= +github.com/ipfs/go-ipfs-blockstore v1.3.0/go.mod h1:KgtZyc9fq+P2xJUiCAzbRdhhqJHvsw8u2Dlqy2MyRTE= github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= github.com/ipfs/go-ipfs-ds-help v1.1.0 h1:yLE2w9RAsl31LtfMt91tRZcrx+e61O5mDxFRR994w4Q= github.com/ipfs/go-ipfs-ds-help v1.1.0/go.mod h1:YR5+6EaebOhfcqVCyqemItCLthrpVNot+rsOU/5IatU= -github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= -github.com/ipfs/go-ipld-format v0.3.0 h1:Mwm2oRLzIuUwEPewWAWyMuuBQUsn3awfFEYVb8akMOQ= -github.com/ipfs/go-ipld-format v0.3.0/go.mod h1:co/SdBE8h99968X0hViiw1MNlh6fvxxnHpvVLnH7jSM= -github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= +github.com/ipfs/go-ipfs-util v0.0.3 h1:2RFdGez6bu2ZlZdI+rWfIdbQb1KudQp3VGwPtdNCmE0= +github.com/ipfs/go-ipfs-util v0.0.3/go.mod h1:LHzG1a0Ig4G+iZ26UUOMjHd+lfM84LZCrn17xAKWBvs= +github.com/ipfs/go-ipld-format v0.5.0 h1:WyEle9K96MSrvr47zZHKKcDxJ/vlpET6PSiQsAFO+Ds= +github.com/ipfs/go-ipld-format v0.5.0/go.mod h1:ImdZqJQaEouMjCvqCe0ORUS+uoBmf7Hf+EO/jh+nk3M= +github.com/ipfs/go-ipld-format v0.6.0 h1:VEJlA2kQ3LqFSIm5Vu6eIlSxD/Ze90xtc4Meten1F5U= +github.com/ipfs/go-ipld-format v0.6.0/go.mod h1:g4QVMTn3marU3qXchwjpKPKgJv+zF+OlaKMyhJ4LHPg= github.com/ipfs/go-log v1.0.5 h1:2dOuUCB1Z7uoczMWgAyDck5JLb72zHzrMnGnCNNbvY8= github.com/ipfs/go-log v1.0.5/go.mod h1:j0b8ZoR+7+R99LD9jZ6+AJsrzkPbSXbZfGakb5JPtIo= github.com/ipfs/go-log/v2 v2.1.3/go.mod h1:/8d0SH3Su5Ooc31QlL1WysJhvyOTDCjcCZ9Axpmri6g= @@ -371,211 +1601,446 @@ github.com/ipfs/go-log/v2 v2.5.1 h1:1XdUzF7048prq4aBjDQQ4SL5RxftpRGdXhNRwKSAlcY= github.com/ipfs/go-log/v2 v2.5.1/go.mod h1:prSpmC1Gpllc9UYWxDiZDreBYw7zp4Iqp1kOLU9U5UI= github.com/ipfs/go-metrics-interface v0.0.1 h1:j+cpbjYvu4R8zbleSs36gvB7jR+wsL2fGD6n0jO4kdg= github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY= -github.com/jackpal/go-nat-pmp v1.0.2-0.20160603034137-1fa385a6f458/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= +github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0= +github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0/go.mod h1:pMCz62A0xJL6I+umB2YTlFRwWXaDFA0jy+5HzGiJjqI= +github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= +github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g= +github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA= github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o= github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4= -github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jedisct1/go-minisign v0.0.0-20190909160543-45766022959e/go.mod h1:G1CVv03EnqU1wYL2dFwXxW2An0az9JTl/ZsqXQeBlkU= +github.com/jedisct1/go-minisign v0.0.0-20230811132847-661be99b8267/go.mod h1:h1nSAbGFqGVzn6Jyl1R/iCcBUHN4g+gW1u9CoBTrb9E= +github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo= +github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= -github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= +github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= -github.com/julienschmidt/httprouter v1.1.1-0.20170430222011-975b5c4c7c21/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/jsternberg/zap-logfmt v1.0.0/go.mod h1:uvPs/4X51zdkcm5jXl5SYoN+4RK21K8mysFmDaM/h+o= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/juju/errors v0.0.0-20181118221551-089d3ea4e4d5/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q= +github.com/juju/loggo v0.0.0-20180524022052-584905176618/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U= +github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073/go.mod h1:63prj8cnj0tU0S9OHjGJn+b1h0ZghCndfnbQolrYTwA= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= +github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes= +github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0= +github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 h1:uC1QfSlInpQF+M0ao65imhwqKnz3Q2z/d8PWZRMQvDM= +github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k= github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213/go.mod h1:vNUNkEQ1e29fT/6vq2aBdFsgNPmy8qMdSay1npru+Sw= -github.com/karalabe/usb v0.0.0-20190919080040-51dc0efba356/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU= -github.com/kevinburke/go-bindata v3.22.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= -github.com/kevinburke/go-bindata v3.23.0+incompatible h1:rqNOXZlqrYhMVVAsQx8wuc+LaA73YcfbQ407wAykyS8= +github.com/k0kubun/pp v3.0.1+incompatible h1:3tqvf7QgUnZ5tXO6pNAZlrvHgl6DvifjDrd9g2S9Z40= +github.com/k0kubun/pp v3.0.1+incompatible/go.mod h1:GWse8YhT0p8pT4ir3ZgBbfZild3tgzSScAn6HmfYukg= +github.com/k0kubun/pp/v3 v3.2.0/go.mod h1:ODtJQbQcIRfAD3N+theGCV1m/CBxweERz2dapdz1EwA= +github.com/karalabe/usb v0.0.2/go.mod h1:Od972xHfMJowv7NGVDiWVxk2zxnWgjLlJzE+F4F7AGU= +github.com/kataras/golog v0.0.9/go.mod h1:12HJgwBIZFNGL0EJnMRhmvGA0PQGx8VFwrZtM4CqbAk= +github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8= +github.com/kataras/iris/v12 v12.0.1/go.mod h1:udK4vLQKkdDqMGJJVd/msuMtN6hpYJhg/lSzuxjhO+U= +github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE= +github.com/kataras/neffos v0.0.10/go.mod h1:ZYmJC07hQPW67eKuzlfY7SO3bC0mw83A3j6im82hfqw= +github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE= +github.com/kataras/pio v0.0.0-20190103105442-ea782b38602d/go.mod h1:NV88laa9UiiDuX9AhMbDPkGYSPugBOV6yTZB1l2K9Z0= +github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro= +github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8= +github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51/go.mod h1:CzGEWj7cYgsdH8dAjBGEr58BoE7ScuLd+fwFZ44+/x8= github.com/kevinburke/go-bindata v3.23.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= +github.com/kevinburke/go-bindata v3.24.0+incompatible h1:qajFA3D0pH94OTLU4zcCCKCDgR+Zr2cZK/RPJHDdFoY= +github.com/kevinburke/go-bindata v3.24.0+incompatible/go.mod h1:/pEEZ72flUW2p0yi30bslSp9YqD9pysLxunQDdb2CPM= +github.com/kilic/bls12-381 v0.1.0/go.mod h1:vDTTHJONJ6G+P2R74EhnyotQDTliQDnFEwhdmfzw1ig= github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= +github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= +github.com/klauspost/compress v1.4.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/klauspost/compress v1.9.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg= -github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= +github.com/klauspost/compress v1.15.9/go.mod h1:PhcZ0MbTNciWF3rruxRgKxI5NkcHHrHUDtV4Yw2GlzU= github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= -github.com/klauspost/cpuid/v2 v2.0.4/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= +github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/djlyI= +github.com/klauspost/compress v1.16.5/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4= +github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM= +github.com/klauspost/cpuid v0.0.0-20170728055534-ae7887de9fa5/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek= +github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek= github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.0.12/go.mod h1:g2LTdtYhdyuGPqyWyv7qRAmj1WBqxuObKfj5c0PQa7c= -github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk= -github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +github.com/klauspost/cpuid/v2 v2.2.0/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY= +github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg= +github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/klauspost/cpuid/v2 v2.2.6 h1:ndNyv040zDGIDh8thGkXYjnFtiN02M1PVVF+JE/48xc= +github.com/klauspost/cpuid/v2 v2.2.6/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws= +github.com/klauspost/crc32 v0.0.0-20161016154125-cb6bfca970f6/go.mod h1:+ZoRqAPRLkC4NPOvfYeR5KNOrY6TD+/sAC3HXPZgDYg= +github.com/klauspost/pgzip v1.0.2-0.20170402124221-0bf5dcad4ada/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v0.0.0-20170224010052-a616ab194758/go.mod h1:B69LEHPfb2qLo0BaaOLcbitczOKLWTsrBG9LczfCD4k= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/labstack/echo/v4 v4.1.11/go.mod h1:i541M3Fj6f76NZtHSj7TXnyM8n2gaodfvfxNnFqi74g= +github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4FW1e6jwpg= +github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y= +github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8= github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg= -github.com/libp2p/go-libp2p v0.24.2 h1:iMViPIcLY0D6zr/f+1Yq9EavCZu2i7eDstsr1nEwSAk= -github.com/libp2p/go-libp2p v0.24.2/go.mod h1:WuxtL2V8yGjam03D93ZBC19tvOUiPpewYv1xdFGWu1k= -github.com/libp2p/go-openssl v0.1.0 h1:LBkKEcUv6vtZIQLVTegAil8jbNpJErQ9AnT+bWV+Ooo= -github.com/libp2p/go-openssl v0.1.0/go.mod h1:OiOxwPpL3n4xlenjx2h7AwSGaFSC/KZvf6gNdOBQMtc= -github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= +github.com/libp2p/go-cidranger v1.1.0 h1:ewPN8EZ0dd1LSnrtuwd4709PXVcITVeuwbag38yPW7c= +github.com/libp2p/go-libp2p v0.28.1 h1:YurK+ZAI6cKfASLJBVFkpVBdl3wGhFi6fusOt725ii8= +github.com/libp2p/go-libp2p v0.28.1/go.mod h1:s3Xabc9LSwOcnv9UD4nORnXKTsWkPMkIMB/JIGXVnzk= +github.com/libp2p/go-libp2p v0.32.2 h1:s8GYN4YJzgUoyeYNPdW7JZeZ5Ee31iNaIBfGYMAY4FQ= +github.com/libp2p/go-libp2p v0.32.2/go.mod h1:E0LKe+diV/ZVJVnOJby8VC5xzHF0660osg71skcxJvk= +github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= +github.com/libp2p/go-libp2p-kbucket v0.6.3 h1:p507271wWzpy2f1XxPzCQG9NiN6R6lHL9GiSErbQQo0= +github.com/libp2p/go-libp2p-pubsub v0.9.3 h1:ihcz9oIBMaCK9kcx+yHWm3mLAFBMAUsM4ux42aikDxo= +github.com/libp2p/go-msgio v0.3.0 h1:mf3Z8B1xcFN314sWX+2vOTShIE0Mmn2TXn3YCUQGNj0= github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8= github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= github.com/logrusorgru/aurora/v4 v4.0.0 h1:sRjfPpun/63iADiSvGGjgA1cAYegEWMPCJdUpJYn9JA= github.com/logrusorgru/aurora/v4 v4.0.0/go.mod h1:lP0iIa2nrnT/qoFXcOZSrZQpJ1o6n2CUf/hyHi2Q4ZQ= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star/v2 v2.0.1/go.mod h1:RcCdONR2ScXaYnQC5tUzxzlpA3WVYF7/opLeUgcQs/o= +github.com/lyft/protoc-gen-star/v2 v2.0.3/go.mod h1:amey7yeodaJhXSbf/TlLvWiqQfLOSpEk//mLlc+axEk= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= -github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= -github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= -github.com/mattn/go-ieproxy v0.0.0-20190702010315-6dee0af9227d/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= -github.com/mattn/go-isatty v0.0.5-0.20180830101745-3fb116b82035/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98= -github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= -github.com/mattn/go-pointer v0.0.1 h1:n+XhsuGeVO6MEAp7xyEukFINEa+Quek5psIR/ylA6o0= -github.com/mattn/go-pointer v0.0.1/go.mod h1:2zXcozF6qYGgmsG+SeTZz3oAbFLdD3OWqnUbNvJZAlc= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= -github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU= +github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U= +github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.14.5/go.mod h1:WVKg1VTActs4Qso6iwGbiFih2UIHo0ENGwNd0Lj+XmI= +github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= +github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE= github.com/mattn/go-tty v0.0.3/go.mod h1:ihxohKRERHTVzN+aSVRwACLCeqIoZAWpoICkkvrWyR0= +github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 h1:jWpvCLoY8Z/e3VKvlsiIGKtc+UG6U5vzxaoagmhXfyg= +github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0/go.mod h1:QUyp042oQthUoa9bqDv0ER0wrtXnBruoNd7aNjkbP+k= +github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed/go.mod h1:dSsfyI2zABAdhcbvkXqgxOxrCsbYeHCPgrZkku60dSg= +github.com/mediocregopher/radix/v3 v3.3.0/go.mod h1:EmfVyvspXz1uZEyPBMyGK+kjWiKQGvsUt6O3Pj+LDCQ= +github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8= +github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc= +github.com/miekg/dns v1.1.54 h1:5jon9mWcb0sFJGpnI99tOMhCPyJ+RPVz5b63MQG0VWI= +github.com/minio/asm2plan9s v0.0.0-20200509001527-cdd76441f9d8/go.mod h1:mC1jAcsrzbxHt8iiaC+zU4b1ylILSosueou12R++wfY= github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= -github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= +github.com/minio/c2goasm v0.0.0-20190812172519-36a3d3bbc4f3/go.mod h1:RagcQ7I8IeTMnF8JTXieKnO4Z6JCsikNEzj0DwauVzE= github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= -github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g= -github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ= github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= +github.com/modocache/gover v0.0.0-20171022184752-b58185e213c5/go.mod h1:caMODM3PzxT8aQXRPkAt8xlV/e7d7w8GM5g0fa5F0D8= +github.com/montanaflynn/stats v0.6.6/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= +github.com/montanaflynn/stats v0.7.0/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow= +github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o= github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/mschoch/smat v0.0.0-20160514031455-90eadee771ae/go.mod h1:qAyveg+e4CE+eKJXWVjKXM4ck2QobLqTDytGJbLLhJg= github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE= github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI= -github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0= github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4= -github.com/multiformats/go-multiaddr v0.8.0 h1:aqjksEcqK+iD/Foe1RRFsGZh8+XFiGo7FgUCZlpv3LU= -github.com/multiformats/go-multiaddr v0.8.0/go.mod h1:Fs50eBDWvZu+l3/9S6xAE7ZYj6yhxlvaVZjakWN7xRs= +github.com/multiformats/go-multiaddr v0.9.0 h1:3h4V1LHIk5w4hJHekMKWALPXErDfz/sggzwC/NcqbDQ= +github.com/multiformats/go-multiaddr v0.9.0/go.mod h1:mI67Lb1EeTOYb8GQfL/7wpIZwc46ElrvzhYnoJOmTT0= +github.com/multiformats/go-multiaddr v0.12.2 h1:9G9sTY/wCYajKa9lyfWPmpZAwe6oV+Wb1zcmMS1HG24= +github.com/multiformats/go-multiaddr v0.12.2/go.mod h1:GKyaTYjZRdcUhyOetrxTk9z0cW+jA/YrnqTOvKgi44M= +github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A= github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= -github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc= -github.com/multiformats/go-multibase v0.1.1 h1:3ASCDsuLX8+j4kx58qnJ4YFq/JWTJpCyDW27ztsVTOI= -github.com/multiformats/go-multibase v0.1.1/go.mod h1:ZEjHE+IsUrgp5mhlEAYjMtZwK1k4haNkcaPg9aoe1a8= -github.com/multiformats/go-multicodec v0.7.0 h1:rTUjGOwjlhGHbEMbPoSUJowG1spZTVsITRANCjKTUAQ= -github.com/multiformats/go-multicodec v0.7.0/go.mod h1:GUC8upxSBE4oG+q3kWZRw/+6yC1BqO550bjhWsJbZlw= -github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= +github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g= +github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk= +github.com/multiformats/go-multicodec v0.9.0 h1:pb/dlPnzee/Sxv/j4PmkDRxCOi3hXTz3IbPKOXWJkmg= +github.com/multiformats/go-multicodec v0.9.0/go.mod h1:L3QTQvMIaVBkXOXXtVmYE+LI16i14xuaojr/H7Ai54k= github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= -github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= -github.com/multiformats/go-multihash v0.2.1 h1:aem8ZT0VA2nCHHk7bPJ1BjUbHNciqZC/d16Vve9l108= -github.com/multiformats/go-multihash v0.2.1/go.mod h1:WxoMcYG85AZVQUyRyo9s4wULvW5qrI9vb2Lt6evduFc= +github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U= +github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM= +github.com/multiformats/go-multistream v0.4.1 h1:rFy0Iiyn3YT0asivDUIR05leAdwZq3de4741sbiSdfo= +github.com/multiformats/go-multistream v0.4.1/go.mod h1:Mz5eykRVAjJWckE2U78c6xqdtyNUEhKSM0Lwar2p77Q= +github.com/multiformats/go-multistream v0.5.0 h1:5htLSLl7lvJk3xx3qT/8Zm9J4K8vEOf/QGkvOGQAyiE= +github.com/multiformats/go-multistream v0.5.0/go.mod h1:n6tMZiwiP2wUsR8DgfDWw1dydlEqV3l6N3/GBsX6ILA= github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8= github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/naoina/go-stringutil v0.1.0/go.mod h1:XJ2SJL9jCtBh+P9q5btrd/Ylo8XwT/h1USek5+NqSA0= github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416/go.mod h1:NBIhNtsFMo3G2szEBne+bO4gS192HuIYRqfvOWb4i1E= +github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= +github.com/nats-io/nats.go v1.8.1/go.mod h1:BrFz9vVn0fU3AcH9Vn4Kd7W0NpJ651tD5omQ3M8LwxM= +github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= +github.com/nats-io/nkeys v0.0.2/go.mod h1:dab7URMsZm6Z/jp9Z5UGa87Uutgc2mVpXLC4B7TDb/4= +github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= -github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/olekukonko/tablewriter v0.0.2-0.20190409134802-7e037d187b0c/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= -github.com/onflow/atree v0.1.0-beta1.0.20211027184039-559ee654ece9/go.mod h1:+6x071HgCF/0v5hQcaE5qqjc2UqN5gCU8h5Mk6uqpOg= -github.com/onflow/atree v0.6.0 h1:j7nQ2r8npznx4NX39zPpBYHmdy45f4xwoi+dm37Jk7c= -github.com/onflow/atree v0.6.0/go.mod h1:gBHU0M05qCbv9NN0kijLWMgC47gHVNBIp4KmsVFi0tc= -github.com/onflow/cadence v0.20.1/go.mod h1:7mzUvPZUIJztIbr9eTvs+fQjWWHTF8veC+yk4ihcNIA= -github.com/onflow/cadence v0.39.12 h1:bb3UdOe7nClUcaLbxSWGLSIJKuCrivpgxhPow99ikv0= -github.com/onflow/cadence v0.39.12/go.mod h1:OIJLyVBPa339DCBQXBfGaorT4tBjQh9gSKe+ZAIyyh0= -github.com/onflow/flow-core-contracts/lib/go/contracts v1.2.4-0.20230703193002-53362441b57d h1:B7PdhdUNkve5MVrekWDuQf84XsGBxNZ/D3x+QQ8XeVs= -github.com/onflow/flow-core-contracts/lib/go/contracts v1.2.4-0.20230703193002-53362441b57d/go.mod h1:xAiV/7TKhw863r6iO3CS5RnQ4F+pBY1TxD272BsILlo= -github.com/onflow/flow-core-contracts/lib/go/templates v1.2.3 h1:X25A1dNajNUtE+KoV76wQ6BR6qI7G65vuuRXxDDqX7E= -github.com/onflow/flow-core-contracts/lib/go/templates v1.2.3/go.mod h1:dqAUVWwg+NlOhsuBHex7bEWmsUjsiExzhe/+t4xNH6A= -github.com/onflow/flow-emulator v0.51.2-0.20230704183611-ecad54e231b7 h1:UFcuL4WO1h41vTL6MVBNA6JSeCDrxgHXv2R7617ukeQ= -github.com/onflow/flow-emulator v0.51.2-0.20230704183611-ecad54e231b7/go.mod h1:lwMNonHdLvfTF+YIU3yjz9huy/KSjqu+5exZ/TT7Hvc= -github.com/onflow/flow-go v0.31.1-0.20230704154018-87a84e9d36c2 h1:PxqNnAgtsqPLPVbNzPLOMb4LR8p8FFgHeRqjV5QfF4g= -github.com/onflow/flow-go v0.31.1-0.20230704154018-87a84e9d36c2/go.mod h1:ptH2kC9JMqhZYkLWeGt3cAZblwuURRApTxHD/AvZI3k= -github.com/onflow/flow-go-sdk v0.24.0/go.mod h1:IoptMLPyFXWvyd9yYA6/4EmSeeozl6nJoIv4FaEMg74= -github.com/onflow/flow-go-sdk v0.41.6 h1:x5HhmRDvbCWXRCzHITJxOp0Komq5JJ9zphoR2u6NOCg= -github.com/onflow/flow-go-sdk v0.41.6/go.mod h1:AYypQvn6ecMONhF3M1vBOUX9b4oHKFWkkrw8bO4VEik= -github.com/onflow/flow-go/crypto v0.21.3/go.mod h1:vI6V4CY3R6c4JKBxdcRiR/AnjBfL8OSD97bJc60cLuQ= -github.com/onflow/flow-go/crypto v0.24.7 h1:RCLuB83At4z5wkAyUCF7MYEnPoIIOHghJaODuJyEoW0= -github.com/onflow/flow-go/crypto v0.24.7/go.mod h1:fqCzkIBBMRRkciVrvW21rECKq1oD7Q6u+bCI78lfNX0= -github.com/onflow/flow-nft/lib/go/contracts v1.1.0 h1:rhUDeD27jhLwOqQKI/23008CYfnqXErrJvc4EFRP2a0= -github.com/onflow/flow-nft/lib/go/contracts v1.1.0/go.mod h1:YsvzYng4htDgRB9sa9jxdwoTuuhjK8WYWXTyLkIigZY= -github.com/onflow/flow/protobuf/go/flow v0.2.2/go.mod h1:gQxYqCfkI8lpnKsmIjwtN2mV/N2PIwc1I+RUK4HPIc8= -github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20230602212908-08fc6536d391 h1:6uKg0gpLKpTZKMihrsFR0Gkq++1hykzfR1tQCKuOfw4= -github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20230602212908-08fc6536d391/go.mod h1:NA2pX2nw8zuaxfKphhKsk00kWLwfd+tv8mS23YXO4Sk= -github.com/onflow/fusd/lib/go/contracts v0.0.0-20211021081023-ae9de8fb2c7e h1:RHaXPHvWCy3VM62+HTyu6DYq5T8rrK1gxxqogKuJ4S4= -github.com/onflow/fusd/lib/go/contracts v0.0.0-20211021081023-ae9de8fb2c7e/go.mod h1:CRX9eXtc9zHaRVTW1Xh4Cf5pZgKkQuu1NuSEVyHXr/0= -github.com/onflow/nft-storefront/lib/go/contracts v0.0.0-20221222181731-14b90207cead h1:2j1Unqs76Z1b95Gu4C3Y28hzNUHBix7wL490e61SMSw= -github.com/onflow/nft-storefront/lib/go/contracts v0.0.0-20221222181731-14b90207cead/go.mod h1:E3ScfQb5XcWJCIAdtIeEnr5i5l2y60GT0BTXeIHseWg= -github.com/onflow/sdks v0.5.0 h1:2HCRibwqDaQ1c9oUApnkZtEAhWiNY2GTpRD5+ftdkN8= -github.com/onflow/sdks v0.5.0/go.mod h1:F0dj0EyHC55kknLkeD10js4mo14yTdMotnWMslPirrU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onflow/atree v0.6.1-0.20230711151834-86040b30171f h1:Z8/PgTqOgOg02MTRpTBYO2k16FE6z4wEOtaC2WBR9Xo= +github.com/onflow/atree v0.6.1-0.20230711151834-86040b30171f/go.mod h1:xvP61FoOs95K7IYdIYRnNcYQGf4nbF/uuJ0tHf4DRuM= +github.com/onflow/atree v0.6.1-0.20240308163425-dc825c20b1a2 h1:jJLDswfAVB0bHCu1y1FPdKukPcTNmN+jYEX9S9phbv0= +github.com/onflow/atree v0.6.1-0.20240308163425-dc825c20b1a2/go.mod h1:xvP61FoOs95K7IYdIYRnNcYQGf4nbF/uuJ0tHf4DRuM= +github.com/onflow/atree v0.7.0-rc.1 h1:g2DFhC3JeaA+L7/HZOp4NwE+OfxvfJ8nibymHHw7i3g= +github.com/onflow/atree v0.7.0-rc.1/go.mod h1:xvP61FoOs95K7IYdIYRnNcYQGf4nbF/uuJ0tHf4DRuM= +github.com/onflow/cadence v1.0.0-M3/go.mod h1:odXGZZ/wGNA5mwT8bC9v8u8EXACHllB2ABSZK65TGL8= +github.com/onflow/cadence v1.0.0-M4 h1:/nt3j7vpYDxuI0ghIgAJrb2R01ijvJYZLAkKt+zbpTY= +github.com/onflow/cadence v1.0.0-M4/go.mod h1:odXGZZ/wGNA5mwT8bC9v8u8EXACHllB2ABSZK65TGL8= +github.com/onflow/cadence v1.0.0-M5 h1:vNG7x2KLLrt2yfVr1HtEXUlUi4GdNo+rkXnPkhSzsFA= +github.com/onflow/cadence v1.0.0-M5/go.mod h1:a4mccDU90hmuxCLUFzs9J/ANG/rYbFa36h4Z0bBAqNU= +github.com/onflow/cadence v1.0.0-M8 h1:ioQ7TyhpsIaImAC7Xn2r8kIgIBdimvyuWeKlGfRxWB8= +github.com/onflow/cadence v1.0.0-M8/go.mod h1:a4mccDU90hmuxCLUFzs9J/ANG/rYbFa36h4Z0bBAqNU= +github.com/onflow/cadence v1.0.0-preview.18 h1:1gN+suBexuu1gZz0JjWDC9dcGBI/GIMP8R0Tyou9mzA= +github.com/onflow/cadence v1.0.0-preview.18/go.mod h1:no8+e5V51B9mgfi4U9xdeH+GxcJdoKKDP9gdxEj9Jdg= +github.com/onflow/cadence v1.0.0-preview.25 h1:kSmWjxmg9PS+bsk8C3j1NUTkFAl/jNrintVhlh6miM0= +github.com/onflow/cadence v1.0.0-preview.25/go.mod h1:fGhLBbuEmv5rh48qv0ZS0tUz53gxWsHpB4dPsF09h6E= +github.com/onflow/crypto v0.25.0 h1:BeWbLsh3ZD13Ej+Uky6kg1PL1ZIVBDVX+2MVBNwqddg= +github.com/onflow/crypto v0.25.0/go.mod h1:C8FbaX0x8y+FxWjbkHy0Q4EASCDR9bSPWZqlpCLYyVI= +github.com/onflow/crypto v0.25.1 h1:0txy2PKPMM873JbpxQNbJmuOJtD56bfs48RQfm0ts5A= +github.com/onflow/crypto v0.25.1/go.mod h1:C8FbaX0x8y+FxWjbkHy0Q4EASCDR9bSPWZqlpCLYyVI= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.1-0.20240125214229-b7a95136dd0d h1:Afcfk/9jAQZ1v5PLGdP68FG/0yPPM60fn9Eq8ChBGS0= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.1-0.20240125214229-b7a95136dd0d/go.mod h1:Ts/HN+N0RaYJ6oPCqR1JPaMVFiVaMdKTSUH4OdSjjs0= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240206003101-928bf99024d7 h1:OI/4F2NK/X/4x3dTUFFDGtuOsSa9pX+jjBeSEcBrY/M= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240206003101-928bf99024d7/go.mod h1:GK+Ik1K3L3v8xmHmRQv5yxJz81lYhdYSNm0PQ63Xrws= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240227190927-0e6ce7e3222b h1:oXHQft30sElpK7G3xWB5tEizI2G+S4p64iVh0LtX4E0= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240227190927-0e6ce7e3222b/go.mod h1:At+gEXmy13wpvxHYlS8bqjKEBufL+UXMQpJyHQxiXY8= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240327170024-10241fffd864 h1:Tym6HXbuhoTwef+EfHWDaVgFs/gwmJ0yKD+zjJH1O1s= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240327170024-10241fffd864/go.mod h1:Br3AdtgZlvvk2h4YFJcbCHCJHsM8y0LX1CK+2EdkYR4= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240429192223-e696a8e439b5 h1:by3a+8p2kUUjnxfbRYRd78bDEeXAc3PK2LzyBEQqkV4= +github.com/onflow/flow-core-contracts/lib/go/contracts v0.15.2-0.20240429192223-e696a8e439b5/go.mod h1:+4JWLclBOT+emyBh6NAZSEbqEwzHcWHpIbfsXmRASgY= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.1-0.20240125214229-b7a95136dd0d h1:IQJpP3VLLjT4R8ItBpr+Mmp0IOnC/8iBcM0/67JNB9c= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.1-0.20240125214229-b7a95136dd0d/go.mod h1:MZ2j5YVTQiSE0B99zuaYhxvGG5GcvimWpQK1Fw/1QBg= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240206003101-928bf99024d7 h1:WAx8ftVz1BeXiKvQ9gLKEf1J3NBWK26Pbczd0iH4C6I= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240206003101-928bf99024d7/go.mod h1:MZ2j5YVTQiSE0B99zuaYhxvGG5GcvimWpQK1Fw/1QBg= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240227190927-0e6ce7e3222b h1:oiV9EbViI07FiO4rKeJ5/RGoQDCGd4c6SX/cdMwHbFE= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240227190927-0e6ce7e3222b/go.mod h1:cTE5NCp+Zk04yA24gCEjBdQIrzDU/iRICgLSx4LsGX0= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240327170024-10241fffd864 h1:shtPP46wORFIX3XE+gnvwVUtwejAZm3wye7Y1nJD75A= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240327170024-10241fffd864/go.mod h1:v+SKoOBjMd8c8jspqcnyM1iTejCQq8JaGr6B1XW8Vsw= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240429192223-e696a8e439b5 h1:6Cg0h+8Iyy/Nnefk5j0gdeVoMTNpUooAMjyV8sk6zoA= +github.com/onflow/flow-core-contracts/lib/go/templates v0.15.2-0.20240429192223-e696a8e439b5/go.mod h1:0oTx6Nkc+LdOXaZe3PRtV1cY+J5z5ig08alR8d+OPHs= +github.com/onflow/flow-emulator v1.0.0-M1 h1:0hBEmvm73F+5HhN5ugkOP3UyN+Ea9yGWflEmoeGzgdw= +github.com/onflow/flow-emulator v1.0.0-M1/go.mod h1:JFJCeQVyhCQVD2Tq4QhctIXK6j5U6aU15yoEwMJt5AQ= +github.com/onflow/flow-emulator v1.0.0-M3 h1:+Rktq6OzQfJCLNVweJqtTUKZrHMc6eVVZn1tYI1PMMg= +github.com/onflow/flow-emulator v1.0.0-M3/go.mod h1:iMQ7WbzrEa+xQL23P8zCxrXv8YhAWUds8SvEdERB14o= +github.com/onflow/flow-emulator v1.0.0-M8 h1:FE9OtyXh3tZLjszpznIfMyaTmIoX+maFBYd1mCY+ke0= +github.com/onflow/flow-emulator v1.0.0-M8/go.mod h1:mSp1JTXt1JGmriiG7Lc2VulQHG1tl6Oj1zGSr/h0ySk= +github.com/onflow/flow-emulator v1.0.0-preview.15 h1:5qAiMOVdxrFKccvLRiApkGhDWyr+nvFhQGQFxRHBALg= +github.com/onflow/flow-emulator v1.0.0-preview.15/go.mod h1:pSSLRvjxTecPQgI2ch+VVPKydeDlCg/1lHSLPrOUghw= +github.com/onflow/flow-emulator v1.0.0-preview.22 h1:l0BPXlDvK0gZDqQhY3Kc7pBm38pE/FbfefiZe7j6Ngg= +github.com/onflow/flow-emulator v1.0.0-preview.22/go.mod h1:60M4QPVpdpEhEdz6NGOtLule+jcRLLKID1gYv2ehLvw= +github.com/onflow/flow-go v0.33.2-0.20240126002816-f0770a716d61 h1:Xq40zbxw9mDS1+Zz1p6DCzAxDYQwbHWLJ5B9HOp9Fk8= +github.com/onflow/flow-go v0.33.2-0.20240126002816-f0770a716d61/go.mod h1:xdzERQeTalqsU0rHGSZgqQuE5krMfBQ4BA/4bgrLndY= +github.com/onflow/flow-go v0.33.2-0.20240206235622-50f8c81f1f43 h1:KB10iF+6HIQ/hKykzBf8n3P8cDDRHL4ytfc0R4ApCZM= +github.com/onflow/flow-go v0.33.2-0.20240206235622-50f8c81f1f43/go.mod h1:gWMjeDpt0YuJiwxtgdD8qxsM53PvUyoPHmjisZZmjR0= +github.com/onflow/flow-go v0.34.0-crescendo-preview.5.0.20240228222755-c41bc8a25122 h1:6R1L5Ji+lEWdTRcqeTLVLGPX1FqiWHeXHnRKAUsciSE= +github.com/onflow/flow-go v0.34.0-crescendo-preview.5.0.20240228222755-c41bc8a25122/go.mod h1:HSffipIVOyXvK3/gsYU13EwRMxbuK591hmjqF36nbEI= +github.com/onflow/flow-go v0.34.0-crescendo-preview.8.0.20240328003708-11040f76d0cd h1:QWLgb4okWnmZHN2ebiGUNR1CNdHICE1CxVx7wQY9Q40= +github.com/onflow/flow-go v0.34.0-crescendo-preview.8.0.20240328003708-11040f76d0cd/go.mod h1:vaUovXWZxbcxCg+wFAvb5SFouo4Q2OI3fj9XwCpbU6M= +github.com/onflow/flow-go v0.34.0-crescendo-preview.18 h1:Bre7uU/n1PjOEcIkTtaJDo4T5tngjKcr/cAOvxr3se4= +github.com/onflow/flow-go v0.34.0-crescendo-preview.18/go.mod h1:bwjzi2kSev1emRVN685FqYfCLYcZ6t2A5z5ztYXfvH8= +github.com/onflow/flow-go-sdk v1.0.0-M1 h1:mke/ebYwNRRWPZqcwCV56Alx0A8psew43ZbSEUQ4TL8= +github.com/onflow/flow-go-sdk v1.0.0-M1/go.mod h1:TDW0MNuCs4SvqYRUzkbRnRmHQL1h4X8wURsCw9P9beo= +github.com/onflow/flow-go-sdk v1.0.0-M2 h1:YWeXTo112RF8s6swiOU5oW8JWbOOz392FCeAbGnm+W4= +github.com/onflow/flow-go-sdk v1.0.0-M2/go.mod h1:mllhNw5WAEug59EWvW3TudcrtPmB5VfLA3iUx7mAA4s= +github.com/onflow/flow-go-sdk v1.0.0-M7 h1:5EhtgpupjdhJZoHpu8AhA7++AroGL6BFpb8D0AYIUQw= +github.com/onflow/flow-go-sdk v1.0.0-M7/go.mod h1:aXSavLzoRlz5FiMjcI7p5QhihWScGctxydzf4dv/avo= +github.com/onflow/flow-go-sdk v1.0.0-preview.16 h1:m5Dj5XLUTHIFgjWPDsapaIFKIheBlhFLwZ9aXxwX6hQ= +github.com/onflow/flow-go-sdk v1.0.0-preview.16/go.mod h1:zQwbb+mHfV7R+xa03xr6RoU13bZOF2uKgdf7dOGELvc= +github.com/onflow/flow-go-sdk v1.0.0-preview.25 h1:wL/+cK7oxSww31qSqTpt1Yfr26c8hJ8YHh9nIdq6PlI= +github.com/onflow/flow-go-sdk v1.0.0-preview.25/go.mod h1:Px1fQdB7WFC0yhYsEM3rhKzuE+Zi8GpBjR4qVuDAwMA= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240125205553-d2b571fb3fad h1:I6LD9BOsilGbiqhGjP86FIIXJe0YdUz75d/oWdHFzDI= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240125205553-d2b571fb3fad/go.mod h1:2gpbza+uzs1k7x31hkpBPlggIRkI53Suo0n2AyA2HcE= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240205233530-86ee8c352fa6 h1:/2vvjKkWG/3cKP3IpgiGNqXi0yskn4GmNTjmeCwMoz8= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240205233530-86ee8c352fa6/go.mod h1:2gpbza+uzs1k7x31hkpBPlggIRkI53Suo0n2AyA2HcE= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240214230837-cd2c42e54b4a h1:xMEtuQp4+ltfEZcw+4smv4wechSBAus4yEAtPghXZeQ= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240214230837-cd2c42e54b4a/go.mod h1:2gpbza+uzs1k7x31hkpBPlggIRkI53Suo0n2AyA2HcE= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240326155818-c01c72c091c0 h1:xekR2FttJpwtpRfH1BFvf9Kztm9be8grT1GT9bpQK8M= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240326155818-c01c72c091c0/go.mod h1:2gpbza+uzs1k7x31hkpBPlggIRkI53Suo0n2AyA2HcE= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240429184308-40c3de711140 h1:oTj4RGgfuJSSBE1aDVrlh6avxKBMraucpNtRg0K+yhg= +github.com/onflow/flow-nft/lib/go/contracts v1.1.1-0.20240429184308-40c3de711140/go.mod h1:2gpbza+uzs1k7x31hkpBPlggIRkI53Suo0n2AyA2HcE= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240214230837-cd2c42e54b4a h1:Ark2dPAaSxSr45G5WJjB1P5H0tFtXnHcOIp+dM146yo= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240214230837-cd2c42e54b4a/go.mod h1:p+2hRvtjLUR3MW1NsoJe5Gqgr2eeH49QB6+s6ze00w0= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240326155818-c01c72c091c0 h1:Qk24unKC2ncZ+U+fd63pC5BdWyMwkKEOsjMdIrj70O0= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240326155818-c01c72c091c0/go.mod h1:p+2hRvtjLUR3MW1NsoJe5Gqgr2eeH49QB6+s6ze00w0= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240429184308-40c3de711140 h1:7NwSIG4SEdm+96gr+Aaqx291jZ/Bqkxk/ghVnens9CU= +github.com/onflow/flow-nft/lib/go/templates v0.0.0-20240429184308-40c3de711140/go.mod h1:p+2hRvtjLUR3MW1NsoJe5Gqgr2eeH49QB6+s6ze00w0= +github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20231121210617-52ee94b830c2/go.mod h1:NA2pX2nw8zuaxfKphhKsk00kWLwfd+tv8mS23YXO4Sk= +github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20231213135419-ae911cc351a2 h1:+rT+UsfTR39JZO8ht2+4fkaWfHw74SCj1fyz1lWuX8A= +github.com/onflow/flow/protobuf/go/flow v0.3.2-0.20231213135419-ae911cc351a2/go.mod h1:NA2pX2nw8zuaxfKphhKsk00kWLwfd+tv8mS23YXO4Sk= +github.com/onflow/flow/protobuf/go/flow v0.3.7 h1:+6sBdlE/u4ZMTVB9U1lA6Xn2Bd48lOOX96Bv9dNubsk= +github.com/onflow/flow/protobuf/go/flow v0.3.7/go.mod h1:NA2pX2nw8zuaxfKphhKsk00kWLwfd+tv8mS23YXO4Sk= +github.com/onflow/flow/protobuf/go/flow v0.4.1-0.20240412170550-911321113030 h1:I+aosSiJny88O4p3nPbCiUcp/UqN6AepvO6uj82bjH0= +github.com/onflow/flow/protobuf/go/flow v0.4.1-0.20240412170550-911321113030/go.mod h1:NA2pX2nw8zuaxfKphhKsk00kWLwfd+tv8mS23YXO4Sk= +github.com/onflow/go-ethereum v1.13.4 h1:iNO86fm8RbBbhZ87ZulblInqCdHnAQVY8okBrNsTevc= +github.com/onflow/go-ethereum v1.13.4/go.mod h1:cE/gEUkAffhwbVmMJYz+t1dAfVNHNwZCgc3BWtZxBGY= +github.com/onflow/sdks v0.5.1-0.20230912225508-b35402f12bba h1:rIehuhO6bj4FkwE4VzwEjX7MoAlOhUJENBJLqDqVxAo= +github.com/onflow/sdks v0.5.1-0.20230912225508-b35402f12bba/go.mod h1:F0dj0EyHC55kknLkeD10js4mo14yTdMotnWMslPirrU= github.com/onflow/wal v0.0.0-20230529184820-bc9f8244608d h1:gAEqYPn3DS83rHIKEpsajnppVD1+zwuYPFyeDVFaQvg= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.13.0/go.mod h1:+REjRxOmWfHCjfv9TTWB1jD1Frx4XydAD3zm1lskyM0= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= -github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE= github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.0.3-0.20180606204148-bd9c31933947/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs= github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/paulbellamy/ratecounter v0.2.0/go.mod h1:Hfx1hDpSGoqxkVVpBi/IlYD7kChlfo5C6hzIHwPqfFE= github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 h1:onHthvaw9LFnH4t2DcNVpwGmV9E1BkGknEliJkfwQj0= github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58/go.mod h1:DXv8WO4yhMYhSNPKjeNKa5WY9YCIEBRbNzFFPJbWO6Y= -github.com/pborman/uuid v0.0.0-20170112150404-1b00554d8222/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU= github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek= +github.com/peterh/liner v1.0.1-0.20180619022028-8c1271fcf47f/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc= github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= +github.com/philhofer/fwd v1.0.0/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU= +github.com/phpdave11/gofpdf v1.4.2/go.mod h1:zpO6xFn9yxo3YLyMvW8HcKWVdbNqgIfOOp2dXMnm1mY= +github.com/phpdave11/gofpdi v1.0.12/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/phpdave11/gofpdi v1.0.13/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI= +github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= github.com/pierrec/lz4 v2.6.1+incompatible h1:9UY3+iC23yxF0UfGaYrGplQ+79Rg+h/q9FV9ix19jjM= github.com/pierrec/lz4 v2.6.1+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY= +github.com/pierrec/lz4/v4 v4.1.15/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4= +github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= +github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= +github.com/pkg/browser v0.0.0-20210115035449-ce105d075bb4/go.mod h1:N6UoU20jOqggOuDwUaBQpluzLNDqif3kq9z2wpdYEfQ= +github.com/pkg/browser v0.0.0-20210911075715-681adbf594b8/go.mod h1:HKlIX3XHQyzLZPlr7++PzdhaXEj94dEiJgZDTsxEqUI= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= -github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= +github.com/pkg/term v0.0.0-20180730021639-bffc007b7fd5/go.mod h1:eCbImbZ95eXtAUIbLAuAVnBnwf83mjf6QIVH8SHYwqQ= +github.com/pkg/term v1.2.0-beta.2/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prashantv/gostub v1.1.0/go.mod h1:A5zLQHz7ieHGG7is6LLXLz7I8+3LZzsrV0P1IAHhP5U= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= -github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= -github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= +github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M= +github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0= +github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= +github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8= +github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc= +github.com/prometheus/client_golang v1.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk= +github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= +github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/client_model v0.4.0 h1:5lQXD3cAg1OXBf4Wq03gTrXHeaV0TQvGfUooCfx1yqY= +github.com/prometheus/client_model v0.4.0/go.mod h1:oMQmHW1/JoDwqLtg57MGgP/Fb1CJEYF2imWWhWtMkYU= +github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= +github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= -github.com/prometheus/common v0.39.0 h1:oOyhkDq05hPZKItWVBkJ6g6AtGxi+fy7F4JvUV8uhsI= -github.com/prometheus/common v0.39.0/go.mod h1:6XBZ7lYdLCbkAVhwRsWTZn+IN5AB9F/NXd5w0BbEX0Y= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc= +github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= +github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/common v0.42.0 h1:EKsfXEYo4JpWMHH5cg+KOUWeuJSov1Id8zGR8eeI1YM= +github.com/prometheus/common v0.42.0/go.mod h1:xBwqVerjNdUDjgODMpudtOMwlOwf2SaTr1yjz4b7Zbc= +github.com/prometheus/common v0.45.0 h1:2BGz0eBc2hdMDLnO/8n0jeB3oPrt2D08CekT0lneoxM= +github.com/prometheus/common v0.45.0/go.mod h1:YJmSTw9BoKxJplESWWxlbyttQR4uaEcGyv9MZjVOJsY= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= -github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI= -github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= -github.com/prometheus/tsdb v0.6.2-0.20190402121629-4f204dcbc150/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= +github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/prometheus/procfs v0.10.1 h1:kYK1Va/YMlutzCGazswoHKo//tZVlFpKYh+PymziUAg= +github.com/prometheus/procfs v0.10.1/go.mod h1:nwNm2aOCAYw8uTR/9bWRREkZFxAUcWzPHWJq+XBB/FM= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= +github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= +github.com/protolambda/bls12-381-util v0.0.0-20220416220906-d8552aa452c7/go.mod h1:IToEjHuttnUzwZI5KBSM/LOOW3qLbbrHOEfp3SbECGY= github.com/psiemens/graceland v1.0.0 h1:L580AVV4Q2XLcPpmvxJRH9UpEAYr/eu2jBKmMglhvM8= github.com/psiemens/graceland v1.0.0/go.mod h1:1Tof+vt1LbmcZFE0lzgdwMN0QBymAChG3FRgDx8XisU= github.com/psiemens/sconfig v0.1.0 h1:xfWqW+TRpih7mXZIqKYTmpRhlZLQ1kbxV8EjllPv76s= @@ -583,49 +2048,72 @@ github.com/psiemens/sconfig v0.1.0/go.mod h1:+MLKqdledP/8G3rOBpknbLh0IclCf4WneJU github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= +github.com/retailnext/hllpp v1.0.1-0.20180308014038-101a6d2f8b52/go.mod h1:RDpi1RftBQPUCDRw6SmxeaREsAaRKnOclghuzp/WRzc= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis= github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho= -github.com/robertkrimen/otto v0.0.0-20170205013659-6a77b7cbc37d/go.mod h1:xvqspoSXJTIpemEonrMDFq6XzwHYYgToXWj5eRX1OtY= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= +github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= -github.com/rs/cors v0.0.0-20160617231935-a62a804a8a00/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xhandler v0.0.0-20160618193221-ed27b6fd6521/go.mod h1:RvLn4FgxWubrpZHtQLnOf6EwhN2hEMusxZOhcW9H3UQ= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= +github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w= github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= -github.com/schollz/progressbar/v3 v3.8.3/go.mod h1:pWnVCjSBZsT2X3nx9HfRdnCDrpbevliMeoEVhStwHko= +github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w= +github.com/ruudk/golang-pdf417 v0.0.0-20201230142125-a7e3863a1245/go.mod h1:pQAZKsJ8yyVxGRWYNEm9oFB8ieLgKFnamEyDmSA0BRk= +github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= github.com/schollz/progressbar/v3 v3.13.1 h1:o8rySDYiQ59Mwzy2FELeHY5ZARXZTVJC7iHD6PEFUiE= +github.com/schollz/progressbar/v3 v3.13.1/go.mod h1:xvrbki8kfT1fzWzBT/UZd9L6GA+jdL7HAgq2RFnO6fQ= +github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw= +github.com/segmentio/kafka-go v0.1.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo= +github.com/segmentio/kafka-go v0.2.0/go.mod h1:X6itGqS9L4jDletMsxZ7Dz+JFWxM6JHfPOCvTvk+EJo= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= +github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= github.com/sethvargo/go-retry v0.2.3 h1:oYlgvIvsju3jNbottWABtbnoLC+GDtLdBHxKWxQm/iU= github.com/sethvargo/go-retry v0.2.3/go.mod h1:1afjQuvh7s4gflMObvjLPaWgluLLyhA1wmVZ6KLpICw= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE= +github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= +github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0= +github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/slok/go-http-metrics v0.10.0 h1:rh0LaYEKza5eaYRGDXujKrOln57nHBi4TtVhmNEpbgM= github.com/slok/go-http-metrics v0.10.0/go.mod h1:lFqdaS4kWMfUKCSukjC47PdCeTk+hXDUVm8kLHRqJ38= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= -github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 h1:RC6RW7j+1+HkWaX/Yh71Ee5ZHaHYt7ZP4sQgUrm6cDU= -github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spaolacci/murmur3 v1.0.1-0.20190317074736-539464a789e9/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.9.3 h1:41FoI0fD7OR7mGcKE/aOiLkGreyf8ifIOQmJANWogMk= -github.com/spf13/afero v1.9.3/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= +github.com/spf13/afero v1.10.0 h1:EaGW2JJh15aKOejeuJ+wpFSHnbd7GE6Wvp3TsNhb6LY= +github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.5.0 h1:rj3WzYc11XZaIZMPKmwP96zkFEnnAmV8s6XbB2aY32w= github.com/spf13/cast v1.5.0/go.mod h1:SpXXQ5YoyJw6s3/6cMTQuxvgRl3PCJiyaX9p6b155UU= +github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= -github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= +github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE= +github.com/spf13/cobra v1.5.0/go.mod h1:dWXEIy2H428czQCjInthrTRUg7yKbok+2Qi/yBIJoUM= +github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0= +github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= @@ -637,13 +2125,15 @@ github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/y github.com/spf13/viper v1.15.0 h1:js3yy885G8xwJa6iOISGFwd+qlUo5AvyXb7CiihdtiU= github.com/spf13/viper v1.15.0/go.mod h1:fFcTBJxvhhzSJiZy8n+PeW6t8l+KeT/uTARa0jHOQLA= github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q= -github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570/go.mod h1:8OR4w3TdeIHIh1g6EMY5p0gVNOovcWC+1vpc7naMuAw= -github.com/steakknife/hamming v0.0.0-20180906055917-c99c65617cd3/go.mod h1:hpGUWaI9xL8pRQCTXQgocU38Qw1g0Us7n5PxxTwTCYU= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= @@ -651,49 +2141,86 @@ github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8= github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= -github.com/supranational/blst v0.3.4/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= -github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b h1:u49mjRnygnB34h8OKbnNJFVUtWSKIKb1KukdV8bILUM= -github.com/syndtr/goleveldb v1.0.1-0.20190923125748-758128399b1d/go.mod h1:9OrXJhf154huy1nPWmuSrkgjPUtUNhA+Zmy+6AESzuA= +github.com/supranational/blst v0.3.8-0.20220526154634-513d2456b344/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= +github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= github.com/texttheater/golang-levenshtein/levenshtein v0.0.0-20200805054039-cae8b0eaed6c h1:HelZ2kAFadG0La9d+4htN4HzQ68Bm2iM9qKMSMES6xg= github.com/texttheater/golang-levenshtein/levenshtein v0.0.0-20200805054039-cae8b0eaed6c/go.mod h1:JlzghshsemAMDGZLytTFY8C1JQxQPhnatWqNwUXjggo= +github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU= +github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= +github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/turbolent/prettier v0.0.0-20220320183459-661cc755135d h1:5JInRQbk5UBX8JfUvKh2oYTLMVwj3p6n+wapDDm7hko= github.com/turbolent/prettier v0.0.0-20220320183459-661cc755135d/go.mod h1:Nlx5Y115XQvNcIdIy7dZXaNSUpzwBSge4/Ivk93/Yog= github.com/tyler-smith/go-bip39 v1.0.1-0.20181017060643-dbb3b84ba2ef/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= +github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= -github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= +github.com/urfave/cli/v2 v2.3.0/go.mod h1:LJmUH05zAU44vOAcrfzZQKsZbVcdbOG8rtL3/XcUArI= +github.com/urfave/cli/v2 v2.10.2/go.mod h1:f8iq5LtQ/bLxafbdBSLPPNsgaW0l/2fYYEHhAyPlwvo= +github.com/urfave/cli/v2 v2.24.1/go.mod h1:GHupkWPMM0M/sj1a2b4wUrWBPzazNrIjouW6fmdJLxc= +github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= +github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4= +github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= +github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w= +github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= +github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= +github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI= github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk= github.com/vmihailenco/msgpack/v4 v4.3.11 h1:Q47CePddpNGNhk4GCnAx9DDtASi2rasatE0cd26cZoE= github.com/vmihailenco/msgpack/v4 v4.3.11/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4= github.com/vmihailenco/tagparser v0.1.1 h1:quXMXlA39OCbd2wAdTsGDlK9RkOk6Wuw+x37wVyIuWY= github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= -github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM= -github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees= +github.com/willf/bitset v1.1.3/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= +github.com/xlab/treeprint v0.0.0-20180616005107-d6fb6747feb6/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI= +github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg= +github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM= +github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/zeebo/assert v1.1.0 h1:hU1L1vLTHsnO8x8c9KAR5GmM5QscxHg5RNU5z5qbUWY= +github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/zeebo/assert v1.1.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= -github.com/zeebo/blake3 v0.2.0/go.mod h1:G9pM4qQwjRzF1/v7+vabMj/c5mWpGZ2Wzo3Eb4z0pb4= +github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ= +github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= github.com/zeebo/blake3 v0.2.3 h1:TFoLXsjeXqRNFxSbk35Dk4YtszE/MQQGK10BH4ptoTg= github.com/zeebo/blake3 v0.2.3/go.mod h1:mjJjZpnsyIVtVgTOSpJ9vmRE4wgDeyt2HU3qXvvKCaQ= -github.com/zeebo/pcg v1.0.0/go.mod h1:09F0S9iiKrwn9rlI5yjLkmrug154/YRW6KnnXVDM/l4= github.com/zeebo/pcg v1.0.1 h1:lyqfGeWiv4ahac6ttHs+I5hwtH/+1mrhlCtVNQM2kHo= github.com/zeebo/pcg v1.0.1/go.mod h1:09F0S9iiKrwn9rlI5yjLkmrug154/YRW6KnnXVDM/l4= +github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= @@ -702,56 +2229,111 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= -go.opentelemetry.io/otel v1.14.0 h1:/79Huy8wbf5DnIPhemGB+zEPVwnN6fuQybr/SRXa6hM= -go.opentelemetry.io/otel v1.14.0/go.mod h1:o4buv+dJzx8rohcUeRmWUZhqupFvzWis188WlggnNeU= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.14.0 h1:/fXHZHGvro6MVqV34fJzDhi7sHGpX3Ej/Qjmfn003ho= -go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.14.0/go.mod h1:UFG7EBMRdXyFstOwH028U0sVf+AvukSGhF0g8+dmNG8= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.14.0 h1:TKf2uAs2ueguzLaxOCBXNpHxfO/aC7PAdDsSH0IbeRQ= -go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.14.0/go.mod h1:HrbCVv40OOLTABmOn1ZWty6CHXkU8DK/Urc43tHug70= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= +go.opentelemetry.io/otel v1.8.0/go.mod h1:2pkj+iMj0o03Y+cW6/m8Y4WkRdYN3AvCXCnzRMp9yvM= +go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s= +go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4= +go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y= +go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI= +go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= +go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= +go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0 h1:t4ZwRPU+emrcvM2e9DHd0Fsf0JTPVcbfa/BhTDF03d0= +go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0/go.mod h1:vLarbg68dH2Wa77g71zmKQqlQ8+8Rq3GRG31uc0WcWI= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0 h1:cbsD4cUcviQGXdw8+bo5x2wazq10SKz8hEbtCRPcU78= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0/go.mod h1:JgXSGah17croqhJfhByOLVY719k1emAXC8MVhCIJlRs= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw= +go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.14.0 h1:ap+y8RXX3Mu9apKVtOkM6WSFESLM8K3wNQyOU8sWHcc= go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.14.0/go.mod h1:5w41DY6S9gZrbjuq6Y+753e96WfPha5IcsOSZTtullM= -go.opentelemetry.io/otel/sdk v1.14.0 h1:PDCppFRDq8A1jL9v6KMI6dYesaq+DFcDZvjsoGvxGzY= -go.opentelemetry.io/otel/sdk v1.14.0/go.mod h1:bwIC5TjrNG6QDCHNWvW4HLHtUQ4I+VQDsnjhvyZCALM= -go.opentelemetry.io/otel/trace v1.14.0 h1:wp2Mmvj41tDsyAJXiWDWpfNsOiIyd38fy85pyKcFq/M= -go.opentelemetry.io/otel/trace v1.14.0/go.mod h1:8avnQLK+CG77yNLUae4ea2JDQ6iT+gozhnZjy/rw9G8= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 h1:tIqheXEFWAZ7O8A7m+J0aPTmpJN3YQ7qetUAdkkkKpk= +go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0/go.mod h1:nUeKExfxAQVbiVFn32YXpXZZHZ61Cc3s3Rn1pDBGAb0= +go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo= +go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4= +go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg= +go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY= +go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= +go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= +go.opentelemetry.io/otel/sdk v1.16.0 h1:Z1Ok1YsijYL0CSJpHt4cS3wDDh7p572grzNrBMiMWgE= +go.opentelemetry.io/otel/sdk v1.16.0/go.mod h1:tMsIuKXuuIWPBAOrH+eHtvhTL+SntFtXF9QD68aP6p4= +go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8= +go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E= +go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw= +go.opentelemetry.io/otel/sdk v1.24.0/go.mod h1:KVrIYw6tEubO9E96HQpcmpTKDVn9gdv35HoYiQWGDFg= +go.opentelemetry.io/otel/trace v1.8.0/go.mod h1:0Bt3PXY8w+3pheS3hQUt+wow8b1ojPaTBoTCh2zIFI4= +go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs= +go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0= +go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0= +go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo= +go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= +go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw= go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= +go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I= +go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM= +go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/atomic v1.10.0 h1:9qC72Qh0+3MqyJbAn8YU5xVq1frD8bn3JtD2oXtafVQ= -go.uber.org/atomic v1.10.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= +go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= +go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= -go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI= -go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ= +go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= +go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= +go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ= go.uber.org/zap v1.19.1/go.mod h1:j3DNczoxDZroyBnOT1L/Q79cfUMGZxlv/9dzN7SM1rI= go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60= go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg= -golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= +go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190909091759-094676da4a83/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220511200225-c6db032c6c88/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw= +golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU= +golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= +golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45I= +golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio= +golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= +golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= +golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= +golang.org/x/crypto v0.16.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/crypto v0.18.0 h1:PGVlW0xEltQnzFZ55hkuX5+KLyrMYhHld1YHO4AKcdc= +golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo= +golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -759,17 +2341,37 @@ golang.org/x/exp v0.0.0-20190125153040-c74c464bbbf2/go.mod h1:CJ0aWSM057203Lf6IL golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191002040644-a1355ae1e2c3/go.mod h1:NOZ3BPKG0ec/BKJQgnvsSFpcKLM5xXVWnvZS97DWHgE= golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= -golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU= -golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w= +golang.org/x/exp v0.0.0-20220426173459-3bcf042a4bf5/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE= +golang.org/x/exp v0.0.0-20220827204233-334a2380cb91/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE= +golang.org/x/exp v0.0.0-20230321023759-10a507213a29/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= +golang.org/x/exp v0.0.0-20230626212559-97b1e661b5df/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= +golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= +golang.org/x/exp v0.0.0-20240103183307-be819d1f06fc h1:ao2WRsKSzW6KuUY9IWPwWahcHCgR0s52IfwutMfEbdM= +golang.org/x/exp v0.0.0-20240103183307-be819d1f06fc/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI= +golang.org/x/exp v0.0.0-20240119083558-1b970713d09a h1:Q8/wZp0KX97QFTc2ywcOE0YRjZPVIx+MXInMzdvQqcA= +golang.org/x/exp v0.0.0-20240119083558-1b970713d09a/go.mod h1:idGWGoKP1toJGkd5/ig9ZLuPcZBC3ewk7SzmH0uou08= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200430140353-33d19683fad8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20200618115811-c13761719519/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20201208152932-35266b937fa6/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210216034530-4410531fe030/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.0.0-20210607152325-775e3b0c77b9/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20211028202545-6944b10bf410/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.0.0-20220302094943-723b81ca9867/go.mod h1:023OzeP/+EPmXeapQh35lcL3II3LrY8Ic+EFFKVhULM= +golang.org/x/image v0.5.0/go.mod h1:FVC7BI/5Ym8R25iw5OLsgshdUBbT1h5jZTpA+mvAdZ4= +golang.org/x/image v0.6.0/go.mod h1:MXLdDR43H7cDJq5GEGXEVeeNhPgi+YYEQ2pC1byI1x0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= @@ -793,7 +2395,19 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.9.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -801,16 +2415,18 @@ golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -821,22 +2437,65 @@ golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/ golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= +golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210610132358-84b48f89b13b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.4.0/go.mod h1:MBQ8lrhLObU/6UmLb4fmbmk5OcyYmqtbGd/9yIeKjEE= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.11.0/go.mod h1:2L/ixqYpgIVXmeoSA/4Lu7BzTG4KIyPIryS4IsOd1oQ= +golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA= +golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= +golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= +golang.org/x/net v0.16.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= +golang.org/x/net v0.19.0 h1:zTwKpTd2XuCqf8huc7Fo2iSy+4RHPd10s4KzeTnVr1c= +golang.org/x/net v0.19.0/go.mod h1:CfAk/cbD4CthTvqiEl8NpboMuiuOYsAr/7NOjZJtv1U= +golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo= +golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= +golang.org/x/oauth2 v0.0.0-20170207211851-4464e7848382/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -853,6 +2512,24 @@ golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= +golang.org/x/oauth2 v0.5.0/go.mod h1:9/XBHVqLaWO3/BRHs5jbpYCnOZVjj5V0ndyaAM7KB4I= +golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= +golang.org/x/oauth2 v0.7.0/go.mod h1:hPLQkd9LyjfXTiRohC/41GhcFqxisoUQ99sCUOHO9x4= +golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= +golang.org/x/oauth2 v0.10.0/go.mod h1:kTpgurOux7LqtuxjuyZa4Gj2gdezIt/jQtGnNFfypQI= +golang.org/x/oauth2 v0.11.0/go.mod h1:LdF7O/8bLR/qWK9DrpXmbHLTouvRHK0SgJl0GmDBchk= +golang.org/x/oauth2 v0.13.0/go.mod h1:/JMhi4ZRXAf4HG9LiNmxvk+45+96RUlVThiH8FzNBn0= +golang.org/x/perf v0.0.0-20230113213139-801c7ef9e5c5/go.mod h1:UBKtEnL8aqnd+0JHqZ+2qoMDwtuy6cYhhKNoHLBiTQc= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -864,8 +2541,18 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E= +golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220819030929-7fc1605a5dde/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= +golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -873,7 +2560,6 @@ golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -883,13 +2569,18 @@ golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -903,46 +2594,113 @@ golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200918174421-af09f7315aff/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201014080544-cc95f250f6bc/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20201101102859-da207088b7d1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210304124612-50617c2ba197/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210420205809-ac73e9fd8988/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210616045830-e2b7044e8c71/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210910150752-751e447fb3d0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210917161153-d61c044b1678/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211020174200-9d6173849985/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220919091848-fb04ddd9f9c8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.3.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y= +golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.3.0/go.mod h1:q750SLmJuPmVoN1blW3UFBPREJfb1KmY3vwxfr+nFDA= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.9.0/go.mod h1:M6DEAAIenWoTxdKrOltXcmDY3rSplQUkrvaDU5FcQyo= +golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o= +golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= +golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU= +golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U= golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4= +golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -951,20 +2709,43 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.5.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.10.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190206041539-40960b6deb8e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= @@ -973,6 +2754,7 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190927191325-030b2cf1153e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -981,9 +2763,11 @@ golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtn golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191126055441-b0650ceb63d9/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200108203644-89082a384178/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= @@ -1003,9 +2787,9 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200828161849-5deb26317202/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201124115921-2c860bdd6e78/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= @@ -1017,18 +2801,53 @@ golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.9.1 h1:8WMNJAz3zrtPmnYC7ISf5dEn3MT0gY7jBJfw27yrrLo= +golang.org/x/tools v0.1.8-0.20211029000441-d6a9af8af023/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s= +golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4= +golang.org/x/tools v0.9.1/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc= +golang.org/x/tools v0.10.0/go.mod h1:UJwyiVBsOA2uwvK/e5OY3GTpDUJriEd+/YlqAwLPmyM= +golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= +golang.org/x/tools v0.16.0 h1:GO788SKMRunPIBCXiQyo2AaexLstOrVhuAL5YwsckQM= +golang.org/x/tools v0.16.0/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= +golang.org/x/tools v0.16.1 h1:TLyB3WofjdOEepBHAU20JdNC1Zbg87elYofWYAY5oZA= +golang.org/x/tools v0.16.1/go.mod h1:kYVVN6I1mBNoB1OX+noeBjbRk4IUEPa7JJ+TJMEooJ0= +golang.org/x/tools v0.17.0 h1:FvmRgNOcs3kOa+T20R1uhfP9F6HgG2mfxDv1vrx1Htc= +golang.org/x/tools v0.17.0/go.mod h1:xsh6VxdV005rRVaS6SSAf9oiAqljS7UZUacMZ8Bnsps= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk= golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU= +golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= +gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= +gonum.org/v1/gonum v0.6.0/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= gonum.org/v1/gonum v0.6.1/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= -gonum.org/v1/gonum v0.8.2 h1:CCXrcPKiGGotvnN6jfUsKk4rRqm7q09/YbKb5xCEvtM= +gonum.org/v1/gonum v0.8.2/go.mod h1:oe/vMfY3deqTw+1EZJhuvEW2iwGF1bW9wwu7XCu0+v0= +gonum.org/v1/gonum v0.9.3/go.mod h1:TZumC3NeyVQskjXqmyWt4S3bINhy7B4eYwW69EbyX+0= +gonum.org/v1/gonum v0.11.0/go.mod h1:fSG4YDCxxUZQJ7rKsQrj0gMOg00Il0Z96/qMA4bVQhA= +gonum.org/v1/gonum v0.13.0 h1:a0T3bh+7fhRyqeNbiC3qVHYmkiQgit3wnNan/2c0HMM= +gonum.org/v1/gonum v0.13.0/go.mod h1:/WPYRckkfWrhWefxyYTfrTtQR0KH4iyHNuzxqXAKyAU= +gonum.org/v1/gonum v0.14.0 h1:2NiG67LD1tEH0D7kM+ps2V+fXmsAnpUeec7n8tcr4S0= +gonum.org/v1/gonum v0.14.0/go.mod h1:AoWeoz0becf9QMWtE8iWXNXc27fK4fNeHNf/oMejGfU= +gonum.org/v1/netlib v0.0.0-20181029234149-ec6d1f5cefe6/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= gonum.org/v1/netlib v0.0.0-20190313105609-8cb42192e0e0/go.mod h1:wa6Ws7BG/ESfp6dHfk7C6KdzKA7wR7u/rKwOGE66zvw= gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b/go.mod h1:Wt8AAjI+ypCyYX3nZBvf6cAIx93T+c/OS2HFAYskSZc= +gonum.org/v1/plot v0.9.0/go.mod h1:3Pcqqmp6RHvJI72kgb8fThyUnav364FOsdDo2aGW5lY= +gonum.org/v1/plot v0.10.0/go.mod h1:JWIHJ7U20drSQb/aDpTetJzfC1KlAPldJLpkSy88dvQ= +gonum.org/v1/plot v0.10.1/go.mod h1:VZW5OlhkL1mysU9vaqNHnsy86inf6Ot+jB3r+BczCEo= +google.golang.org/api v0.0.0-20170206182103-3d017632ea10/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= @@ -1058,7 +2877,43 @@ google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6 google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= -google.golang.org/api v0.58.0/go.mod h1:cAbP2FsxoGVNwtgNAmmn3y5G1TWAiVYRmg4yku3lv+E= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= +google.golang.org/api v0.106.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.107.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.108.0/go.mod h1:2Ts0XTHNVWxypznxWOYUeI4g3WdP9Pk2Qk58+a/O9MY= +google.golang.org/api v0.110.0/go.mod h1:7FC4Vvx1Mooxh8C5HWjzZHcavuS2f6pmJpZx60ca7iI= +google.golang.org/api v0.111.0/go.mod h1:qtFHvU9mhgTJegR31csQ+rwxyUTHOKFqCKWp1J0fdw0= +google.golang.org/api v0.114.0/go.mod h1:ifYI2ZsFK6/uGddGfAD5BMxlnkBqCmqHSDUVi45N5Yg= +google.golang.org/api v0.118.0/go.mod h1:76TtD3vkgmZ66zZzp72bUUklpmQmKlhh6sYtIjYK+5E= +google.golang.org/api v0.122.0/go.mod h1:gcitW0lvnyWjSp9nKxAbdHKIZ6vF4aajGueeslZOyms= +google.golang.org/api v0.124.0/go.mod h1:xu2HQurE5gi/3t1aFCvhPD781p0a3p11sdunTJ2BlP4= +google.golang.org/api v0.125.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= +google.golang.org/api v0.126.0/go.mod h1:mBwVAtz+87bEN6CbA1GtZPDOqY2R5ONPqJeIlvyo4Aw= +google.golang.org/api v0.128.0/go.mod h1:Y611qgqaE92On/7g65MQgxYul3c0rEB894kniWLY750= +google.golang.org/api v0.139.0/go.mod h1:CVagp6Eekz9CjGZ718Z+sloknzkDJE7Vc1Ckj9+viBk= +google.golang.org/api v0.149.0/go.mod h1:Mwn1B7JTXrzXtnvmzQE2BD6bYZQ8DShKZDZbeN9I7qI= +google.golang.org/api v0.151.0/go.mod h1:ccy+MJ6nrYFgE3WgRx/AMXOxOmU8Q4hSa+jjibzhxcg= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1067,11 +2922,15 @@ google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCID google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM= +google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds= +google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190716160619-c506a9f90610/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= @@ -1079,6 +2938,7 @@ google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvx google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200108215221-bd8f9a0ef82f/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= @@ -1108,6 +2968,7 @@ google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= @@ -1124,13 +2985,149 @@ google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEc google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210917145530-b395a37504d4/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210921142501-181ce0d877f6/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211007155348-82e027067bd4/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221109142239-94d6d90a7d66/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201204527-e3fa12d562f3/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20221207170731-23e4bf6bdc37/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20221227171554-f9683d7f8bef/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230112194545-e10362b5ecf9/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230113154510-dbe35b8444a5/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230123190316-2c411cf9d197/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230124163310-31e0e69b6fc2/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230125152338-dcaf20b6aeaa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230127162408-596548ed4efa/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230209215440-0dfe4f8abfcc/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= +google.golang.org/genproto v0.0.0-20230216225411-c8e22ba71e44/go.mod h1:8B0gmkoRebU8ukX6HP+4wrVQUY1+6PkQ44BSyIlflHA= +google.golang.org/genproto v0.0.0-20230222225845-10f96fb3dbec/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230223222841-637eb2293923/go.mod h1:3Dl5ZL0q0isWJt+FVcfpQyirqemEuLAK/iFvg1UP1Hw= +google.golang.org/genproto v0.0.0-20230303212802-e74f57abe488/go.mod h1:TvhZT5f700eVlTNwND1xoEZQeWTB2RY/65kplwl/bFA= +google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230320184635-7606e756e683/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= +google.golang.org/genproto v0.0.0-20230323212658-478b75c54725/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230330154414-c0448cd141ea/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230331144136-dcfb400f0633/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= +google.golang.org/genproto v0.0.0-20230403163135-c38d8f061ccd/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU= +google.golang.org/genproto v0.0.0-20230525234025-438c736192d0/go.mod h1:9ExIQyXL5hZrHzQceCwuSYwZZ5QZBazOcprJ5rgs3lY= +google.golang.org/genproto v0.0.0-20230526161137-0005af68ea54/go.mod h1:zqTuNwFlFRsw5zIts5VnzLQxSRqh+CGOTVMlYbY0Eyk= +google.golang.org/genproto v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:zqTuNwFlFRsw5zIts5VnzLQxSRqh+CGOTVMlYbY0Eyk= +google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64= +google.golang.org/genproto v0.0.0-20230629202037-9506855d4529/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64= +google.golang.org/genproto v0.0.0-20230706204954-ccb25ca9f130/go.mod h1:O9kGHb51iE/nOGvQaDUuadVYqovW56s5emA88lQnj6Y= +google.golang.org/genproto v0.0.0-20230711160842-782d3b101e98/go.mod h1:S7mY02OqCJTD0E1OiQy1F72PWFB4bZJ87cAtLPYgDR0= +google.golang.org/genproto v0.0.0-20230726155614-23370e0ffb3e/go.mod h1:0ggbjUrZYpy1q+ANUS30SEoGZ53cdfwtbuG7Ptgy108= +google.golang.org/genproto v0.0.0-20230803162519-f966b187b2e5/go.mod h1:oH/ZOT02u4kWEp7oYBGYFFkCdKS/uYR9Z7+0/xuuFp8= +google.golang.org/genproto v0.0.0-20230821184602-ccc8af3d0e93/go.mod h1:yZTlhN0tQnXo3h00fuXNCxJdLdIdnVFVBaRJ5LWBbw4= +google.golang.org/genproto v0.0.0-20230822172742-b8732ec3820d/go.mod h1:yZTlhN0tQnXo3h00fuXNCxJdLdIdnVFVBaRJ5LWBbw4= +google.golang.org/genproto v0.0.0-20230913181813-007df8e322eb/go.mod h1:yZTlhN0tQnXo3h00fuXNCxJdLdIdnVFVBaRJ5LWBbw4= +google.golang.org/genproto v0.0.0-20230920204549-e6e6cdab5c13/go.mod h1:CCviP9RmpZ1mxVr8MUjCnSiY09IbAXZxhLE6EhHIdPU= +google.golang.org/genproto v0.0.0-20231002182017-d307bd883b97/go.mod h1:t1VqOqqvce95G3hIDCT5FeO3YUc6Q4Oe24L/+rNMxRk= +google.golang.org/genproto v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:EMfReVxb80Dq1hhioy0sOsY9jCE46YDgHlJ7fWVUWRE= +google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b h1:+YaDE2r2OG8t/z5qmsh7Y+XXwCbvadxxZ0YY6mTdrVA= +google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:CgAqfJo+Xmu0GwA0411Ht3OU3OntXwsGmrmjI8ioGXI= +google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917 h1:nz5NESFLZbJGPFxDT/HCn+V1mZ8JGNoY4nUpmW/Y2eg= +google.golang.org/genproto v0.0.0-20240102182953-50ed04b92917/go.mod h1:pZqR+glSb11aJ+JQcczCvgf47+duRuzNSKqE8YAQnV0= +google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de h1:F6qOa9AZTYJXOUEr4jDysRDLrm4PHePlge4v4TGAlxY= +google.golang.org/genproto v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:VUhTRKeHn9wwcdrk73nvdC9gF178Tzhmt/qyaFcPLSo= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234020-1aefcd67740a/go.mod h1:ts19tUU+Z0ZShN1y3aPyq2+O3d5FUNNgT6FtOzmrNn8= +google.golang.org/genproto/googleapis/api v0.0.0-20230525234035-dd9d682886f9/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20230629202037-9506855d4529/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig= +google.golang.org/genproto/googleapis/api v0.0.0-20230706204954-ccb25ca9f130/go.mod h1:mPBs5jNgx2GuQGvFwUvVKqtn6HsUw9nP64BedgvqEsQ= +google.golang.org/genproto/googleapis/api v0.0.0-20230711160842-782d3b101e98/go.mod h1:rsr7RhLuwsDKL7RmgDDCUc6yaGr1iqceVb5Wv6f6YvQ= +google.golang.org/genproto/googleapis/api v0.0.0-20230726155614-23370e0ffb3e/go.mod h1:rsr7RhLuwsDKL7RmgDDCUc6yaGr1iqceVb5Wv6f6YvQ= +google.golang.org/genproto/googleapis/api v0.0.0-20230803162519-f966b187b2e5/go.mod h1:5DZzOUPCLYL3mNkQ0ms0F3EuUNZ7py1Bqeq6sxzI7/Q= +google.golang.org/genproto/googleapis/api v0.0.0-20230822172742-b8732ec3820d/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk= +google.golang.org/genproto/googleapis/api v0.0.0-20230913181813-007df8e322eb/go.mod h1:KjSP20unUpOx5kyQUFa7k4OJg0qeJ7DEZflGDu2p6Bk= +google.golang.org/genproto/googleapis/api v0.0.0-20230920204549-e6e6cdab5c13/go.mod h1:RdyHbowztCGQySiCvQPgWQWgWhGnouTdCflKoDBt32U= +google.golang.org/genproto/googleapis/api v0.0.0-20231002182017-d307bd883b97/go.mod h1:iargEX0SFPm3xcfMI0d1domjg0ZF4Aa0p2awqyxhvF0= +google.golang.org/genproto/googleapis/api v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:SUBoKXbI1Efip18FClrQVGjWcyd0QZd8KkvdP34t7ww= +google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b h1:CIC2YMXmIhYw6evmhPxBKJ4fmLbOFtXQN/GV3XOZR8k= +google.golang.org/genproto/googleapis/api v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:IBQ646DjkDkvUIsVq/cc03FUFQ9wbZu7yE396YcL870= +google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 h1:OPXtXn7fNMaXwO3JvOmF1QyTc00jsSFFz1vXXBOdCDo= +google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:B5xPO//w8qmBDjGReYLpR6UJPnkldGkCSMoH/2vxJeg= +google.golang.org/genproto/googleapis/api v0.0.0-20240227224415-6ceb2ff114de h1:jFNzHPIeuzhdRwVhbZdiym9q0ory/xY3sA+v2wPg8I0= +google.golang.org/genproto/googleapis/api v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:5iCWqnniDlqZHrd3neWVTOwvh/v6s3232omMecelax8= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:ylj+BE99M198VPbBh6A8d9n3w8fChvyLK3wwBOjXBFA= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20230807174057-1744710a1577/go.mod h1:NjCQG/D8JandXxM57PZbAJL1DCNL6EypA0vPPwfsc7c= +google.golang.org/genproto/googleapis/bytestream v0.0.0-20231030173426-d783a09b4405/go.mod h1:GRUCuLdzVqZte8+Dl/D4N25yLzcGqqWaYkeVOwulFqw= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234015-3fc162c6f38a/go.mod h1:xURIpW9ES5+/GZhnV6beoEtxQrnkRGIfP5VQG2tCBLc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230526203410-71b5a4ffd15e/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230629202037-9506855d4529/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230706204954-ccb25ca9f130/go.mod h1:8mL13HKkDa+IuJ8yruA3ci0q+0vsUz4m//+ottjwS5o= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230711160842-782d3b101e98/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230731190214-cbb8c96f2d6d/go.mod h1:TUfxEVdsvPg18p6AslUXFoLdpED4oBnGwyqk3dV1XzM= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230803162519-f966b187b2e5/go.mod h1:zBEcrKX2ZOcEkHWxBPAIvYUWOKKMIhYcmNiUIu2ji3I= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230920183334-c177e329c48b/go.mod h1:+Bk1OCOj40wS2hwAMA+aCW9ypzm63QTBBHp6lQ3p+9M= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230920204549-e6e6cdab5c13/go.mod h1:KSqppvjFjtoCI+KGd4PELB0qLNxdJHRGqRI09mB6pQA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231002182017-d307bd883b97/go.mod h1:v7nGkzlmW8P3n/bKmWBn2WpBjpOEx8Q6gMueudAmKfY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231012201019-e917dd12ba7a/go.mod h1:4cYg8o5yUbm77w8ZX00LhMVNl/YVBFJRYWDc0uYWMs0= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231016165738-49dd2c1f3d0b/go.mod h1:swOH3j0KzcDDgGUWr+SNpyTen5YrXjS3eyPzFYKc6lc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231030173426-d783a09b4405 h1:AB/lmRny7e2pLhFEYIbl5qkDAUt2h0ZRO4wGPhZf+ik= +google.golang.org/genproto/googleapis/rpc v0.0.0-20231030173426-d783a09b4405/go.mod h1:67X1fPuzjcrkymZzZV1vvkFeTn2Rvc6lYF9MYFGCcwE= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 h1:gphdwh0npgs8elJ4T6J+DQJHPVF7RsuJHCfwztUb4J4= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:daQN87bsDqDoe316QbbvX60nMoJQa4r6Ds0ZuoAe5yA= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de h1:cZGRis4/ot9uVm639a+rHCUaG0JJHEsdyzSQTMX+suY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240227224415-6ceb2ff114de/go.mod h1:H4O17MA/PE9BsGx3w+a+W2VOLLD1Qf7oJneAoU6WktY= +google.golang.org/grpc v0.0.0-20170208002647-2a6bf6142e96/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= @@ -1157,9 +3154,34 @@ google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQ google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc v1.56.1 h1:z0dNfjIl0VpaZ9iSVjA6daGatAYwPGstTjt5vkRMFkQ= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.52.0/go.mod h1:pu6fVzoFb+NBYNAvQL08ic+lvB2IojljRYuun5vorUY= +google.golang.org/grpc v1.52.3/go.mod h1:pu6fVzoFb+NBYNAvQL08ic+lvB2IojljRYuun5vorUY= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +google.golang.org/grpc v1.54.0/go.mod h1:PUSEXI6iWghWaB6lXM4knEgpJNu2qUcKfDtNci3EC2g= +google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8= google.golang.org/grpc v1.56.1/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= +google.golang.org/grpc v1.56.2/go.mod h1:I9bI3vqKfayGqPUAwGdOSu7kt6oIJLixfffKrpXqQ9s= +google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo= +google.golang.org/grpc v1.58.2/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0= +google.golang.org/grpc v1.58.3/go.mod h1:tgX3ZQDlNJGU96V6yHh1T/JeoBQ2TXdr43YbYSsCJk0= +google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk= +google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98= +google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU= +google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM= +google.golang.org/grpc v1.63.2 h1:MUeiw1B2maTVZthpU5xvASfTh3LDbxHd6IJ6QQVU+xM= +google.golang.org/grpc v1.63.2/go.mod h1:WAX/8DgncnokcFUldAxq7GeB5DXHDbMF+lLvDomNkRA= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= @@ -1174,37 +3196,55 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= +google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= +google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= +gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y= +gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA= gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA= +gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c= -gopkg.in/olebedev/go-duktape.v3 v3.0.0-20190213234257-ec84240a7772/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= -gopkg.in/sourcemap.v1 v1.0.5/go.mod h1:2RlvNNSMglmRrcvhfuzp4hQHwOtjxlbjX7UPY/GXb78= +gopkg.in/src-d/go-billy.v4 v4.3.2/go.mod h1:nDjArDMp+XMs1aFAESLRjfGSgfvoYN0hDfzEk0GjC98= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/urfave/cli.v1 v1.20.0/go.mod h1:vuBzUtMdQeixQj8LVd+/98pzhxNGQoyuPBlsXHOQNO0= gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74= gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= -gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -1212,19 +3252,80 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -lukechampine.com/blake3 v1.1.7 h1:GgRMhmdsuK8+ii6UZFDL8Nb+VyMwadAgcJyfYHxG6n0= +honnef.co/go/tools v0.1.3/go.mod h1:NgwopIslSNH47DimFoV78dnkksY2EFtX0ajyb3K/las= lukechampine.com/blake3 v1.1.7/go.mod h1:tkKEOtDkNtklkXtLNEOGNq5tcV90tJiA1vAA12R78LA= +lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI= +lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k= +lukechampine.com/uint128 v1.1.1/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +lukechampine.com/uint128 v1.2.0/go.mod h1:c4eWIwlEGaxC/+H1VguhU4PHXNWDCDMUlWdIWl2j1gk= +modernc.org/cc/v3 v3.36.0/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.2/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.36.3/go.mod h1:NFUHyPn4ekoC/JHeZFfZurN6ixxawE1BnVonP/oahEI= +modernc.org/cc/v3 v3.37.0/go.mod h1:vtL+3mdHx/wcj3iEGz84rQa8vEqR6XM84v5Lcvfph20= +modernc.org/cc/v3 v3.40.0/go.mod h1:/bTg4dnWkSXowUO6ssQKnOV0yMVxDYNIsIrzqTFDGH0= +modernc.org/ccgo/v3 v3.0.0-20220428102840-41399a37e894/go.mod h1:eI31LL8EwEBKPpNpA4bU1/i+sKOwOrQy8D87zWUcRZc= +modernc.org/ccgo/v3 v3.0.0-20220430103911-bc99d88307be/go.mod h1:bwdAnOoaIt8Ax9YdWGjxWsdkPcZyRPHqrOvJxaKAKGw= +modernc.org/ccgo/v3 v3.0.0-20220904174949-82d86e1b6d56/go.mod h1:YSXjPL62P2AMSxBphRHPn7IkzhVHqkvOnRKAKh+W6ZI= +modernc.org/ccgo/v3 v3.16.4/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.6/go.mod h1:tGtX0gE9Jn7hdZFeU88slbTh1UtCYKusWOoCJuvkWsQ= +modernc.org/ccgo/v3 v3.16.8/go.mod h1:zNjwkizS+fIFDrDjIAgBSCLkWbJuHF+ar3QRn+Z9aws= +modernc.org/ccgo/v3 v3.16.9/go.mod h1:zNMzC9A9xeNUepy6KuZBbugn3c0Mc9TeiJO4lgvkJDo= +modernc.org/ccgo/v3 v3.16.13-0.20221017192402-261537637ce8/go.mod h1:fUB3Vn0nVPReA+7IG7yZDfjv1TMWjhQP8gCxrFAtL5g= +modernc.org/ccgo/v3 v3.16.13/go.mod h1:2Quk+5YgpImhPjv2Qsob1DnZ/4som1lJTodubIcoUkY= +modernc.org/ccorpus v1.11.6/go.mod h1:2gEUTrWqdpH2pXsmTM1ZkjeSrUWDpjMu2T6m29L/ErQ= +modernc.org/httpfs v1.0.6/go.mod h1:7dosgurJGp0sPaRanU53W4xZYKh14wfzX420oZADeHM= +modernc.org/libc v0.0.0-20220428101251-2d5f3daf273b/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.16.0/go.mod h1:N4LD6DBE9cf+Dzf9buBlzVJndKr/iJHG97vGLHYnb5A= +modernc.org/libc v1.16.1/go.mod h1:JjJE0eu4yeK7tab2n4S1w8tlWd9MxXLRzheaRnAKymU= +modernc.org/libc v1.16.17/go.mod h1:hYIV5VZczAmGZAnG15Vdngn5HSF5cSkbvfz2B7GRuVU= +modernc.org/libc v1.16.19/go.mod h1:p7Mg4+koNjc8jkqwcoFBJx7tXkpj00G77X7A72jXPXA= +modernc.org/libc v1.17.0/go.mod h1:XsgLldpP4aWlPlsjqKRdHPqCxCjISdHfM/yeWC5GyW0= +modernc.org/libc v1.17.1/go.mod h1:FZ23b+8LjxZs7XtFMbSzL/EhPxNbfZbErxEHc7cbD9s= +modernc.org/libc v1.17.4/go.mod h1:WNg2ZH56rDEwdropAJeZPQkXmDwh+JCA1s/htl6r2fA= +modernc.org/libc v1.18.0/go.mod h1:vj6zehR5bfc98ipowQOM2nIDUZnVew/wNC/2tOGS+q0= +modernc.org/libc v1.20.3/go.mod h1:ZRfIaEkgrYgZDl6pa4W39HgN5G/yDW+NRmNKZBDFrk0= +modernc.org/libc v1.21.4/go.mod h1:przBsL5RDOZajTVslkugzLBj1evTue36jEomFQOoYuI= +modernc.org/libc v1.22.2/go.mod h1:uvQavJ1pZ0hIoC/jfqNoMLURIMhKzINIWypNM17puug= modernc.org/libc v1.22.3 h1:D/g6O5ftAfavceqlLOFwaZuA5KYafKwmr30A6iSqoyY= modernc.org/libc v1.22.3/go.mod h1:MQrloYP209xa2zHome2a8HLiLm6k0UT8CoHpV74tOFw= +modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw= +modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE= +modernc.org/mathutil v1.2.2/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= modernc.org/mathutil v1.5.0 h1:rV0Ko/6SfM+8G+yKiyI830l3Wuz1zRutdslNoQ0kfiQ= modernc.org/mathutil v1.5.0/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E= +modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4= +modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo= +modernc.org/memory v1.1.1/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.0/go.mod h1:/0wo5ibyrQiaoUoH7f9D8dnglAmILJ5/cxZlRECf+Nw= +modernc.org/memory v1.2.1/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/memory v1.3.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/memory v1.4.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= modernc.org/memory v1.5.0 h1:N+/8c5rE6EqugZwHii4IFsaJ7MUhoWX07J5tC/iI5Ds= modernc.org/memory v1.5.0/go.mod h1:PkUhL0Mugw21sHPeskwZW4D6VscE/GQJOnIpCnW6pSU= +modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E= +modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E= +modernc.org/opt v0.1.1/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/opt v0.1.3/go.mod h1:WdSiB5evDcignE70guQKxYUl14mgWtbClRi5wmkkTX0= +modernc.org/sqlite v1.18.1/go.mod h1:6ho+Gow7oX5V+OiOQ6Tr4xeqbx13UZ6t+Fw9IRUG4d4= +modernc.org/sqlite v1.18.2/go.mod h1:kvrTLEWgxUcHa2GfHBQtanR1H9ht3hTJNtKpzH9k1u0= modernc.org/sqlite v1.21.1 h1:GyDFqNnESLOhwwDRaHGdp2jKLDzpyT/rNLglX3ZkMSU= modernc.org/sqlite v1.21.1/go.mod h1:XwQ0wZPIh1iKb5mkvCJ3szzbhk+tykC8ZWqTRTgYRwI= +modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ= +modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0= +modernc.org/strutil v1.1.1/go.mod h1:DE+MQQ/hjKBZS2zNInV5hhcipt5rLPWkmpbGeW5mmdw= +modernc.org/strutil v1.1.3/go.mod h1:MEHNA7PdEnEwLvspRMtWTNnp2nnyvMfkimT1NKNAGbw= +modernc.org/tcl v1.13.1/go.mod h1:XOLfOwzhkljL4itZkK6T72ckMgvj0BDsnKNdZVUOecw= +modernc.org/tcl v1.13.2/go.mod h1:7CLiGIPo1M8Rv1Mitpv5akc2+8fxUd2y2UzC/MfMzy0= +modernc.org/token v1.0.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= +modernc.org/z v1.5.1/go.mod h1:eWFB510QWW5Th9YGZT81s+LwvaAs3Q2yr4sP0rmLkv8= pgregory.net/rapid v0.4.7 h1:MTNRktPuv5FNqOO151TM9mDTa+XHcX6ypYeISDVD14g= pgregory.net/rapid v0.4.7/go.mod h1:UYpPVyjFHzYBGHIxLFoupi8vwk6rXNzRY9OMvVxFIOU= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/lib/go/test/test.go b/lib/go/test/test.go index 14bb8736..94934194 100644 --- a/lib/go/test/test.go +++ b/lib/go/test/test.go @@ -6,6 +6,7 @@ import ( "io/ioutil" "testing" + "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/onflow/cadence" jsoncdc "github.com/onflow/cadence/encoding/json" "github.com/onflow/flow-emulator/convert" @@ -21,8 +22,12 @@ import ( "github.com/rs/zerolog" ) +// this is added to resolve the issue with chainhash ambiguous import, +// the code is not used, but it's needed to force go.mod specify and retain chainhash version +// workaround for issue: https://github.com/golang/go/issues/27899 +var _ = chainhash.Hash{} + // Sets up testing and emulator objects and initialize the emulator default addresses -// func newTestSetup(t *testing.T) (emulator.Emulator, *adapters.SDKAdapter, *test.AccountKeys) { // Set for parallel processing t.Parallel() @@ -211,12 +216,11 @@ func bytesToCadenceArray(b []byte) cadence.Array { // assertEqual asserts that two objects are equal. // -// assertEqual(t, 123, 123) +// assertEqual(t, 123, 123) // // Pointer variable equality is determined based on the equality of the // referenced values (as opposed to the memory addresses). Function equality // cannot be determined and will always fail. -// func assertEqual(t *testing.T, expected, actual interface{}) bool { if assert.ObjectsAreEqual(expected, actual) { diff --git a/lib/go/test/token_test.go b/lib/go/test/token_test.go index f672e8ca..c7460a82 100644 --- a/lib/go/test/token_test.go +++ b/lib/go/test/token_test.go @@ -5,111 +5,125 @@ import ( "testing" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" "github.com/onflow/cadence" jsoncdc "github.com/onflow/cadence/encoding/json" - "github.com/onflow/cadence/runtime/common" "github.com/onflow/flow-go-sdk" "github.com/onflow/flow-go-sdk/crypto" "github.com/onflow/flow-ft/lib/go/templates" ) +// Steps: +// +// 1. All the token contracts deploy properly +// 2. Total supply is initialized to 1000.0 func TestTokenDeployment(t *testing.T) { b, adapter, accountKeys := newTestSetup(t) exampleTokenAccountKey, _ := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, _, _, _ := DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) + + env := templates.Environment{} + + _ = deployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}, &env) t.Run("Should have initialized Supply field correctly", func(t *testing.T) { - script := templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script := templates.GenerateInspectSupplyScript(env) supply := executeScriptAndCheck(t, b, script, nil) assert.Equal(t, CadenceUFix64("1000.0"), supply) }) } -func TestCreateToken(t *testing.T) { +// Steps: +// +// 1. Create an empty vault that doesn't change the total supply +// (verify directly and through the metadata view) +func TestTokenSetupAccount(t *testing.T) { b, adapter, accountKeys := newTestSetup(t) - serviceSigner, _ := b.ServiceKey().Signer() - exampleTokenAccountKey, _ := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, _, metadataViewsAddr, fungibleMetadataViewsAddr := DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) - joshAccountKey, joshSigner := accountKeys.NewWithSigner() - joshAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{joshAccountKey}, nil) + env := templates.Environment{} + exampleTokenAddr := deployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}, &env) t.Run("Should be able to create empty Vault that doesn't affect supply", func(t *testing.T) { - script := templates.GenerateCreateTokenScript(fungibleAddr, exampleTokenAddr, metadataViewsAddr, "ExampleToken") - tx := createTxWithTemplateAndAuthorizer(b, script, joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, + joshAddress, _, _ := createAccountWithVault(b, adapter, t, + accountKeys, + env, ) - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Make sure the vault balance is zero + script := templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }, ) - assert.Equal(t, CadenceUFix64("0.0"), result) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Directly query the total supply to make sure it hasn't changed + script = templates.GenerateInspectSupplyScript(env) supply := executeScriptAndCheck(t, b, script, nil) assert.Equal(t, CadenceUFix64("1000.0"), supply) - script = templates.GenerateInspectSupplyViewScript(fungibleAddr, exampleTokenAddr, metadataViewsAddr, fungibleMetadataViewsAddr, "ExampleToken") + // Query the total supply via the metadata view to make sure it is also correct + script = templates.GenerateInspectSupplyViewScript(env) supply = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }) assert.Equal(t, CadenceUFix64("1000.0"), supply) }) + + t.Run("Should be able to create empty Vault with the generic setup transaction", func(t *testing.T) { + newAccountKey, newSigner := accountKeys.NewWithSigner() + newAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{newAccountKey}, nil) + + serviceSigner, _ := b.ServiceKey().Signer() + + // Setup new account with an empty vault + script := templates.GenerateSetupAccountFromAddressScript(env.FungibleTokenAddress, env.FungibleTokenMetadataViewsAddress) + tx := createTxWithTemplateAndAuthorizer(b, script, newAddress) + + tx.AddArgument(cadence.NewAddress(exampleTokenAddr)) + tx.AddArgument(cadence.String("ExampleToken")) + + signAndSubmit( + t, b, tx, + []flow.Address{ + b.ServiceKey().Address, + newAddress, + }, + []crypto.Signer{ + serviceSigner, + newSigner, + }, + false, + ) + }) } -func TestExternalTransfers(t *testing.T) { +// Steps: +// +// 1. Make sure extra tokens cannot be withdrawn +// 2. Test a regular transfer +// 3. Test a transfer to multiple accounts +func TestTokenExternalTransfers(t *testing.T) { b, adapter, accountKeys := newTestSetup(t) serviceSigner, _ := b.ServiceKey().Signer() exampleTokenAccountKey, exampleTokenSigner := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, forwardingAddr, metadataViewsAddr, _ := - DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) - - joshAccountKey, joshSigner := accountKeys.NewWithSigner() - joshAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{joshAccountKey}, nil) - - // then deploy the tokens to an account - script := templates.GenerateCreateTokenScript(fungibleAddr, exampleTokenAddr, metadataViewsAddr, "ExampleToken") - tx := createTxWithTemplateAndAuthorizer(b, script, joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, + env := templates.Environment{} + exampleTokenAddr := deployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}, &env) + + joshAddress, _, joshSigner := createAccountWithVault(b, adapter, t, + accountKeys, + env, ) t.Run("Shouldn't be able to withdraw more than the balance of the Vault", func(t *testing.T) { - script := templates.GenerateTransferVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script := templates.GenerateTransferVaultScript(env) tx := createTxWithTemplateAndAuthorizer(b, script, exampleTokenAddr) _ = tx.AddArgument(CadenceUFix64("30000.0")) @@ -129,29 +143,29 @@ func TestExternalTransfers(t *testing.T) { ) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Sender vault + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) - assert.Equal(t, CadenceUFix64("1000.0"), result) - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Receiver Vault + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }, ) - assert.Equal(t, CadenceUFix64("0.0"), result) }) t.Run("Should be able to withdraw and deposit tokens from a vault", func(t *testing.T) { - script := templates.GenerateTransferVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script := templates.GenerateTransferVaultScript(env) tx := createTxWithTemplateAndAuthorizer(b, script, exampleTokenAddr) @@ -172,115 +186,44 @@ func TestExternalTransfers(t *testing.T) { ) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Sender vault + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) - assert.Equal(t, CadenceUFix64("700.0"), result) - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Receiver Vault + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }, ) - assert.Equal(t, CadenceUFix64("300.0"), result) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assert.Equal(t, CadenceUFix64("1000.0"), supply) - }) - - t.Run("Should be able to transfer to multiple accounts ", func(t *testing.T) { - - recipient1Address := cadence.Address(joshAddress) - recipient1Amount := CadenceUFix64("300.0") - - pair := cadence.KeyValuePair{Key: recipient1Address, Value: recipient1Amount} - recipientPairs := make([]cadence.KeyValuePair, 1) - recipientPairs[0] = pair - - script := templates.GenerateTransferManyAccountsScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - - tx := flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(exampleTokenAddr) - - _ = tx.AddArgument(cadence.NewDictionary(recipientPairs)) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - exampleTokenAddr, - }, - []crypto.Signer{ - serviceSigner, - exampleTokenSigner, - }, - false, - ) - - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result, err := b.ExecuteScript( - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), - }, - ) - require.NoError(t, err) - if !assert.True(t, result.Succeeded()) { - t.Log(result.Error.Error()) - } - balance := result.Value - assert.Equal(t, CadenceUFix64("400.0"), balance) - - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result, err = b.ExecuteScript( - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(joshAddress)), - }, - ) - require.NoError(t, err) - if !assert.True(t, result.Succeeded()) { - t.Log(result.Error.Error()) - } - balance = result.Value - assert.Equal(t, CadenceUFix64("600.0"), balance) - - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Supply should not have changed + script = templates.GenerateInspectSupplyScript(env) supply := executeScriptAndCheck(t, b, script, nil) assert.Equal(t, CadenceUFix64("1000.0"), supply) }) - t.Run("Should be able to transfer tokens through a forwarder from a vault", func(t *testing.T) { + t.Run("Should be able to transfer tokens with the generic transfer transactions", func(t *testing.T) { - script := templates.GenerateCreateForwarderScript( - fungibleAddr, - forwardingAddr, - exampleTokenAddr, - "ExampleToken", - ) + script := templates.GenerateTransferGenericVaultWithPathsScript(env.FungibleTokenAddress) tx := createTxWithTemplateAndAuthorizer(b, script, joshAddress) + _ = tx.AddArgument(CadenceUFix64("300.0")) _ = tx.AddArgument(cadence.NewAddress(exampleTokenAddr)) + tx.AddArgument(cadence.String("exampleTokenVault")) + tx.AddArgument(cadence.String("exampleTokenReceiver")) + signAndSubmit( t, b, tx, []flow.Address{ @@ -294,82 +237,51 @@ func TestExternalTransfers(t *testing.T) { false, ) - script = templates.GenerateTransferVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - tx = createTxWithTemplateAndAuthorizer(b, script, exampleTokenAddr) - - _ = tx.AddArgument(CadenceUFix64("300.0")) - _ = tx.AddArgument(cadence.NewAddress(joshAddress)) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - exampleTokenAddr, - }, - []crypto.Signer{ - serviceSigner, - exampleTokenSigner, - }, - false, - ) - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) - assertEqual(t, CadenceUFix64("400.0"), result) + assertEqual(t, CadenceUFix64("1000.0"), result) - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }, ) - assertEqual(t, CadenceUFix64("600.0"), result) - - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assertEqual(t, CadenceUFix64("1000.0"), supply) - }) - - t.Run("Should be able to transfer tokens with the generic transfer transaction", func(t *testing.T) { + assertEqual(t, CadenceUFix64("0.0"), result) - script := templates.GenerateTransferGenericVaultScript( - fungibleAddr, - ) + script = templates.GenerateTransferGenericVaultWithAddressScript(env.FungibleTokenAddress, env.FungibleTokenMetadataViewsAddress) - tx := createTxWithTemplateAndAuthorizer(b, script, joshAddress) + tx = createTxWithTemplateAndAuthorizer(b, script, exampleTokenAddr) _ = tx.AddArgument(CadenceUFix64("300.0")) - _ = tx.AddArgument(cadence.NewAddress(exampleTokenAddr)) - - storagePath := cadence.Path{Domain: common.PathDomainStorage, Identifier: "exampleTokenVault"} - publicPath := cadence.Path{Domain: common.PathDomainPublic, Identifier: "exampleTokenReceiver"} + _ = tx.AddArgument(cadence.NewAddress(joshAddress)) - _ = tx.AddArgument(storagePath) - _ = tx.AddArgument(publicPath) + tx.AddArgument(cadence.NewAddress(exampleTokenAddr)) + tx.AddArgument(cadence.String("ExampleToken")) signAndSubmit( t, b, tx, []flow.Address{ b.ServiceKey().Address, - joshAddress, + exampleTokenAddr, }, []crypto.Signer{ serviceSigner, - joshSigner, + exampleTokenSigner, }, false, ) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result := executeScriptAndCheck(t, b, + script = templates.GenerateInspectVaultScript(env) + result = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), @@ -377,7 +289,7 @@ func TestExternalTransfers(t *testing.T) { ) assertEqual(t, CadenceUFix64("700.0"), result) - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ @@ -389,103 +301,33 @@ func TestExternalTransfers(t *testing.T) { }) } -func TestVaultDestroy(t *testing.T) { +// Steps: +// +// 1. Setup a forwarder in josh's account to forward to the token address +// 2. Test a transfer from the token account to josh, which will go back to the token account +func TestTokenForwarding(t *testing.T) { b, adapter, accountKeys := newTestSetup(t) serviceSigner, _ := b.ServiceKey().Signer() + env := templates.Environment{} + exampleTokenAccountKey, exampleTokenSigner := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, _, metadataViewsAddr, _ := DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) - - joshAccountKey, joshSigner := accountKeys.NewWithSigner() - joshAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{joshAccountKey}, nil) - - // then deploy the tokens to an account - script := templates.GenerateCreateTokenScript(fungibleAddr, exampleTokenAddr, metadataViewsAddr, "ExampleToken") - tx := flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, - ) + exampleTokenAddr := deployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}, &env) - script = templates.GenerateTransferVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - tx = flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(exampleTokenAddr) - - _ = tx.AddArgument(CadenceUFix64("300.0")) - _ = tx.AddArgument(cadence.NewAddress(joshAddress)) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - exampleTokenAddr, - }, - []crypto.Signer{ - serviceSigner, - exampleTokenSigner, - }, - false, + joshAddress, _, joshSigner := createAccountWithVault(b, adapter, t, + accountKeys, + env, ) - t.Run("Should subtract tokens from supply when they are destroyed", func(t *testing.T) { - script := templates.GenerateDestroyVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken", 100) - tx := createTxWithTemplateAndAuthorizer( - b, script, exampleTokenAddr) - - signAndSubmit( - t, b, tx, - []flow.Address{b.ServiceKey().Address, exampleTokenAddr}, - []crypto.Signer{serviceSigner, exampleTokenSigner}, - false, - ) - - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result := executeScriptAndCheck(t, b, - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), - }, - ) + t.Run("Should be able to transfer tokens through a forwarder from a vault", func(t *testing.T) { - assert.Equal(t, CadenceUFix64("600.0"), result) + // Setup the forwarder in josh's account to forward to the token addr + script := templates.GenerateCreateForwarderScript(env) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assert.Equal(t, CadenceUFix64("900.0"), supply) - }) + tx := createTxWithTemplateAndAuthorizer(b, script, joshAddress) - t.Run("Should subtract tokens from supply when they are destroyed by a different account", func(t *testing.T) { - script := templates.GenerateDestroyVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken", 100) - tx := createTxWithTemplateAndAuthorizer( - b, script, joshAddress) + _ = tx.AddArgument(cadence.NewAddress(exampleTokenAddr)) signAndSubmit( t, b, tx, @@ -500,68 +342,13 @@ func TestVaultDestroy(t *testing.T) { false, ) - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - result := executeScriptAndCheck(t, b, - script, - [][]byte{ - jsoncdc.MustEncode(cadence.Address(joshAddress)), - }, - ) - - assert.Equal(t, CadenceUFix64("200.0"), result) - - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assert.Equal(t, CadenceUFix64("800.0"), supply) - }) - -} - -func TestMintingAndBurning(t *testing.T) { - b, adapter, accountKeys := newTestSetup(t) - - serviceSigner, _ := b.ServiceKey().Signer() - - exampleTokenAccountKey, exampleTokenSigner := accountKeys.NewWithSigner() - fungibleAddr, exampleTokenAddr, _, metadataViewsAddr, _ := DeployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}) - - joshAccountKey, joshSigner := accountKeys.NewWithSigner() - joshAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{joshAccountKey}, nil) - - // then deploy the tokens to an account - script := templates.GenerateCreateTokenScript(fungibleAddr, exampleTokenAddr, metadataViewsAddr, "ExampleToken") - tx := flow.NewTransaction(). - SetScript(script). - SetGasLimit(100). - SetProposalKey( - b.ServiceKey().Address, - b.ServiceKey().Index, - b.ServiceKey().SequenceNumber, - ). - SetPayer(b.ServiceKey().Address). - AddAuthorizer(joshAddress) - - signAndSubmit( - t, b, tx, - []flow.Address{ - b.ServiceKey().Address, - joshAddress, - }, - []crypto.Signer{ - serviceSigner, - joshSigner, - }, - false, - ) - - t.Run("Shouldn't be able to mint zero tokens", func(t *testing.T) { - script := templates.GenerateMintTokensScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - tx := createTxWithTemplateAndAuthorizer( - b, script, exampleTokenAddr) + // Transfer tokens from the token account to josh + // which will be forwarded back to the token account + script = templates.GenerateTransferVaultScript(env) + tx = createTxWithTemplateAndAuthorizer(b, script, exampleTokenAddr) + _ = tx.AddArgument(CadenceUFix64("300.0")) _ = tx.AddArgument(cadence.NewAddress(joshAddress)) - _ = tx.AddArgument(CadenceUFix64("0.0")) signAndSubmit( t, b, tx, @@ -573,38 +360,53 @@ func TestMintingAndBurning(t *testing.T) { serviceSigner, exampleTokenSigner, }, - true, + false, ) - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Assert that the vaults' balances are correct (the same as before) + // Token account (sender) + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) + assertEqual(t, CadenceUFix64("1000.0"), result) - assert.Equal(t, CadenceUFix64("1000.0"), result) - - // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Receiver account + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(joshAddress)), }, ) + assertEqual(t, CadenceUFix64("0.0"), result) + }) +} - assert.Equal(t, CadenceUFix64("0.0"), result) +// Steps: +// +// 1. Mint tokens with the ExampleToken Admin (verify that supply and balances are increased) +// 2. Burn tokens, which will decrease the supply and balances +func TestMintingAndBurning(t *testing.T) { + b, adapter, accountKeys := newTestSetup(t) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") - supply := executeScriptAndCheck(t, b, script, nil) - assert.Equal(t, CadenceUFix64("1000.0"), supply) - }) + serviceSigner, _ := b.ServiceKey().Signer() + + env := templates.Environment{} + + exampleTokenAccountKey, exampleTokenSigner := accountKeys.NewWithSigner() + exampleTokenAddr := deployTokenContracts(b, adapter, t, []*flow.AccountKey{exampleTokenAccountKey}, &env) + + joshAddress, _, _ := createAccountWithVault(b, adapter, t, + accountKeys, + env, + ) t.Run("Should mint tokens, deposit, and update balance and total supply", func(t *testing.T) { - script := templates.GenerateMintTokensScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script := templates.GenerateMintTokensScript(env) tx := createTxWithTemplateAndAuthorizer( b, script, exampleTokenAddr) @@ -625,18 +427,19 @@ func TestMintingAndBurning(t *testing.T) { ) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // token account should not have increased + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) - assert.Equal(t, CadenceUFix64("1000.0"), result) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // Josh account should have increased by 50, the amount minted + script = templates.GenerateInspectVaultScript(env) result = executeScriptAndCheck(t, b, script, [][]byte{ @@ -646,13 +449,13 @@ func TestMintingAndBurning(t *testing.T) { assert.Equal(t, CadenceUFix64("50.0"), result) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script = templates.GenerateInspectSupplyScript(env) supply := executeScriptAndCheck(t, b, script, nil) assert.Equal(t, CadenceUFix64("1050.0"), supply) }) t.Run("Should burn tokens and update balance and total supply", func(t *testing.T) { - script := templates.GenerateBurnTokensScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + script := templates.GenerateBurnTokensScript(env) tx := createTxWithTemplateAndAuthorizer( b, script, exampleTokenAddr) @@ -672,17 +475,18 @@ func TestMintingAndBurning(t *testing.T) { ) // Assert that the vaults' balances are correct - script = templates.GenerateInspectVaultScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // token account balance should have decreased by the burned amount + script = templates.GenerateInspectVaultScript(env) result := executeScriptAndCheck(t, b, script, [][]byte{ jsoncdc.MustEncode(cadence.Address(exampleTokenAddr)), }, ) - assert.Equal(t, CadenceUFix64("950.0"), result) - script = templates.GenerateInspectSupplyScript(fungibleAddr, exampleTokenAddr, "ExampleToken") + // total supply also decreases by the burned amount + script = templates.GenerateInspectSupplyScript(env) supply := executeScriptAndCheck(t, b, script, nil) assert.Equal(t, CadenceUFix64("1000.0"), supply) }) diff --git a/lib/go/test/token_test_helpers.go b/lib/go/test/token_test_helpers.go index cff3ee92..d0b6a6f4 100644 --- a/lib/go/test/token_test_helpers.go +++ b/lib/go/test/token_test_helpers.go @@ -4,9 +4,13 @@ import ( "context" "testing" + "github.com/onflow/flow-ft/lib/go/templates" + "github.com/onflow/flow-emulator/adapters" "github.com/onflow/flow-emulator/emulator" + "github.com/onflow/flow-go-sdk/crypto" sdktemplates "github.com/onflow/flow-go-sdk/templates" + "github.com/onflow/flow-go-sdk/test" "github.com/stretchr/testify/assert" "github.com/onflow/flow-go-sdk" @@ -18,22 +22,32 @@ import ( // Deploys the FungibleToken, ExampleToken, and TokenForwarding contracts // to different accounts and returns their addresses -func DeployTokenContracts( +func deployTokenContracts( b emulator.Emulator, adapter *adapters.SDKAdapter, t *testing.T, key []*flow.AccountKey, + env *templates.Environment, ) ( - fungibleAddr flow.Address, tokenAddr flow.Address, - forwardingAddr flow.Address, - metadataViewsAddr flow.Address, - fungibleMetadataViewsAddr flow.Address, ) { var err error + // Deploy the ViewResolver contract + resolverAddress, err := adapter.CreateAccount(context.Background(), + nil, + []sdktemplates.Contract{ + { + Name: "ViewResolver", + Source: string(nftcontracts.ViewResolver()), + }, + }, + ) + assert.NoError(t, err) + env.ViewResolverAddress = resolverAddress.Hex() + // Deploy the NonFungibleToken contract - nonFungibleTokenCode := nftcontracts.NonFungibleToken() + nonFungibleTokenCode := nftcontracts.NonFungibleToken(env.ViewResolverAddress) nftAddress, err := adapter.CreateAccount(context.Background(), nil, []sdktemplates.Contract{ @@ -45,9 +59,22 @@ func DeployTokenContracts( ) assert.NoError(t, err) + // Deploy the Burner contract + burnerAddress, err := adapter.CreateAccount(context.Background(), + nil, + []sdktemplates.Contract{ + { + Name: "Burner", + Source: string(contracts.Burner()), + }, + }, + ) + assert.NoError(t, err) + env.BurnerAddress = burnerAddress.Hex() + // Deploy the FungibleToken contract - fungibleTokenCode := contracts.FungibleToken() - fungibleAddr, err = adapter.CreateAccount(context.Background(), + fungibleTokenCode := contracts.FungibleToken(resolverAddress.String(), burnerAddress.String()) + fungibleAddr, err := adapter.CreateAccount(context.Background(), nil, []sdktemplates.Contract{ { @@ -57,13 +84,11 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) - - _, err = b.CommitBlock() - assert.NoError(t, err) + env.FungibleTokenAddress = fungibleAddr.Hex() // Deploy the MetadataViews contract - metadataViewsCode := nftcontracts.MetadataViews(fungibleAddr, nftAddress) - metadataViewsAddr, err = adapter.CreateAccount(context.Background(), + metadataViewsCode := nftcontracts.MetadataViews(env.FungibleTokenAddress, nftAddress.Hex(), env.ViewResolverAddress) + metadataViewsAddr, err := adapter.CreateAccount(context.Background(), nil, []sdktemplates.Contract{ { @@ -73,10 +98,11 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) + env.MetadataViewsAddress = metadataViewsAddr.Hex() // Deploy the FungibleTokenMetadataViews contract - fungibleTokenMetadataViewsCode := contracts.FungibleTokenMetadataViews(fungibleAddr.String(), metadataViewsAddr.String()) - fungibleMetadataViewsAddr, err = adapter.CreateAccount(context.Background(), + fungibleTokenMetadataViewsCode := contracts.FungibleTokenMetadataViews(fungibleAddr.String(), metadataViewsAddr.String(), resolverAddress.String()) + fungibleMetadataViewsAddr, err := adapter.CreateAccount(context.Background(), nil, []sdktemplates.Contract{ { @@ -86,9 +112,7 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) - - _, err = b.CommitBlock() - assert.NoError(t, err) + env.FungibleTokenMetadataViewsAddress = fungibleMetadataViewsAddr.Hex() // Deploy the ExampleToken contract exampleTokenCode := contracts.ExampleToken(fungibleAddr.String(), metadataViewsAddr.String(), fungibleMetadataViewsAddr.String()) @@ -102,13 +126,11 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) - - _, err = b.CommitBlock() - assert.NoError(t, err) + env.ExampleTokenAddress = tokenAddr.Hex() // Deploy the TokenForwarding contract forwardingCode := contracts.TokenForwarding(fungibleAddr.String()) - forwardingAddr, err = adapter.CreateAccount(context.Background(), + forwardingAddr, err := adapter.CreateAccount(context.Background(), key, []sdktemplates.Contract{ { @@ -118,13 +140,11 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) - - _, err = b.CommitBlock() - assert.NoError(t, err) + env.TokenForwardingAddress = forwardingAddr.Hex() // Deploy the FungibleTokenSwitchboard contract switchboardCode := contracts.FungibleTokenSwitchboard(fungibleAddr.String()) - _, err = adapter.CreateAccount(context.Background(), + switchboardAddr, err := adapter.CreateAccount(context.Background(), key, []sdktemplates.Contract{ { @@ -134,9 +154,56 @@ func DeployTokenContracts( }, ) assert.NoError(t, err) + env.SwitchboardAddress = switchboardAddr.Hex() + + // // Deploy the PrivateReceiverForwarder contract + // privateRecFor := contracts.PrivateReceiverForwarder(fungibleAddr.String()) + // _, err = adapter.CreateAccount(context.Background(), + // key, + // []sdktemplates.Contract{ + // { + // Name: "PrivateReceiverForwarder", + // Source: string(privateRecFor), + // }, + // }, + // ) + // assert.NoError(t, err) _, err = b.CommitBlock() assert.NoError(t, err) - return fungibleAddr, tokenAddr, forwardingAddr, metadataViewsAddr, fungibleMetadataViewsAddr + return tokenAddr +} + +func createAccountWithVault( + b emulator.Emulator, + adapter *adapters.SDKAdapter, + t *testing.T, + keys *test.AccountKeys, + env templates.Environment, +) ( + flow.Address, *flow.AccountKey, crypto.Signer, +) { + + newAccountKey, newSigner := keys.NewWithSigner() + newAddress, _ := adapter.CreateAccount(context.Background(), []*flow.AccountKey{newAccountKey}, nil) + + serviceSigner, _ := b.ServiceKey().Signer() + + // Setup new account with an empty vault + script := templates.GenerateCreateTokenScript(env) + tx := createTxWithTemplateAndAuthorizer(b, script, newAddress) + signAndSubmit( + t, b, tx, + []flow.Address{ + b.ServiceKey().Address, + newAddress, + }, + []crypto.Signer{ + serviceSigner, + newSigner, + }, + false, + ) + return newAddress, newAccountKey, newSigner } diff --git a/tests/test_example_token.cdc b/tests/example_token_test.cdc similarity index 69% rename from tests/test_example_token.cdc rename to tests/example_token_test.cdc index 01f23270..840752ec 100644 --- a/tests/test_example_token.cdc +++ b/tests/example_token_test.cdc @@ -1,36 +1,22 @@ import Test import BlockchainHelpers +import "test_helpers.cdc" import "FungibleTokenMetadataViews" import "ExampleToken" +import "FungibleToken" access(all) let admin = Test.getAccount(0x0000000000000007) access(all) let recipient = Test.createAccount() access(all) fun setup() { - var err = Test.deployContract( - name: "FungibleTokenMetadataViews", - path: "../contracts/FungibleTokenMetadataViews.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) - - err = Test.deployContract( - name: "ExampleToken", - path: "../contracts/ExampleToken.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) -} - -access(all) -fun testTokensInitializedEventEmitted() { - let typ = Type() - let events = Test.eventsOfType(typ) - Test.assertEqual(1, events.length) - - let event = events[0] as! ExampleToken.TokensInitialized - Test.assertEqual(1000.0, event.initialSupply) + deploy("ViewResolver", "../contracts/utility/ViewResolver.cdc") + deploy("Burner", "../contracts/utility/Burner.cdc") + deploy("FungibleToken", "../contracts/FungibleToken.cdc") + deploy("NonFungibleToken", "../contracts/utility/NonFungibleToken.cdc") + deploy("MetadataViews", "../contracts/utility/MetadataViews.cdc") + deploy("FungibleTokenMetadataViews", "../contracts/FungibleTokenMetadataViews.cdc") + deploy("ExampleToken", "../contracts/ExampleToken.cdc") } access(all) @@ -89,25 +75,19 @@ fun testMintTokens() { // Test that the proper events were emitted var typ = Type() var events = Test.eventsOfType(typ) - Test.assertEqual(1, events.length) + Test.assertEqual(2, events.length) - let tokensMintedEvent = events[0] as! ExampleToken.TokensMinted + let tokensMintedEvent = events[1] as! ExampleToken.TokensMinted Test.assertEqual(250.0, tokensMintedEvent.amount) - typ = Type() + typ = Type() events = Test.eventsOfType(typ) - Test.assertEqual(1, events.length) - - let minterCreatedEvent = events[0] as! ExampleToken.MinterCreated - Test.assertEqual(250.0, minterCreatedEvent.allowedAmount) - - typ = Type() - events = Test.eventsOfType(typ) - Test.assertEqual(1, events.length) - let tokensDepositedEvent = events[0] as! ExampleToken.TokensDeposited + let tokensDepositedEvent = events[events.length - 1] as! FungibleToken.Deposited Test.assertEqual(250.0, tokensDepositedEvent.amount) Test.assertEqual(recipient.address, tokensDepositedEvent.to!) + Test.assertEqual("A.0000000000000007.ExampleToken.Vault", tokensDepositedEvent.type) + Test.assertEqual(250.0, tokensDepositedEvent.balanceAfter!) // Test that the totalSupply increased by the amount of minted tokens let scriptResult = executeScript( @@ -129,16 +109,18 @@ fun testTransferTokens() { ) Test.expect(txResult, Test.beSucceeded()) - var typ = Type() + var typ = Type() Test.assertEqual(2, Test.eventsOfType(typ).length) - typ = Type() + typ = Type() let events = Test.eventsOfType(typ) Test.assertEqual(1, events.length) - let tokensWithdrawnEvent = events[0] as! ExampleToken.TokensWithdrawn + let tokensWithdrawnEvent = events[0] as! FungibleToken.Withdrawn + Test.assertEqual("A.0000000000000007.ExampleToken.Vault", tokensWithdrawnEvent.type) Test.assertEqual(50.0, tokensWithdrawnEvent.amount) Test.assertEqual(recipient.address, tokensWithdrawnEvent.from!) + Test.assertEqual(200.0, tokensWithdrawnEvent.balanceAfter!) var scriptResult = executeScript( "../transactions/scripts/get_balance.cdc", @@ -177,39 +159,84 @@ fun testTransferTokenAmountGreaterThanBalance() { access(all) fun testBurnTokens() { - let txResult = executeTransaction( + var txResult = executeTransaction( "../transactions/burn_tokens.cdc", [50.0], admin ) Test.expect(txResult, Test.beSucceeded()) - var typ = Type() - var events = Test.eventsOfType(typ) + let type = Type() + let events = Test.eventsOfType(type) Test.assertEqual(1, events.length) - typ = Type() - events = Test.eventsOfType(typ) - Test.assertEqual(1, events.length) - - let tokensBurnedEvent = events[0] as! ExampleToken.TokensBurned + let tokensBurnedEvent = events[0] as! FungibleToken.Burned Test.assertEqual(50.0, tokensBurnedEvent.amount) + Test.assertEqual("A.0000000000000007.ExampleToken.Vault", tokensBurnedEvent.type) - let scriptResult = executeScript( + var scriptResult = executeScript( "../transactions/scripts/get_balance.cdc", [admin.address] ) Test.expect(scriptResult, Test.beSucceeded()) // The admin should now have the initial supply of 1000.0 tokens - let balance = scriptResult.returnValue! as! UFix64 + var balance = scriptResult.returnValue! as! UFix64 Test.assertEqual(1000.0, balance) + + txResult = executeTransaction( + "transactions/burn_array.cdc", + [10.0, 5], + admin + ) + Test.expect(txResult, Test.beSucceeded()) + + scriptResult = executeScript( + "../transactions/scripts/get_supply.cdc", + [] + ) + Test.expect(scriptResult, Test.beSucceeded()) + + var totalSupply = scriptResult.returnValue! as! UFix64 + Test.assertEqual(1150.0, totalSupply) + + txResult = executeTransaction( + "transactions/burn_dict.cdc", + [10.0, 5], + admin + ) + Test.expect(txResult, Test.beSucceeded()) + + scriptResult = executeScript( + "../transactions/scripts/get_supply.cdc", + [] + ) + Test.expect(scriptResult, Test.beSucceeded()) + + totalSupply = scriptResult.returnValue! as! UFix64 + Test.assertEqual(1100.0, totalSupply) + + txResult = executeTransaction( + "transactions/burn_optional.cdc", + [], + admin + ) + Test.expect(txResult, Test.beSucceeded()) + + scriptResult = executeScript( + "../transactions/scripts/get_supply.cdc", + [] + ) + Test.expect(scriptResult, Test.beSucceeded()) + + totalSupply = scriptResult.returnValue! as! UFix64 + Test.assertEqual(200.0, totalSupply) } access(all) fun testVaultTypes() { let scriptResult = executeScript( - "scripts/get_views.cdc", + "../transactions/metadata/scripts/get_views.cdc", [recipient.address] ) Test.expect(scriptResult, Test.beSucceeded()) diff --git a/tests/metadata_views_test.cdc b/tests/metadata_views_test.cdc new file mode 100644 index 00000000..b9da725d --- /dev/null +++ b/tests/metadata_views_test.cdc @@ -0,0 +1,70 @@ +import Test +import BlockchainHelpers +import "test_helpers.cdc" +import "ViewResolver" +import "FungibleTokenMetadataViews" +import "ExampleToken" +import "FungibleToken" + +access(all) let admin = Test.getAccount(0x0000000000000007) + +/* Test Setup */ + +access(all) fun setup() { + deploy("ViewResolver", "../contracts/utility/ViewResolver.cdc") + deploy("Burner", "../contracts/utility/Burner.cdc") + deploy("FungibleToken", "../contracts/FungibleToken.cdc") + deploy("NonFungibleToken", "../contracts/utility/NonFungibleToken.cdc") + deploy("MetadataViews", "../contracts/utility/MetadataViews.cdc") + deploy("FungibleTokenMetadataViews", "../contracts/FungibleTokenMetadataViews.cdc") + deploy("ExampleToken", "../contracts/ExampleToken.cdc") +} + +/* Test Cases */ + +access(all) fun testSetupAccountUsingFTView() { + let alice = Test.createAccount() + let bob = Test.createAccount() + + setupExampleToken(alice) + let aliceBalance = getExampleTokenBalance(alice) + txExecutor("metadata/setup_account_from_vault_reference.cdc", [bob], [alice.address, /public/exampleTokenVault], nil, nil) + let bobBalance = getExampleTokenBalance(bob) + + Test.assertEqual(0.0, aliceBalance) + Test.assertEqual(0.0, bobBalance) +} + +access(all) fun testSetupAccountUsingContractAddressAndName() { + let bob = Test.createAccount() + + txExecutor("metadata/setup_account_from_address.cdc", [bob], [admin.address, "ExampleToken"], nil, nil) + let bobBalance = getExampleTokenBalance(bob) + + Test.assertEqual(0.0, bobBalance) +} + +access(all) fun testRetrieveVaultDisplayInfo() { + let alice = Test.createAccount() + + setupExampleToken(alice) + let scriptResult = executeScript( + "scripts/example_token_vault_display_strict_equal.cdc", + [alice.address] + ) + Test.expect(scriptResult, Test.beSucceeded()) +} + + +/* Transaction Helpers */ + +access(all) fun setupExampleToken(_ acct: Test.TestAccount) { + txExecutor("setup_account.cdc", [acct], [], nil, nil) +} + +/* Script Helpers */ + +access(all) fun getExampleTokenBalance(_ acct: Test.TestAccount): UFix64 { + let balance: UFix64? = (scriptExecutor("get_balance.cdc", [acct.address])! as! UFix64) + return balance! +} \ No newline at end of file diff --git a/tests/private_receiver_forwarder_test.cdc b/tests/private_receiver_forwarder_test.cdc new file mode 100644 index 00000000..7da9f199 --- /dev/null +++ b/tests/private_receiver_forwarder_test.cdc @@ -0,0 +1,86 @@ +import Test +import BlockchainHelpers +import "test_helpers.cdc" +import "ExampleToken" + +/* Test Setup */ + +access(all) let admin = Test.getAccount(0x0000000000000007) +access(all) let senderStoragePath = /storage/Sender +access(all) let privateReceiverStoragePath = /storage/PrivateReceiver +access(all) let privateReceiverPublicPath = /public/PrivateReceiver + +access(all) fun setup() { + + // helper nft contract so we can actually talk to nfts with tests + deploy("ViewResolver", "../contracts/utility/ViewResolver.cdc") + deploy("Burner", "../contracts/utility/Burner.cdc") + deploy("FungibleToken", "../contracts/FungibleToken.cdc") + deploy("NonFungibleToken", "../contracts/utility/NonFungibleToken.cdc") + deploy("MetadataViews", "../contracts/utility/MetadataViews.cdc") + deploy("FungibleTokenMetadataViews", "../contracts/FungibleTokenMetadataViews.cdc") + deploy("ExampleToken", "../contracts/ExampleToken.cdc") + deployWithArgs( + "PrivateReceiverForwarder", + "../contracts/utility/PrivateReceiverForwarder.cdc", + args: [ + senderStoragePath, + privateReceiverStoragePath, + privateReceiverPublicPath + ] + ) +} + +/* Test Cases */ + +access(all) fun testSetupForwader() { + let alice = Test.createAccount() + let txResult = executeTransaction( + "../transactions/privateForwarder/setup_and_create_forwarder.cdc", + [], + alice + ) + Test.expect(txResult, Test.beSucceeded()) +} + +access(all) fun testTransferPrivateTokens() { + let senderBalanceBefore = getExampleTokenBalance(admin) + assert(senderBalanceBefore == 1000.0, message: "ExampleToken balance should be 1000.0") + + let recipient = Test.createAccount() + let recipientAmount = 300.0 + + let pair = {recipient.address: recipientAmount} + + txExecutor("../transactions/privateForwarder/setup_and_create_forwarder.cdc", [recipient], [], nil, nil) + + txExecutor("../transactions/privateForwarder/transfer_private_many_accounts.cdc", [admin], [pair], nil, nil) + + let recipientBalance = getExampleTokenBalance(recipient) + Test.assertEqual(recipientAmount, recipientBalance) + + let senderBalanceAfter = getExampleTokenBalance(admin) + Test.assertEqual(senderBalanceBefore - recipientAmount, senderBalanceAfter) +} + + +/* Transaction Helpers */ + +access(all) fun setupExampleToken(_ acct: Test.TestAccount) { + txExecutor("setup_account.cdc", [acct], [], nil, nil) +} + +access(all) fun mintExampleToken(_ acct: Test.TestAccount, recipient: Address, amount: UFix64) { + txExecutor("mint_tokens.cdc", [acct], [recipient, amount], nil, nil) +} + +access(all) fun setupTokenForwarder(_ acct: Test.TestAccount) { + txExecutor("../transactions/privateForwarder/setup_and_create_forwarder.cdc", [acct], [], nil, nil) +} + +/* Script Helpers */ + +access(all) fun getExampleTokenBalance(_ acct: Test.TestAccount): UFix64 { + let balance: UFix64? = (scriptExecutor("get_balance.cdc", [acct.address])! as! UFix64) + return balance! +} diff --git a/tests/scripts/example_token_vault_display_strict_equal.cdc b/tests/scripts/example_token_vault_display_strict_equal.cdc new file mode 100644 index 00000000..80fe2bfe --- /dev/null +++ b/tests/scripts/example_token_vault_display_strict_equal.cdc @@ -0,0 +1,46 @@ +import "FungibleTokenMetadataViews" +import "MetadataViews" +import "ViewResolver" +import "ExampleToken" + +/// Test helper script to validate ExampleToken serves FTDisplay as expected +/// +access(all) fun main(address: Address): Bool { + let account = getAccount(address) + + let expected = FungibleTokenMetadataViews.FTDisplay( + name: "Example Fungible Token", + symbol: "EFT", + description: "This fungible token is used as an example to help you develop your next FT #onFlow.", + externalURL: MetadataViews.ExternalURL("https://example-ft.onflow.org"), + logos: MetadataViews.Medias([ + MetadataViews.Media( + file: MetadataViews.HTTPFile( + url: "https://assets.website-files.com/5f6294c0c7a8cdd643b1c820/5f6294c0c7a8cda55cb1c936_Flow_Wordmark.svg" + ), + mediaType: "image/svg+xml" + )] + ), + socials: { + "twitter": MetadataViews.ExternalURL("https://twitter.com/flow_blockchain") + } + ) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow a reference to the vault resolver") + + let actual = FungibleTokenMetadataViews.getFTDisplay(vaultRef) + ?? panic("Token does not implement FTDisplay view") + + assert(actual.logos.items.length == expected.logos.items.length, message: "Medias length mismatch") + + let expectedLogoMedia = expected.logos.items[0] + let actualLogoMedia = actual.logos.items[0] + return expected.name == actual.name && expected.symbol == actual.symbol && + expected.description == actual.description && expected.externalURL.url == actual.externalURL.url && + expectedLogoMedia.file.uri() == actualLogoMedia.file.uri() && expectedLogoMedia.mediaType == actualLogoMedia.mediaType +} + diff --git a/tests/scripts/get_supported_vault_types.cdc b/tests/scripts/get_supported_vault_types.cdc deleted file mode 100644 index aaa67eab..00000000 --- a/tests/scripts/get_supported_vault_types.cdc +++ /dev/null @@ -1,16 +0,0 @@ -import "FungibleToken" - -/// This scripts returns the supported FungibleToken's type by the provided `target` address. -/// `target` address should hold the capability which conforms with FungibleToken.Receiver restricted type -/// while it doesn't matter whether capability refers to fungible token or a custom receiver like -/// `FungibleTokenSwitchboard` or `TokenReceiver`. However `targetPath` tells where the capability stores -pub fun main(target: Address, targetPath: PublicPath): {Type: Bool} { - - // Access the capability for the provided target address - let capabilityRef = getAccount(target) - .getCapability<&{FungibleToken.Receiver}>(targetPath) - .borrow() - ?? panic("Unable to borrow capability with restricted sub type {FungibleToken.Receiver} from path".concat(targetPath.toString())) - // Return the supported vault types. - return capabilityRef.getSupportedVaultTypes() -} \ No newline at end of file diff --git a/tests/scripts/get_token_metadata.cdc b/tests/scripts/get_token_metadata.cdc index dfd4ae57..0c034aef 100644 --- a/tests/scripts/get_token_metadata.cdc +++ b/tests/scripts/get_token_metadata.cdc @@ -4,13 +4,15 @@ import "ExampleToken" import "FungibleTokenMetadataViews" import "MetadataViews" +import "ViewResolver" -pub fun main(address: Address): Bool { +access(all) fun main(address: Address): Bool { let account = getAccount(address) - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get the vault data view for ExampleToken") + + let vaultRef = account.capabilities.borrow<&{ViewResolver.Resolver}>(vaultData.metadataPath) ?? panic("Could not borrow a reference to the vault resolver") let ftView = FungibleTokenMetadataViews.getFTView(viewResolver: vaultRef) diff --git a/tests/scripts/get_unsupported_view.cdc b/tests/scripts/get_unsupported_view.cdc index c1379b10..4073cfd3 100644 --- a/tests/scripts/get_unsupported_view.cdc +++ b/tests/scripts/get_unsupported_view.cdc @@ -4,11 +4,16 @@ import "ExampleToken" import "MetadataViews" +import "FungibleToken" +import "FungibleTokenMetadataViews" -pub fun main(address: Address, type: Type): AnyStruct? { +access(all) fun main(address: Address, type: Type): AnyStruct? { let account = getAccount(address) - let vaultRef = account.getCapability(ExampleToken.VaultPublicPath) - .borrow<&ExampleToken.Vault{MetadataViews.Resolver}>() + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get the vault data view for ExampleToken") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) ?? panic("Could not borrow Balance reference to the Vault") return vaultRef.resolveView(type) diff --git a/tests/scripts/get_vault_data.cdc b/tests/scripts/get_vault_data.cdc index 1c871293..7d2effe3 100644 --- a/tests/scripts/get_vault_data.cdc +++ b/tests/scripts/get_vault_data.cdc @@ -6,27 +6,17 @@ import "FungibleToken" import "FungibleTokenMetadataViews" import "MetadataViews" -pub fun main(address: Address): Bool { +access(all) fun main(address: Address): Bool { let account = getAccount(address) - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") - - let vaultData = FungibleTokenMetadataViews.getFTVaultData(vaultRef) - ?? panic("Token does not implement FTVaultData view") + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // FungibleTokenMetadataViews.FTVaultData cannot be returned as // a script result, because of the createEmptyVault() function. // So we perform the assertions here. - assert(ExampleToken.VaultStoragePath == vaultData.storagePath) - assert(ExampleToken.ReceiverPublicPath == vaultData.receiverPath) - assert(ExampleToken.VaultPublicPath == vaultData.metadataPath) - assert(/private/exampleTokenVault == vaultData.providerPath) - assert(Type<&ExampleToken.Vault{FungibleToken.Receiver}>() == vaultData.receiverLinkedType) - assert(Type<&ExampleToken.Vault{FungibleToken.Provider}>() == vaultData.providerLinkedType) - assert(Type<&ExampleToken.Vault{FungibleToken.Balance, MetadataViews.Resolver}>() == vaultData.metadataLinkedType) + assert(Type<&ExampleToken.Vault>() == vaultData.receiverLinkedType) + assert(Type<&ExampleToken.Vault>() == vaultData.metadataLinkedType) let vault <- vaultData.createEmptyVault() let vaultIsEmpty = vault.balance == 0.0 assert(vaultIsEmpty) diff --git a/tests/scripts/get_vault_display.cdc b/tests/scripts/get_vault_display.cdc index 0754672d..deb26092 100644 --- a/tests/scripts/get_vault_display.cdc +++ b/tests/scripts/get_vault_display.cdc @@ -4,14 +4,16 @@ import "ExampleToken" import "FungibleTokenMetadataViews" import "MetadataViews" +import "ViewResolver" -pub fun main(address: Address): FungibleTokenMetadataViews.FTDisplay { +access(all) fun main(address: Address): FungibleTokenMetadataViews.FTDisplay { let account = getAccount(address) - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow Balance reference to the Vault") let ftDisplay = FungibleTokenMetadataViews.getFTDisplay(vaultRef) ?? panic("Token does not implement FTDisplay view") diff --git a/tests/scripts/get_views.cdc b/tests/scripts/get_views.cdc deleted file mode 100644 index 5e643395..00000000 --- a/tests/scripts/get_views.cdc +++ /dev/null @@ -1,16 +0,0 @@ -// This script checks the supported views from ExampleToken -// are the expected ones. This is merely used in testing. - -import "MetadataViews" -import "ExampleToken" -import "FungibleTokenMetadataViews" - -pub fun main(address: Address): [Type] { - let account = getAccount(address) - - let vaultRef = account.getCapability(ExampleToken.VaultPublicPath) - .borrow<&ExampleToken.Vault{MetadataViews.Resolver}>() - ?? panic("Could not borrow Balance reference to the Vault") - - return vaultRef.getViews() -} diff --git a/tests/test_switchboard.cdc b/tests/switchboard_test.cdc similarity index 69% rename from tests/test_switchboard.cdc rename to tests/switchboard_test.cdc index 5f09cf71..d80b84b5 100644 --- a/tests/test_switchboard.cdc +++ b/tests/switchboard_test.cdc @@ -1,41 +1,25 @@ import Test import BlockchainHelpers +import "test_helpers.cdc" import "FungibleTokenMetadataViews" import "ExampleToken" import "FungibleTokenSwitchboard" +import "FungibleToken" access(all) let admin = Test.getAccount(0x0000000000000007) access(all) let recipient = Test.createAccount() access(all) fun setup() { - var err = Test.deployContract( - name: "FungibleTokenMetadataViews", - path: "../contracts/FungibleTokenMetadataViews.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) - - err = Test.deployContract( - name: "ExampleToken", - path: "../contracts/ExampleToken.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) - - err = Test.deployContract( - name: "FungibleTokenSwitchboard", - path: "../contracts/FungibleTokenSwitchboard.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) - - err = Test.deployContract( - name: "TokenForwarding", - path: "../contracts/utility/TokenForwarding.cdc", - arguments: [] - ) - Test.expect(err, Test.beNil()) + deploy("ViewResolver", "../contracts/utility/ViewResolver.cdc") + deploy("Burner", "../contracts/utility/Burner.cdc") + deploy("FungibleToken", "../contracts/FungibleToken.cdc") + deploy("NonFungibleToken", "../contracts/utility/NonFungibleToken.cdc") + deploy("MetadataViews", "../contracts/utility/MetadataViews.cdc") + deploy("FungibleTokenMetadataViews", "../contracts/FungibleTokenMetadataViews.cdc") + deploy("ExampleToken", "../contracts/ExampleToken.cdc") + deploy("FungibleTokenSwitchboard", "../contracts/FungibleTokenSwitchboard.cdc") + deploy("TokenForwarding", "../contracts/utility/TokenForwarding.cdc") } access(all) @@ -56,7 +40,7 @@ fun testSetupSwitchboard() { // Test that the newly-setup switchboard cannot accept any types var scriptResult = executeScript( - "scripts/get_supported_vault_types.cdc", + "../transactions/scripts/get_supported_vault_types.cdc", [recipient.address, /public/GenericFTReceiver] ) Test.expect(scriptResult, Test.beSucceeded()) @@ -73,7 +57,7 @@ fun testSetupSwitchboard() { // Test that the switchboard can now accept one vault type scriptResult = executeScript( - "scripts/get_supported_vault_types.cdc", + "../transactions/scripts/get_supported_vault_types.cdc", [recipient.address, /public/GenericFTReceiver] ) Test.expect(scriptResult, Test.beSucceeded()) @@ -81,12 +65,23 @@ fun testSetupSwitchboard() { supportedTypes = scriptResult.returnValue! as! {Type: Bool} let expectedTypes = {Type<@ExampleToken.Vault>(): true} Test.assertEqual(expectedTypes, supportedTypes) + + // Test that the switchboard capability is correct + scriptResult = executeScript( + "../transactions/switchboard/scripts/get_vault_types_and_address.cdc", + [recipient.address] + ) + Test.expect(scriptResult, Test.beSucceeded()) + + var typeAddresses = scriptResult.returnValue! as! {Type: Address} + let expectedAddresses = {Type<@ExampleToken.Vault>(): recipient.address} + Test.assertEqual(expectedAddresses, typeAddresses) } access(all) fun testUseSwitchboard() { var txResult = executeTransaction( - "../transactions/switchboard/safe_transfer_tokens_v2.cdc", + "../transactions/switchboard/safe_transfer_tokens.cdc", [recipient.address, 10.0], admin ) @@ -128,7 +123,7 @@ fun testRemoveVaultTypeFromSwitchboard() { // Test that the switchboard can now accept zero vault types let scriptResult = executeScript( - "scripts/get_supported_vault_types.cdc", + "../transactions/scripts/get_supported_vault_types.cdc", [recipient.address, /public/GenericFTReceiver] ) Test.expect(scriptResult, Test.beSucceeded()) @@ -140,12 +135,20 @@ fun testRemoveVaultTypeFromSwitchboard() { access(all) fun testUseSwitchboardWithForwarder() { var txResult = executeTransaction( - "../transactions/create_forwarder.cdc", + "../transactions/tokenForwarder/create_forwarder.cdc", [admin.address], recipient ) Test.expect(txResult, Test.beSucceeded()) + // Fail with invalid capability + txResult = executeTransaction( + "../transactions/switchboard/add_vault_wrapper_capability.cdc", + [], + recipient + ) + Test.expect(txResult, Test.beSucceeded()) + txResult = executeTransaction( "../transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc", [recipient.address], @@ -153,9 +156,16 @@ fun testUseSwitchboardWithForwarder() { ) Test.expect(txResult, Test.beSucceeded()) + txResult = executeTransaction( + "../transactions/switchboard/batch_add_vault_capabilities.cdc", + [recipient.address], + recipient + ) + Test.expect(txResult, Test.beSucceeded()) + // Test that the switchboard can now accept one vault types var scriptResult = executeScript( - "scripts/get_supported_vault_types.cdc", + "../transactions/scripts/get_supported_vault_types.cdc", [recipient.address, /public/GenericFTReceiver] ) Test.expect(scriptResult, Test.beSucceeded()) diff --git a/tests/test_helpers.cdc b/tests/test_helpers.cdc new file mode 100644 index 00000000..e0405a93 --- /dev/null +++ b/tests/test_helpers.cdc @@ -0,0 +1,147 @@ +// Helper functions. All of the following were taken from +// - deploy +// - scriptExecutor +// - txExecutor +// - getErrorMessagePointer + +import Test + +access(all) fun deploy(_ contractName: String, _ path: String) { + let err = Test.deployContract( + name: contractName, + path: path, + arguments: [], + ) + + Test.expect(err, Test.beNil()) +} + +access(all) fun deployWithArgs(_ contractName: String, _ path: String, args: [AnyStruct]) { + let err = Test.deployContract( + name: contractName, + path: path, + arguments: args, + ) + + Test.expect(err, Test.beNil()) +} + +access(all) fun scriptExecutor(_ scriptName: String, _ arguments: [AnyStruct]): AnyStruct? { + let scriptCode = loadCode(scriptName, "transactions/scripts") + let scriptResult = Test.executeScript(scriptCode, arguments) + + if let failureError = scriptResult.error { + panic( + "Failed to execute the script because -: ".concat(failureError.message) + ) + } + + return scriptResult.returnValue +} + +access(all) fun expectScriptFailure(_ scriptName: String, _ arguments: [AnyStruct]): String { + let scriptCode = loadCode(scriptName, "transactions/scripts") + let scriptResult = Test.executeScript(scriptCode, arguments) + + assert(scriptResult.error != nil, message: "script error was expected but there is no error message") + return scriptResult.error!.message +} + +access(all) fun txExecutor(_ txName: String, _ signers: [Test.TestAccount], _ arguments: [AnyStruct], _ expectedError: String?, _ expectedErrorType: ErrorType?): Bool { + let txCode = loadCode(txName, "transactions") + + let authorizers: [Address] = [] + for signer in signers { + authorizers.append(signer.address) + } + + let tx = Test.Transaction( + code: txCode, + authorizers: authorizers, + signers: signers, + arguments: arguments, + ) + + let txResult = Test.executeTransaction(tx) + if let err = txResult.error { + if let expectedErrorMessage = expectedError { + let ptr = getErrorMessagePointer(errorType: expectedErrorType!) + let errMessage = err.message + let hasEmittedCorrectMessage = contains(errMessage, expectedErrorMessage) + let failureMessage = "Expecting - " + .concat(expectedErrorMessage) + .concat("\n") + .concat("But received - ") + .concat(err.message) + assert(hasEmittedCorrectMessage, message: failureMessage) + return true + } + panic(err.message) + } else { + if let expectedErrorMessage = expectedError { + panic("Expecting error - ".concat(expectedErrorMessage).concat(". While no error triggered")) + } + } + + return txResult.status == Test.ResultStatus.succeeded +} + +access(all) fun loadCode(_ fileName: String, _ baseDirectory: String): String { + return Test.readFile("../".concat(baseDirectory).concat("/").concat(fileName)) +} + +access(all) enum ErrorType: UInt8 { + access(all) case TX_PANIC + access(all) case TX_ASSERT + access(all) case TX_PRE +} + +access(all) fun getErrorMessagePointer(errorType: ErrorType): Int { + switch errorType { + case ErrorType.TX_PANIC: return 159 + case ErrorType.TX_ASSERT: return 170 + case ErrorType.TX_PRE: return 174 + default: panic("Invalid error type") + } +} + +access(all) fun buildTypeIdentifier(_ acct: Test.TestAccount, _ contractName: String, _ suffix: String): String { + let addrString = acct.address.toString() + return "A.".concat(addrString.slice(from: 2, upTo: addrString.length)).concat(".").concat(contractName).concat(".").concat(suffix) +} + +// Copied functions from flow-utils so we can assert on error conditions +// https://github.com/green-goo-dao/flow-utils/blob/main/cadence/contracts/StringUtils.cdc +access(all) fun contains(_ s: String, _ substr: String): Bool { + if let index = index(s, substr, 0) { + return true + } + return false +} + +// https://github.com/green-goo-dao/flow-utils/blob/main/cadence/contracts/StringUtils.cdc +access(all) fun index(_ s: String, _ substr: String, _ startIndex: Int): Int? { + for i in range(startIndex, s.length - substr.length + 1) { + if s[i] == substr[0] && s.slice(from: i, upTo: i + substr.length) == substr { + return i + } + } + return nil +} + +// https://github.com/green-goo-dao/flow-utils/blob/main/cadence/contracts/ArrayUtils.cdc +access(all) fun rangeFunc(_ start: Int, _ end: Int, _ f: (fun (Int): Void)) { + var current = start + while current < end { + f(current) + current = current + 1 + } +} + +access(all) fun range(_ start: Int, _ end: Int): [Int] { + let res: [Int] = [] + rangeFunc(start, end, fun (i: Int) { + res.append(i) + }) + return res +} diff --git a/tests/transactions/burn_array.cdc b/tests/transactions/burn_array.cdc new file mode 100644 index 00000000..115ec4bf --- /dev/null +++ b/tests/transactions/burn_array.cdc @@ -0,0 +1,37 @@ +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "Burner" + +/// This transaction is for testing burning an array of Vaults +/// +transaction(amountPerIndex: UFix64, numIndicies: Int) { + + /// Vault resource that holds the tokens that are being burned + let burnVaults: @[ExampleToken.Vault] + + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + // Withdraw tokens from the signer's vault in storage + let sourceVault = signer.storage.borrow( + from: vaultData.storagePath + ) ?? panic("Could not borrow a reference to the signer's ExampleToken vault") + + self.burnVaults <- [] + var i = 0 + while i < numIndicies { + let vault <- sourceVault.withdraw(amount: amountPerIndex) as! @ExampleToken.Vault + self.burnVaults.append(<-vault) + i = i + 1 + } + } + + execute { + + Burner.burn(<-self.burnVaults) + + } +} diff --git a/tests/transactions/burn_dict.cdc b/tests/transactions/burn_dict.cdc new file mode 100644 index 00000000..186afab6 --- /dev/null +++ b/tests/transactions/burn_dict.cdc @@ -0,0 +1,37 @@ +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "Burner" + +/// This transaction is for testing burning a dictionary of Vaults +/// +transaction(amountPerIndex: UFix64, numIndicies: Int) { + + /// Vault resource that holds the tokens that are being burned + let burnVaults: @{Int: ExampleToken.Vault} + + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + // Withdraw tokens from the signer's vault in storage + let sourceVault = signer.storage.borrow( + from: vaultData.storagePath + ) ?? panic("Could not borrow a reference to the signer's ExampleToken vault") + + self.burnVaults <- {} + var i = 0 + while i < numIndicies { + let vault <- sourceVault.withdraw(amount: amountPerIndex) as! @ExampleToken.Vault + self.burnVaults[i] <-! vault + i = i + 1 + } + } + + execute { + + Burner.burn(<-self.burnVaults) + + } +} diff --git a/tests/transactions/burn_optional.cdc b/tests/transactions/burn_optional.cdc new file mode 100644 index 00000000..08507f76 --- /dev/null +++ b/tests/transactions/burn_optional.cdc @@ -0,0 +1,37 @@ +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "Burner" + +/// This transaction is a template for a transaction that could be used by an account +/// to load a vault from storage and burn the whole vault +/// +/// It is meant for testing purposes to burn an optional vault with the burner contract +/// +transaction { + + /// The total supply of tokens before the burn + let supplyBefore: UFix64 + + /// Vault resource that holds the tokens that are being burned + let burnVault: @AnyResource + + prepare(signer: auth(Storage) &Account) { + + self.supplyBefore = ExampleToken.totalSupply + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + // Withdraw tokens from the signer's vault in storage + self.burnVault <- signer.storage.load<@AnyResource>( + from: vaultData.storagePath + ) + } + + execute { + + Burner.burn(<-self.burnVault) + + } +} diff --git a/transactions/burn_tokens.cdc b/transactions/burn_tokens.cdc index aadaff50..ef7aadc5 100644 --- a/transactions/burn_tokens.cdc +++ b/transactions/burn_tokens.cdc @@ -1,45 +1,45 @@ -// This transaction is a template for a transaction that -// could be used by the admin account to burn tokens -// from their stored Vault -// -// The burning amount would be a parameter to the transaction - -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" - +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "Burner" + +/// This transaction is a template for a transaction that could be used by the admin account to burn tokens from their +/// stored Vault +/// +/// The burning amount would be a parameter to the transaction +/// transaction(amount: UFix64) { - /// Vault resource that holds the tokens that are being burned - let vault: @FungibleToken.Vault - - /// Reference to the ExampleToken Admin object - let admin: &ExampleToken.Administrator - /// The total supply of tokens before the burn let supplyBefore: UFix64 - prepare(signer: AuthAccount) { + /// Vault resource that holds the tokens that are being burned + let burnVault: @ExampleToken.Vault + + prepare(signer: auth(BorrowValue) &Account) { self.supplyBefore = ExampleToken.totalSupply - // Withdraw 10 tokens from the admin vault in storage - self.vault <- signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath)! - .withdraw(amount: amount) + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") - // Create a reference to the admin admin resource in storage - self.admin = signer.borrow<&ExampleToken.Administrator>(from: ExampleToken.AdminStoragePath) - ?? panic("Could not borrow a reference to the admin resource") + // Withdraw tokens from the signer's vault in storage + let sourceVault = signer.storage.borrow( + from: vaultData.storagePath + ) ?? panic("Could not borrow a reference to the signer's ExampleToken vault") + self.burnVault <- sourceVault.withdraw(amount: amount) as! @ExampleToken.Vault } execute { - let burner <- self.admin.createNewBurner() - burner.burnTokens(from: <-self.vault) + Burner.burn(<-self.burnVault) - destroy burner } post { - ExampleToken.totalSupply == self.supplyBefore - amount: "The total supply must be decreased by the amount" + ExampleToken.totalSupply == (self.supplyBefore - amount): + "Before: ".concat(self.supplyBefore.toString()) + .concat(" | After: ".concat(ExampleToken.totalSupply.toString())) + .concat(" | Expected: ".concat((self.supplyBefore - amount).toString())) } } diff --git a/transactions/generic_transfer.cdc b/transactions/generic_transfer.cdc deleted file mode 100644 index 0ff46941..00000000 --- a/transactions/generic_transfer.cdc +++ /dev/null @@ -1,33 +0,0 @@ -import FungibleToken from "FungibleToken" - -/// Can pass in any storage path and receiver path instead of just the default. -/// This lets you choose the token you want to send as well the capability you want to send it to. -/// -/// Any token path can be passed as an argument here, so wallets should -/// should check argument values to make sure the intended token path is passed in -/// -transaction(amount: UFix64, to: Address, senderPath: StoragePath, receiverPath: PublicPath) { - - // The Vault resource that holds the tokens that are being transferred - let tempVault: @FungibleToken.Vault - - prepare(signer: AuthAccount) { - - // Get a reference to the signer's stored vault - let vaultRef = signer.borrow<&{FungibleToken.Provider}>(from: senderPath) - ?? panic("Could not borrow reference to the owner's Vault!") - - self.tempVault <- vaultRef.withdraw(amount: amount) - - } - - execute { - - let recipient = getAccount(to) - let receiverRef = recipient.getCapability<&{FungibleToken.Receiver}>(receiverPath) - .borrow()! - - // Transfer tokens from the signer's stored vault to the receiver capability - receiverRef.deposit(from: <-self.tempVault) - } -} \ No newline at end of file diff --git a/transactions/generic_transfer_with_address.cdc b/transactions/generic_transfer_with_address.cdc new file mode 100644 index 00000000..486036e1 --- /dev/null +++ b/transactions/generic_transfer_with_address.cdc @@ -0,0 +1,44 @@ +import "FungibleToken" +import "FungibleTokenMetadataViews" + +/// Can pass in any contract address and name to transfer a token from that contract +/// This lets you choose the token you want to send +/// +/// Any contract can be chosen here, so wallets should check argument values +/// to make sure the intended token contract name and address is passed in +/// +transaction(amount: UFix64, to: Address, contractAddress: Address, contractName: String) { + + // The Vault resource that holds the tokens that are being transferred + let tempVault: @{FungibleToken.Vault} + + // FTVaultData struct to get paths from + let vaultData: FungibleTokenMetadataViews.FTVaultData + + prepare(signer: auth(BorrowValue) &Account) { + + // Borrow a reference to the vault stored on the passed account at the passed publicPath + let resolverRef = getAccount(contractAddress) + .contracts.borrow<&{FungibleToken}>(name: contractName) + ?? panic("Could not borrow a reference to the fungible token contract") + + // Use that reference to retrieve the FTView + self.vaultData = resolverRef.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not resolve the FTVaultData view for the given Fungible token contract") + + // Get a reference to the signer's stored vault + let vaultRef = signer.storage.borrow(from: self.vaultData.storagePath) + ?? panic("Could not borrow reference to the owner's Vault!") + + self.tempVault <- vaultRef.withdraw(amount: amount) + } + + execute { + let recipient = getAccount(to) + let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(self.vaultData.receiverPath) + ?? panic("Could not borrow reference to the recipient's Receiver!") + + // Transfer tokens from the signer's stored vault to the receiver capability + receiverRef.deposit(from: <-self.tempVault) + } +} \ No newline at end of file diff --git a/transactions/generic_transfer_with_paths.cdc b/transactions/generic_transfer_with_paths.cdc new file mode 100644 index 00000000..cbb99b58 --- /dev/null +++ b/transactions/generic_transfer_with_paths.cdc @@ -0,0 +1,37 @@ +import "FungibleToken" + +/// Can pass in any storage path and receiver path identifier instead of just the default. +/// This lets you choose the token you want to send as well the capability you want to send it to. +/// +/// Any token path can be passed as an argument here, so wallets should +/// should check argument values to make sure the intended token path is passed in +/// +transaction(amount: UFix64, to: Address, senderPathIdentifier: String, receiverPathIdentifier: String) { + + // The Vault resource that holds the tokens that are being transferred + let tempVault: @{FungibleToken.Vault} + + prepare(signer: auth(BorrowValue) &Account) { + + let storagePath = StoragePath(identifier: senderPathIdentifier) + ?? panic("Could not construct a storage path from the provided path identifier string") + + // Get a reference to the signer's stored vault + let vaultRef = signer.storage.borrow(from: storagePath) + ?? panic("Could not borrow reference to the owner's Vault!") + + self.tempVault <- vaultRef.withdraw(amount: amount) + } + + execute { + let publicPath = PublicPath(identifier: receiverPathIdentifier) + ?? panic("Could not construct a public path from the provided path identifier string") + + let recipient = getAccount(to) + let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(publicPath) + ?? panic("Could not borrow reference to the recipient's Receiver!") + + // Transfer tokens from the signer's stored vault to the receiver capability + receiverRef.deposit(from: <-self.tempVault) + } +} \ No newline at end of file diff --git a/transactions/metadata/scripts/get_token_metadata.cdc b/transactions/metadata/scripts/get_token_metadata.cdc new file mode 100644 index 00000000..59fc650f --- /dev/null +++ b/transactions/metadata/scripts/get_token_metadata.cdc @@ -0,0 +1,18 @@ +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "FungibleToken" +import "ViewResolver" + +access(all) fun main(address: Address): FungibleTokenMetadataViews.FTView { + let account = getAccount(address) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow a reference to the vault resolver") + + let ftView = FungibleTokenMetadataViews.getFTView(viewResolver: vaultRef) + + return ftView +} diff --git a/transactions/metadata/scripts/get_vault_data.cdc b/transactions/metadata/scripts/get_vault_data.cdc new file mode 100644 index 00000000..692d016c --- /dev/null +++ b/transactions/metadata/scripts/get_vault_data.cdc @@ -0,0 +1,19 @@ +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "FungibleToken" +import "ViewResolver" + +access(all) fun main(address: Address): FungibleTokenMetadataViews.FTVaultData { + let account = getAccount(address) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow a reference to the vault resolver") + + let vaultData = FungibleTokenMetadataViews.getFTVaultData(vaultRef) + ?? panic("Token does not implement FTVaultData view") + + return vaultData +} diff --git a/transactions/metadata/scripts/get_vault_display.cdc b/transactions/metadata/scripts/get_vault_display.cdc new file mode 100644 index 00000000..3b8b85f0 --- /dev/null +++ b/transactions/metadata/scripts/get_vault_display.cdc @@ -0,0 +1,19 @@ +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "FungibleToken" +import "ViewResolver" + +access(all) fun main(address: Address): FungibleTokenMetadataViews.FTDisplay { + let account = getAccount(address) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow a reference to the vault resolver") + + let ftDisplay = FungibleTokenMetadataViews.getFTDisplay(vaultRef) + ?? panic("Token does not implement FTDisplay view") + + return ftDisplay +} diff --git a/transactions/metadata/scripts/get_vault_supply_view.cdc b/transactions/metadata/scripts/get_vault_supply_view.cdc new file mode 100644 index 00000000..bd11142f --- /dev/null +++ b/transactions/metadata/scripts/get_vault_supply_view.cdc @@ -0,0 +1,22 @@ +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "FungibleToken" +import "ViewResolver" + +/// Gets the total supply of the vault's token directly from the vault + +access(all) fun main(address: Address): UFix64 { + let account = getAccount(address) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow a reference to the vault resolver") + + let ftSupply = vaultRef.resolveView(Type())! + + let supplyView = ftSupply as! FungibleTokenMetadataViews.TotalSupply + + return supplyView.supply +} diff --git a/transactions/metadata/scripts/get_views.cdc b/transactions/metadata/scripts/get_views.cdc new file mode 100644 index 00000000..1dd26731 --- /dev/null +++ b/transactions/metadata/scripts/get_views.cdc @@ -0,0 +1,19 @@ +// This script checks the supported views from ExampleToken +// are the expected ones. This is merely used in testing. + +import "MetadataViews" +import "ExampleToken" +import "FungibleTokenMetadataViews" +import "FungibleToken" + +access(all) fun main(address: Address): [Type] { + let account = getAccount(address) + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + let vaultRef = account.capabilities.borrow<&ExampleToken.Vault>(vaultData.metadataPath) + ?? panic("Could not borrow Balance reference to the Vault") + + return vaultRef.getViews() +} diff --git a/transactions/metadata/setup_account_from_address.cdc b/transactions/metadata/setup_account_from_address.cdc new file mode 100644 index 00000000..f6bfe622 --- /dev/null +++ b/transactions/metadata/setup_account_from_address.cdc @@ -0,0 +1,37 @@ +import "FungibleToken" +import "FungibleTokenMetadataViews" + +/// This transaction is what an account would run +/// to set itself up to manage fungible tokens. This function +/// uses views to know where to set up the vault +/// in storage and to create the empty vault. + +transaction(contractAddress: Address, contractName: String) { + + prepare(signer: auth(SaveValue, Capabilities) &Account) { + // Borrow a reference to the vault stored on the passed account at the passed publicPath + let resolverRef = getAccount(contractAddress) + .contracts.borrow<&{FungibleToken}>(name: contractName) + ?? panic("Could not borrow a reference to the fungible token contract") + + // Use that reference to retrieve the FTView + let ftVaultData = resolverRef.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not resolve the FTVaultData view for the given Fungible token contract") + + // Create a new empty vault using the createEmptyVault function inside the FTVaultData + let emptyVault <-ftVaultData.createEmptyVault() + + // Save it to the account + signer.storage.save(<-emptyVault, to: ftVaultData.storagePath) + + // Create a public capability for the vault which includes the .Resolver interface + let vaultCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(ftVaultData.storagePath) + signer.capabilities.publish(vaultCap, at: ftVaultData.metadataPath) + + // Create a public capability for the vault exposing the receiver interface + let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>(ftVaultData.storagePath) + signer.capabilities.publish(receiverCap, at: ftVaultData.receiverPath) + + } +} + \ No newline at end of file diff --git a/transactions/metadata/setup_account_from_vault_reference.cdc b/transactions/metadata/setup_account_from_vault_reference.cdc index 63fa3f41..8e0d514e 100644 --- a/transactions/metadata/setup_account_from_vault_reference.cdc +++ b/transactions/metadata/setup_account_from_vault_reference.cdc @@ -1,6 +1,6 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenMetadataViews from "FungibleTokenMetadataViews" -import MetadataViews from "contracts/utility/MetadataViews" +import "FungibleToken" +import "FungibleTokenMetadataViews" +import "ViewResolver" /// This transaction is what an account would run /// to set itself up to manage fungible tokens. This function @@ -9,11 +9,10 @@ import MetadataViews from "contracts/utility/MetadataViews" transaction(address: Address, publicPath: PublicPath) { - prepare(signer: AuthAccount) { + prepare(signer: auth(SaveValue, Capabilities) &Account) { // Borrow a reference to the vault stored on the passed account at the passed publicPath let resolverRef = getAccount(address) - .getCapability(publicPath) - .borrow<&{MetadataViews.Resolver}>() + .capabilities.borrow<&{ViewResolver.Resolver}>(publicPath) ?? panic("Could not borrow a reference to the vault view resolver ") // Use that reference to retrieve the FTView @@ -26,19 +25,15 @@ transaction(address: Address, publicPath: PublicPath) { let emptyVault <-ftVaultData.createEmptyVault() // Save it to the account - signer.save(<-emptyVault, to: ftVaultData.storagePath) + signer.storage.save(<-emptyVault, to: ftVaultData.storagePath) + + // Create a public capability for the vault which includes the .Resolver interface + let vaultCap = signer.capabilities.storage.issue<&{FungibleToken.Vault}>(ftVaultData.storagePath) + signer.capabilities.publish(vaultCap, at: ftVaultData.metadataPath) // Create a public capability for the vault exposing the receiver interface - signer.link<&{FungibleToken.Receiver}>( - ftVaultData.receiverPath, - target: ftVaultData.storagePath - ) - - // Create a public capability for the vault exposing the balance and resolver interfaces - signer.link<&{FungibleToken.Balance, MetadataViews.Resolver}>( - ftVaultData.metadataPath, - target: ftVaultData.storagePath - ) + let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>(ftVaultData.storagePath) + signer.capabilities.publish(receiverCap, at: ftVaultData.receiverPath) } } diff --git a/transactions/mint_tokens.cdc b/transactions/mint_tokens.cdc index b0357fab..0ac0e940 100644 --- a/transactions/mint_tokens.cdc +++ b/transactions/mint_tokens.cdc @@ -1,5 +1,6 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" /// This transaction is what the minter Account uses to mint new tokens /// They provide the recipient address and amount to mint, and the tokens @@ -7,8 +8,8 @@ import ExampleToken from "ExampleToken" transaction(recipient: Address, amount: UFix64) { - /// Reference to the Example Token Admin Resource object - let tokenAdmin: &ExampleToken.Administrator + /// Reference to the Example Token Minter Resource object + let tokenMinter: &ExampleToken.Minter /// Reference to the Fungible Token Receiver of the recipient let tokenReceiver: &{FungibleToken.Receiver} @@ -16,30 +17,27 @@ transaction(recipient: Address, amount: UFix64) { /// The total supply of tokens before the burn let supplyBefore: UFix64 - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { self.supplyBefore = ExampleToken.totalSupply // Borrow a reference to the admin object - self.tokenAdmin = signer.borrow<&ExampleToken.Administrator>(from: ExampleToken.AdminStoragePath) + self.tokenMinter = signer.storage.borrow<&ExampleToken.Minter>(from: ExampleToken.AdminStoragePath) ?? panic("Signer is not the token admin") - // Get the account of the recipient and borrow a reference to their receiver - self.tokenReceiver = getAccount(recipient) - .getCapability(ExampleToken.ReceiverPublicPath) - .borrow<&{FungibleToken.Receiver}>() - ?? panic("Unable to borrow receiver reference") + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + self.tokenReceiver = getAccount(recipient).capabilities.borrow<&{FungibleToken.Receiver}>(vaultData.receiverPath) + ?? panic("Could not borrow receiver reference to the Vault") } execute { - // Create a minter and mint tokens - let minter <- self.tokenAdmin.createNewMinter(allowedAmount: amount) - let mintedVault <- minter.mintTokens(amount: amount) + // Create mint tokens + let mintedVault <- self.tokenMinter.mintTokens(amount: amount) // Deposit them to the receiever self.tokenReceiver.deposit(from: <-mintedVault) - - destroy minter } post { diff --git a/transactions/privateForwarder/create_account_private_forwarder.cdc b/transactions/privateForwarder/create_account_private_forwarder.cdc index af3cee6a..292070e1 100644 --- a/transactions/privateForwarder/create_account_private_forwarder.cdc +++ b/transactions/privateForwarder/create_account_private_forwarder.cdc @@ -1,41 +1,46 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import PrivateReceiverForwarder from "PrivateReceiverForwarder" +import "FungibleToken" +import "ExampleToken" +import "PrivateReceiverForwarder" +import "FungibleTokenMetadataViews" /// This transaction is used to create a user's Flow account with a private forwarder transaction { /// New Account that will hold the forwarder - let newAccount: AuthAccount + let newAccount: auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account - prepare(payer: AuthAccount) { - self.newAccount = AuthAccount(payer: payer) + prepare(signer: auth(BorrowValue) &Account) { + self.newAccount = Account(payer: signer) } execute { + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + // Save a regular vault to the new account - self.newAccount.save(<-ExampleToken.createEmptyVault(), - to: ExampleToken.VaultStoragePath - ) + self.newAccount.storage.save(<-ExampleToken.createEmptyVault(vaultType: Type<@ExampleToken.Vault>()), to: vaultData.storagePath) - // Create a private receiver - let receiverCapability = self.newAccount.link<&{FungibleToken.Receiver}>( - /private/exampleTokenReceiver, - target: ExampleToken.VaultStoragePath - )! + // Issue a Receiver Capability targetting the ExampleToken Vault + let receiverCapability = self.newAccount.capabilities.storage.issue<&{FungibleToken.Receiver}>( + vaultData.storagePath + ) // Use the private receiver to create a private forwarder let forwarder <- PrivateReceiverForwarder.createNewForwarder(recipient: receiverCapability) // Save the private forwarder to account storage - self.newAccount.save(<-forwarder, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) - - // Link the forwarder to a private path - self.newAccount.link<&PrivateReceiverForwarder.Forwarder>( - PrivateReceiverForwarder.PrivateReceiverPublicPath, - target: PrivateReceiverForwarder.PrivateReceiverStoragePath + self.newAccount.storage.save(<-forwarder, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) + + // Issue a Capability to the Forwarder resource + let forwarderCap = self.newAccount.capabilities.storage.issue<&PrivateReceiverForwarder.Forwarder>( + PrivateReceiverForwarder.PrivateReceiverStoragePath + ) + // Publish the Capability to the Forwarder resource + self.newAccount.capabilities.publish( + forwarderCap, + at: PrivateReceiverForwarder.PrivateReceiverPublicPath ) } diff --git a/transactions/privateForwarder/create_private_forwarder.cdc b/transactions/privateForwarder/create_private_forwarder.cdc index 6dc90aa1..6e365eda 100644 --- a/transactions/privateForwarder/create_private_forwarder.cdc +++ b/transactions/privateForwarder/create_private_forwarder.cdc @@ -1,6 +1,7 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import PrivateReceiverForwarder from "PrivateReceiverForwarder" +import "FungibleToken" +import "ExampleToken" +import "PrivateReceiverForwarder" +import "FungibleTokenMetadataViews" // This transaction creates a new private receiver in an account that // doesn't already have a private receiver or a public token receiver @@ -8,19 +9,27 @@ import PrivateReceiverForwarder from "PrivateReceiverForwarder" transaction { - prepare(signer: AuthAccount) { - receiverCapability = signer.link<&ExampleToken.Vault{FungibleToken.Receiver}>( - /private/exampleTokenReceiver, - target: ExampleToken.VaultStoragePath - ) - - let vault <- PrivateReceiverForwarder.createNewForwarder(recipient: receiverCapability) + prepare(signer: auth(IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) { - signer.save(<-vault, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") - signer.link<&{PrivateReceiverForwarder.Forwarder}>( - PrivateReceiverForwarder.PrivateReceiverPublicPath, - target: PrivateReceiverForwarder.PrivateReceiverStoragePath + // Issue a Receiver Capability targetting the ExampleToken Vault + let receiverCapability = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>( + vaultData.storagePath + ) + // Create the Forwarder resource + let forwarder <- PrivateReceiverForwarder.createNewForwarder(recipient: receiverCapability) + // Save the Forwarder resource to storage + signer.storage.save(<-forwarder, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) + // Issue a Capability to the Forwarder resource + let forwarderCap = signer.capabilities.storage.issue<&PrivateReceiverForwarder.Forwarder>( + PrivateReceiverForwarder.PrivateReceiverStoragePath + ) + // Publish the Capability to the Forwarder resource + signer.capabilities.publish( + forwarderCap, + at: PrivateReceiverForwarder.PrivateReceiverPublicPath ) } } diff --git a/transactions/privateForwarder/deploy_forwarder_contract.cdc b/transactions/privateForwarder/deploy_forwarder_contract.cdc index 499a3019..f114a5bd 100644 --- a/transactions/privateForwarder/deploy_forwarder_contract.cdc +++ b/transactions/privateForwarder/deploy_forwarder_contract.cdc @@ -6,7 +6,7 @@ transaction(contractName: String, storagePath: StoragePath, publicPath: PublicPath) { - prepare(signer: AuthAccount) { + prepare(signer: auth(AddContract) &Account) { signer.contracts.add(name: contractName, code: code, senderStoragePath, storagePath, publicPath) diff --git a/transactions/privateForwarder/setup_and_create_forwarder.cdc b/transactions/privateForwarder/setup_and_create_forwarder.cdc index c957ef18..c3591750 100644 --- a/transactions/privateForwarder/setup_and_create_forwarder.cdc +++ b/transactions/privateForwarder/setup_and_create_forwarder.cdc @@ -1,48 +1,56 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import PrivateReceiverForwarder from "PrivateReceiverForwarder" +import "FungibleToken" +import "ExampleToken" +import "PrivateReceiverForwarder" +import "FungibleTokenMetadataViews" /// This transaction adds a Vault, a private receiver forwarder /// a balance capability, and a public capability for the receiver transaction { - prepare(signer: AuthAccount) { - if signer.getCapability<&PrivateReceiverForwarder.Forwarder>(PrivateReceiverForwarder.PrivateReceiverPublicPath).check() { + prepare(signer: auth(IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) { + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + if signer.capabilities.get<&PrivateReceiverForwarder.Forwarder>(PrivateReceiverForwarder.PrivateReceiverPublicPath).check() { // private forwarder was already set up return } - if signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) == nil { + if signer.storage.check<&ExampleToken.Vault>(from: vaultData.storagePath) == false { // Create a new ExampleToken Vault and put it in storage - signer.save( - <-ExampleToken.createEmptyVault(), - to: ExampleToken.VaultStoragePath + signer.storage.save( + <-ExampleToken.createEmptyVault(vaultType: Type<@ExampleToken.Vault>()), + to: vaultData.storagePath ) } - signer.link<&{FungibleToken.Receiver}>( - /private/exampleTokenReceiver, - target: ExampleToken.VaultStoragePath - ) - - let receiverCapability = signer.getCapability<&{FungibleToken.Receiver}>(/private/exampleTokenReceiver) + // Create a public Vault Capability if needed + if signer.capabilities.borrow<&{FungibleToken.Vault}>(vaultData.metadataPath) == nil { + let vaultCap = signer.capabilities.storage.issue<&{FungibleToken.Balance, FungibleToken.Vault}>( + vaultData.storagePath + ) + signer.capabilities.publish(vaultCap, at: vaultData.metadataPath) + } - // Create a public capability to the Vault that only exposes - // the balance field through the Balance interface - signer.link<&ExampleToken.Vault{FungibleToken.Balance}>( - ExampleToken.VaultPublicPath, - target: ExampleToken.VaultStoragePath - ) + // Issue a Receiver Capability targetting the ExampleToken Vault + let receiverCapability = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>( + vaultData.storagePath + ) let forwarder <- PrivateReceiverForwarder.createNewForwarder(recipient: receiverCapability) - signer.save(<-forwarder, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) + signer.storage.save(<-forwarder, to: PrivateReceiverForwarder.PrivateReceiverStoragePath) - signer.link<&PrivateReceiverForwarder.Forwarder>( - PrivateReceiverForwarder.PrivateReceiverPublicPath, - target: PrivateReceiverForwarder.PrivateReceiverStoragePath + // Issue a Capability to the Forwarder resource + let forwarderCap = signer.capabilities.storage.issue<&PrivateReceiverForwarder.Forwarder>( + PrivateReceiverForwarder.PrivateReceiverStoragePath + ) + // Publish the Capability to the Forwarder resource + signer.capabilities.publish( + forwarderCap, + at: PrivateReceiverForwarder.PrivateReceiverPublicPath ) } } diff --git a/transactions/privateForwarder/transfer_private_many_accounts.cdc b/transactions/privateForwarder/transfer_private_many_accounts.cdc index 7aebbfe3..fa705ddb 100644 --- a/transactions/privateForwarder/transfer_private_many_accounts.cdc +++ b/transactions/privateForwarder/transfer_private_many_accounts.cdc @@ -1,23 +1,27 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import PrivateReceiverForwarder from "PrivateReceiverForwarder" +import "FungibleToken" +import "ExampleToken" +import "PrivateReceiverForwarder" +import "FungibleTokenMetadataViews" /// This transaction transfers to many addresses through their private receivers transaction(addressAmountMap: {Address: UFix64}) { // The Vault resource that holds the tokens that are being transferred - let vaultRef: &ExampleToken.Vault + let vaultRef: auth(FungibleToken.Withdraw) &ExampleToken.Vault let privateForwardingSender: &PrivateReceiverForwarder.Sender - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) + self.vaultRef = signer.storage.borrow(from: vaultData.storagePath) ?? panic("Could not borrow reference to the owner's Vault!") - self.privateForwardingSender = signer.borrow<&PrivateReceiverForwarder.Sender>(from: PrivateReceiverForwarder.SenderStoragePath) + self.privateForwardingSender = signer.storage.borrow<&PrivateReceiverForwarder.Sender>(from: PrivateReceiverForwarder.SenderStoragePath) ?? panic("Could not borrow reference to the owner's Vault!") } diff --git a/transactions/safe_generic_transfer.cdc b/transactions/safe_generic_transfer.cdc index ec1558be..f9d43929 100644 --- a/transactions/safe_generic_transfer.cdc +++ b/transactions/safe_generic_transfer.cdc @@ -1,4 +1,4 @@ -import FungibleToken from "FungibleToken" +import "FungibleToken" /// Can pass in any storage path and receiver path instead of just the default. /// This lets you choose the token you want to send as well the capability you want to send it to. @@ -14,20 +14,20 @@ transaction(amount: UFix64, to: Address, senderPath: StoragePath, receiverPath: // Borrowed teference receive tokens if receiving account doesn't support the sending token let senderReceiverRef: &{Token.Receiver} - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { // Get a reference to the signer's stored vault - let vaultRef = signer.borrow<&{FungibleToken.Provider}>(from: senderPath) + let vaultRef = signer.storage.borrow(from: senderPath) ?? panic("Could not borrow reference to the owner's Vault!") - self.senderReceiverRef = signer.borrow<&{FungibleToken.Receiver}>(from: senderPath) + self.senderReceiverRef = signer.storage.borrow<&{FungibleToken.Receiver}>(from: senderPath) ?? panic("Could not borrow {FungibleToken.Receiver} reference to the owner's Vault!") self.tempVault <- vaultRef.withdraw(amount: amount) } execute { - let receiverRef = getAccount(to).getCapability<&{FungibleToken.Receiver}>(receiverPath).borrow()! + let receiverRef = getAccount(to).capabilities.borrow<&{FungibleToken.Receiver}>(receiverPath)! let supportedVaultTypes = receiverRef.getSupportedVaultTypes() // Only transfer tokens when the receiver is willing to receive the targeted FT. if supportedVaultTypes.containsKey(self.tempVault.getType()) { diff --git a/transactions/scripts/get_balance.cdc b/transactions/scripts/get_balance.cdc index 5ecd644e..8c9dd45a 100644 --- a/transactions/scripts/get_balance.cdc +++ b/transactions/scripts/get_balance.cdc @@ -1,14 +1,16 @@ // This script reads the balance field // of an account's ExampleToken Balance -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" -pub fun main(address: Address): UFix64 { - let account = getAccount(address) - let vaultRef = account.getCapability(ExampleToken.VaultPublicPath) - .borrow<&ExampleToken.Vault{FungibleToken.Balance}>() - ?? panic("Could not borrow Balance reference to the Vault") +access(all) fun main(address: Address): UFix64 { + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") - return vaultRef.balance + return getAccount(address).capabilities.borrow<&{FungibleToken.Balance}>( + vaultData.metadataPath + )?.balance + ?? panic("Could not borrow Balance reference to the Vault") } diff --git a/transactions/scripts/get_balance_generic.cdc b/transactions/scripts/get_balance_generic.cdc new file mode 100644 index 00000000..81d17191 --- /dev/null +++ b/transactions/scripts/get_balance_generic.cdc @@ -0,0 +1,11 @@ +/// This script reads the balance of a vault at whatever path +/// is passed in as an argument + +import "FungibleToken" + +access(all) fun main(address: Address, path: PublicPath): UFix64 { + return getAccount(address).capabilities.borrow<&{FungibleToken.Balance}>( + path + )?.balance + ?? panic("Could not borrow Balance reference to the Vault") +} diff --git a/transactions/scripts/get_supply.cdc b/transactions/scripts/get_supply.cdc index c5b7fee1..eac571ba 100644 --- a/transactions/scripts/get_supply.cdc +++ b/transactions/scripts/get_supply.cdc @@ -1,8 +1,8 @@ // This script reads the total supply field // of the ExampleToken smart contract -import ExampleToken from "ExampleToken" +import "ExampleToken" -pub fun main(): UFix64 { +access(all) fun main(): UFix64 { return ExampleToken.totalSupply } diff --git a/transactions/scripts/get_supported_vault_types.cdc b/transactions/scripts/get_supported_vault_types.cdc index f5ed70ee..c08fa105 100644 --- a/transactions/scripts/get_supported_vault_types.cdc +++ b/transactions/scripts/get_supported_vault_types.cdc @@ -1,16 +1,14 @@ -import FungibleToken from "FungibleToken" +import "FungibleToken" /// This scripts returns the supported FungibleToken's type by the provided `target` address. /// `target` address should hold the capability which conforms with FungibleToken.Receiver restricted type /// while it doesn't matter whether capability refers to fungible token or a custom receiver like /// `FungibleTokenSwitchboard` or `TokenReceiver`. However `targetPath` tells where the capability stores -pub fun main(target: Address, targetPath: PublicPath): {Type: Bool} { +access(all) fun main(target: Address, targetPath: PublicPath): {Type: Bool} { // Access the capability for the provided target address - let capabilityRef = getAccount(target) - .getCapability<&{FungibleToken.Receiver}>(targetPath) - .borrow() - ?? panic("Unable to borrow capability with restricted sub type {FungibleToken.Receiver} from path".concat(targetPath.toString())) + let capabilityRef = getAccount(target).capabilities.borrow<&{FungibleToken.Receiver}>(targetPath) + ?? panic("Unable to borrow capability with restricted sub type {FungibleToken.Receiver} from path".concat(targetPath.toString())) // Return the supported vault types. return capabilityRef.getSupportedVaultTypes() -} \ No newline at end of file +} diff --git a/transactions/scripts/metadata/get_token_metadata.cdc b/transactions/scripts/metadata/get_token_metadata.cdc deleted file mode 100644 index d307d082..00000000 --- a/transactions/scripts/metadata/get_token_metadata.cdc +++ /dev/null @@ -1,16 +0,0 @@ -import ExampleToken from "ExampleToken" -import FungibleTokenMetadataViews from "FungibleTokenMetadataViews" -import MetadataViews from "MetadataViews" - -pub fun main(address: Address): FungibleTokenMetadataViews.FTView { - let account = getAccount(address) - - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") - - let ftView = FungibleTokenMetadataViews.getFTView(viewResolver: vaultRef) - - return ftView -} diff --git a/transactions/scripts/metadata/get_vault_data.cdc b/transactions/scripts/metadata/get_vault_data.cdc deleted file mode 100644 index a008e257..00000000 --- a/transactions/scripts/metadata/get_vault_data.cdc +++ /dev/null @@ -1,17 +0,0 @@ -import ExampleToken from "ExampleToken" -import FungibleTokenMetadataViews from "FungibleTokenMetadataViews" -import MetadataViews from "MetadataViews" - -pub fun main(address: Address): FungibleTokenMetadataViews.FTVaultData { - let account = getAccount(address) - - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") - - let vaultData = FungibleTokenMetadataViews.getFTVaultData(vaultRef) - ?? panic("Token does not implement FTVaultData view") - - return vaultData -} diff --git a/transactions/scripts/metadata/get_vault_display.cdc b/transactions/scripts/metadata/get_vault_display.cdc deleted file mode 100644 index 52893fcd..00000000 --- a/transactions/scripts/metadata/get_vault_display.cdc +++ /dev/null @@ -1,17 +0,0 @@ -import ExampleToken from "ExampleToken" -import FungibleTokenMetadataViews from "FungibleTokenMetadataViews" -import MetadataViews from "MetadataViews" - -pub fun main(address: Address): FungibleTokenMetadataViews.FTDisplay { - let account = getAccount(address) - - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") - - let ftDisplay = FungibleTokenMetadataViews.getFTDisplay(vaultRef) - ?? panic("Token does not implement FTDisplay view") - - return ftDisplay -} diff --git a/transactions/scripts/metadata/get_vault_supply_view.cdc b/transactions/scripts/metadata/get_vault_supply_view.cdc deleted file mode 100644 index 488c3576..00000000 --- a/transactions/scripts/metadata/get_vault_supply_view.cdc +++ /dev/null @@ -1,20 +0,0 @@ -import ExampleToken from "ExampleToken" -import FungibleTokenMetadataViews from "FungibleTokenMetadataViews" -import MetadataViews from "MetadataViews" - -/// Gets the total supply of the vault's token directly from the vault - -pub fun main(address: Address): UFix64 { - let account = getAccount(address) - - let vaultRef = account - .getCapability(ExampleToken.VaultPublicPath) - .borrow<&{MetadataViews.Resolver}>() - ?? panic("Could not borrow a reference to the vault resolver") - - let ftSupply = vaultRef.resolveView(Type())! - - let supplyView = ftSupply as! FungibleTokenMetadataViews.TotalSupply - - return supplyView.supply -} diff --git a/transactions/scripts/switchboard/check_receiver_by_type.cdc b/transactions/scripts/switchboard/check_receiver_by_type.cdc deleted file mode 100644 index 808a33dd..00000000 --- a/transactions/scripts/switchboard/check_receiver_by_type.cdc +++ /dev/null @@ -1,10 +0,0 @@ -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" - -pub fun main(switchboard: Address): Bool { -let switchboardRef = getAccount(switchboard) - .getCapability<&{FungibleTokenSwitchboard.SwitchboardPublic}>(FungibleTokenSwitchboard.PublicPath) - .borrow() - ?? panic("Unable to borrow capability with restricted type of {FungibleTokenSwitchboard.SwitchboardPublic} from ".concat(switchboard.toString()).concat( "account")) - return switchboardRef.checkReceiverByType(type: Type<@ExampleToken.Vault>()) -} \ No newline at end of file diff --git a/transactions/scripts/switchboard/get_vault_types.cdc b/transactions/scripts/switchboard/get_vault_types.cdc deleted file mode 100644 index d92e8183..00000000 --- a/transactions/scripts/switchboard/get_vault_types.cdc +++ /dev/null @@ -1,18 +0,0 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" - -// This script reads the stored vault capabilities from a switchboard on the -// passed account -pub fun main(account: Address): [Type] { - - let acct = getAccount(account) - - // Get a reference to the switchboard conforming to SwitchboardPublic - let switchboardRef = acct.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() - ?? panic("Could not borrow reference to switchboard") - - // Return the result of `getVaultTypes()` - return switchboardRef.getVaultTypes() - -} diff --git a/transactions/scripts/switchboard/get_vault_types_and_address.cdc b/transactions/scripts/switchboard/get_vault_types_and_address.cdc deleted file mode 100644 index e6d0826c..00000000 --- a/transactions/scripts/switchboard/get_vault_types_and_address.cdc +++ /dev/null @@ -1,18 +0,0 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" - -// This script reads the stored vault capabilities from a switchboard on the -// passed account -pub fun main(account: Address): {Type: Address} { - - let acct = getAccount(account) - - // Get a reference to the switchboard conforming to SwitchboardPublic - let switchboardRef = acct.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() - ?? panic("Could not borrow reference to switchboard") - - // Return the result of `getVaultTypesWithAddress()` - return switchboardRef.getVaultTypesWithAddress() - -} diff --git a/transactions/scripts/tokenForwarder/is_recipient_valid.cdc b/transactions/scripts/tokenForwarder/is_recipient_valid.cdc deleted file mode 100644 index c3bfc8a0..00000000 --- a/transactions/scripts/tokenForwarder/is_recipient_valid.cdc +++ /dev/null @@ -1,10 +0,0 @@ -import TokenForwarding from "TokenForwarding" - -pub fun main(addr: Address, tokenForwardingPath: PublicPath): Bool { - let forwarderRef = getAccount(addr) - .getCapability<&{TokenForwarding.ForwarderPublic}>(tokenForwardingPath) - .borrow() - ?? panic("Unable to borrow {TokenForwarding.ForwarderPublic} restrict type from a capability") - - return forwarderRef.check() -} \ No newline at end of file diff --git a/transactions/setup_account.cdc b/transactions/setup_account.cdc index 20a5a433..bf9d4314 100644 --- a/transactions/setup_account.cdc +++ b/transactions/setup_account.cdc @@ -2,36 +2,38 @@ // anyone to add a Vault resource to their account so that // they can use the exampleToken -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import MetadataViews from "MetadataViews" +import "FungibleToken" +import "ExampleToken" +import "ViewResolver" +import "FungibleTokenMetadataViews" transaction () { - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("ViewResolver does not resolve FTVaultData view") // Return early if the account already stores a ExampleToken Vault - if signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) != nil { + if signer.storage.borrow<&ExampleToken.Vault>(from: vaultData.storagePath) != nil { return } + let vault <- ExampleToken.createEmptyVault(vaultType: Type<@ExampleToken.Vault>()) + // Create a new ExampleToken Vault and put it in storage - signer.save( - <-ExampleToken.createEmptyVault(), - to: ExampleToken.VaultStoragePath - ) + signer.storage.save(<-vault, to: vaultData.storagePath) - // Create a public capability to the Vault that only exposes - // the deposit function through the Receiver interface - signer.link<&ExampleToken.Vault{FungibleToken.Receiver}>( - ExampleToken.ReceiverPublicPath, - target: ExampleToken.VaultStoragePath + // Create a public capability to the Vault that exposes the Vault interfaces + let vaultCap = signer.capabilities.storage.issue<&ExampleToken.Vault>( + vaultData.storagePath ) + signer.capabilities.publish(vaultCap, at: vaultData.metadataPath) - // Create a public capability to the Vault that exposes the Balance and Resolver interfaces - signer.link<&ExampleToken.Vault{FungibleToken.Balance, MetadataViews.Resolver}>( - ExampleToken.VaultPublicPath, - target: ExampleToken.VaultStoragePath + // Create a public Capability to the Vault's Receiver functionality + let receiverCap = signer.capabilities.storage.issue<&ExampleToken.Vault>( + vaultData.storagePath ) + signer.capabilities.publish(receiverCap, at: vaultData.receiverPath) } } diff --git a/transactions/switchboard/add_vault_capability.cdc b/transactions/switchboard/add_vault_capability.cdc index 83c6e5a8..e4dd0bd0 100644 --- a/transactions/switchboard/add_vault_capability.cdc +++ b/transactions/switchboard/add_vault_capability.cdc @@ -1,30 +1,72 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" +import "FungibleTokenMetadataViews" -// This transaction is a template for a transaction that -// could be used by anyone to add a new fungible token vault -// capability to their switchboard resource +/// This transaction is a template for a transaction that could be used by anyone to add a new fungible token vault +/// capability to their switchboard resource +/// transaction { let exampleTokenVaultCapability: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) { + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") + + /* ExampleToken Vault configuration */ + // + // Configure an ExampleToken Vault if needed + if signer.storage.borrow<&ExampleToken.Vault>(from: vaultData.storagePath) == nil { + // Create a new ExampleToken Vault and save it in storage + signer.storage.save(<-ExampleToken.createEmptyVault(vaultType: Type<@ExampleToken.Vault>()), to: vaultData.storagePath) + // Clear existing Capabilities at canonical paths + signer.capabilities.unpublish(vaultData.metadataPath) + signer.capabilities.unpublish(vaultData.receiverPath) + // Issue Vault & Receiver Capabilities + let vaultCap = signer.capabilities.storage.issue<&{FungibleToken.Balance, FungibleToken.Vault}>(vaultData.storagePath) + let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>(vaultData.storagePath) + // Publish Capabilities + signer.capabilities.publish(vaultCap, at: vaultData.metadataPath) + signer.capabilities.publish(receiverCap, at: vaultData.receiverPath) + } + // Get the example token vault capability from the signer's account - self.exampleTokenVaultCapability = - signer.getCapability<&{FungibleToken.Receiver}> - (ExampleToken.ReceiverPublicPath) + self.exampleTokenVaultCapability = signer.capabilities.get<&{FungibleToken.Receiver}>( + vaultData.receiverPath) // Check if the receiver capability exists - assert(self.exampleTokenVaultCapability.check(), - message: "Signer does not have a Example Token receiver capability") + assert( + self.exampleTokenVaultCapability.check(), + message: "Signer does not have a Example Token receiver capability" + ) + /* Switchboard setup */ + // + // Configure .Switchboard if needed + if signer.storage.borrow<&FungibleTokenSwitchboard.Switchboard>(from: FungibleTokenSwitchboard.StoragePath) == nil { + // Create a new Switchboard and save it in storage + signer.storage.save(<-FungibleTokenSwitchboard.createSwitchboard(), to: FungibleTokenSwitchboard.StoragePath) + // Clear existing Capabilities at canonical paths + signer.capabilities.unpublish(FungibleTokenSwitchboard.ReceiverPublicPath) + signer.capabilities.unpublish(FungibleTokenSwitchboard.PublicPath) + // Issue Receiver & Switchboard Capabilities + let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>( + FungibleTokenSwitchboard.StoragePath + ) + let switchboardPublicCap = signer.capabilities.storage.issue<&{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver}>( + FungibleTokenSwitchboard.StoragePath + ) + // Publish Capabilities + signer.capabilities.publish(receiverCap, at: FungibleTokenSwitchboard.ReceiverPublicPath) + signer.capabilities.publish(switchboardPublicCap, at: FungibleTokenSwitchboard.PublicPath) + } // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") + self.switchboardRef = signer.storage.borrow( + from: FungibleTokenSwitchboard.StoragePath + ) ?? panic("Could not borrow reference to switchboard") } diff --git a/transactions/switchboard/add_vault_wrapper_capability.cdc b/transactions/switchboard/add_vault_wrapper_capability.cdc index 936d1cab..7b613fd2 100644 --- a/transactions/switchboard/add_vault_wrapper_capability.cdc +++ b/transactions/switchboard/add_vault_wrapper_capability.cdc @@ -1,38 +1,48 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" +import "FungibleTokenMetadataViews" -// This transaction is a template for a transaction that -// could be used by anyone to add a new vault wrapper -// capability to their switchboard resource +/// This transaction is a template for a transaction that could be used by anyone to add a new vault wrapper capability +/// to their switchboard resource +/// They would just need to change the contract name they are importing from +/// to the token contract that they want to support with their switchboard +/// transaction { - let tokenForwarderCapability: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let tokenReceiverCapability: Capability<&{FungibleToken.Receiver}> + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get the token forwarder capability from the signer's account - self.tokenForwarderCapability = - signer.getCapability<&{FungibleToken.Receiver}> - (ExampleToken.ReceiverPublicPath) - + self.tokenReceiverCapability = signer.capabilities.get<&{FungibleToken.Receiver}>( + vaultData.receiverPath) + // Check if the receiver capability exists - assert(self.tokenForwarderCapability.check(), - message: "Signer does not have a working fungible token receiver capability") - + assert( + self.tokenReceiverCapability.check(), + message: "Signer does not have a working fungible token receiver capability" + ) + // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") - + self.switchboardRef = signer.storage.borrow( + from: FungibleTokenSwitchboard.StoragePath + ) ?? panic("Could not borrow reference to switchboard") + } execute { // Add the capability to the switchboard using addNewVault method - self.switchboardRef.addNewVaultWrapper(capability: self.tokenForwarderCapability, type: Type<@ExampleToken.Vault>()) - + self.switchboardRef.addNewVaultWrapper( + capability: self.tokenReceiverCapability, + type: Type<@ExampleToken.Vault>() + ) + } } diff --git a/transactions/switchboard/batch_add_vault_capabilities.cdc b/transactions/switchboard/batch_add_vault_capabilities.cdc index 5f12f5c3..668093ff 100644 --- a/transactions/switchboard/batch_add_vault_capabilities.cdc +++ b/transactions/switchboard/batch_add_vault_capabilities.cdc @@ -1,19 +1,23 @@ -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" +import "FungibleTokenMetadataViews" -// This transaction is a template for a transaction that could be used by anyone -// to add several new fungible token vaults, belonging to a certain `Address` to -// their switchboard resource. +/// This transaction is a template for a transaction that could be used by anyone to add several new fungible token +/// vaults, belonging to a certain `Address` to their switchboard resource. +/// transaction (address: Address) { let exampleTokenVaultPath: PublicPath let vaultPaths: [PublicPath] - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get the example token vault path from the contract - self.exampleTokenVaultPath = ExampleToken.ReceiverPublicPath + self.exampleTokenVaultPath = vaultData.receiverPath // And store it in the array of public paths that will be passed to the // switchboard method @@ -21,17 +25,17 @@ transaction (address: Address) { self.vaultPaths.append(self.exampleTokenVaultPath) // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") + self.switchboardRef = signer.storage.borrow( + from: FungibleTokenSwitchboard.StoragePath + ) ?? panic("Could not borrow reference to switchboard") } execute { - // Add the capability to the switchboard using addNewVault method - self.switchboardRef.addNewVaultsByPath (paths: self.vaultPaths, address: address) + // Add the capability to the switchboard using addNewVault method + self.switchboardRef.addNewVaultsByPath(paths: self.vaultPaths, address: address) } -} \ No newline at end of file +} diff --git a/transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc b/transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc index 3c025f2e..a1357190 100644 --- a/transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc +++ b/transactions/switchboard/batch_add_vault_wrapper_capabilities.cdc @@ -1,21 +1,25 @@ -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" +import "FungibleTokenMetadataViews" -// This transaction is a template for a transaction that could be used by anyone -// to add several capabilities that point to fungible token vaults of a different -// `Type` and belong to a certain `Address`, to their switchboard resource. +/// This transaction is a template for a transaction that could be used by anyone to add several capabilities that point +/// to fungible token vaults of a different `Type` and belong to a certain `Address`, to their switchboard resource. +/// transaction (address: Address) { let vaultPaths: [PublicPath] let vaultTypes: [Type] - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Store the Example Token receiver's public path in the array of public // paths that will be passed to the switchboard method self.vaultPaths = [] - self.vaultPaths.append(ExampleToken.ReceiverPublicPath) + self.vaultPaths.append(vaultData.receiverPath) // Store the Example Token's type in the array of types that will be passed // to the switchboard method @@ -23,17 +27,20 @@ transaction (address: Address) { self.vaultTypes.append(Type<@ExampleToken.Vault>()) // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") + self.switchboardRef = signer.storage.borrow( + from: FungibleTokenSwitchboard.StoragePath + ) ?? panic("Could not borrow reference to switchboard") } execute { - // Add the capability(ies) to the switchboard using addNewVaultWrappersByPath - self.switchboardRef.addNewVaultWrappersByPath(paths: self.vaultPaths, - types: self.vaultTypes, address: address) + // Add the capability(ies) to the switchboard using addNewVaultWrappersByPath + self.switchboardRef.addNewVaultWrappersByPath( + paths: self.vaultPaths, + types: self.vaultTypes, + address: address + ) } diff --git a/transactions/switchboard/remove_vault_capability.cdc b/transactions/switchboard/remove_vault_capability.cdc index 682061c4..689afeec 100644 --- a/transactions/switchboard/remove_vault_capability.cdc +++ b/transactions/switchboard/remove_vault_capability.cdc @@ -1,34 +1,32 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" -// This transaction is a template for a transaction that -// could be used by anyone to remove fungible token vault -// capability from their switchboard resource +/// This transaction is a template for a transaction that could be used by anyone to remove fungible token vault +/// capability from their switchboard resource +/// transaction(path: PublicPath) { let exampleTokenVaultCapabilty: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { - // Get the capability from the signer's account - self.exampleTokenVaultCapabilty = signer.getCapability - <&{FungibleToken.Receiver}>(path) - - // Get a reference to the signers switchboard - self.switchboardRef = signer.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) - ?? panic("Could not borrow reference to switchboard") + // Get the capability from the signer's account + self.exampleTokenVaultCapabilty = signer.capabilities.get<&{FungibleToken.Receiver}>(path) + + // Get a reference to the signers switchboard + self.switchboardRef = signer.storage.borrow( + from: FungibleTokenSwitchboard.StoragePath + ) ?? panic("Could not borrow reference to switchboard") } execute { - // Remove the capability from the switchboard using the - // removeVault method + // Remove the capability from the switchboard using the .removeVault() method self.switchboardRef.removeVault(capability: self.exampleTokenVaultCapabilty) - + } } diff --git a/transactions/switchboard/safe_deposit_to_lnf.cdc b/transactions/switchboard/safe_deposit_to_lnf.cdc deleted file mode 100644 index 30cd364a..00000000 --- a/transactions/switchboard/safe_deposit_to_lnf.cdc +++ /dev/null @@ -1,96 +0,0 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import FiatToken from "FiatToken" -import LostAndFound from "LostAndFound" -import FlowToken from "FlowToken" - -// This transaction templates how to send USDC funds `to` any `Address` without knowing -// if it holds a vault of that specific token type. The transaction will attempt to -// deposit the funds into the receiver's switchboard, if no capability for routing -// that specific FT is found on the switchboard, then it will deposit the funds -// into the LostAndFound contract. -// -transaction(to: Address, amount: UFix64) { - - // The reference to the vault from the payer's account - let vaultRef: &FiatToken.Vault - // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault - // A reference to the signer's flow vault, that will be used for paying the L&F fees - let flowProviderRef: &{FungibleToken.Provider} - // A capability to the signer's flow token receiver for recovering the L&F fees - let flowReceiver: Capability<&FlowToken.Vault{FungibleToken.Receiver}>? - - prepare(signer: AuthAccount) { - - // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&FiatToken.Vault>(from: FiatToken.VaultStoragePath) - ?? panic("Could not borrow reference to the owner's Vault!") - // Withdraw tokens from the signer's stored vault - self.sentVault <-self.vaultRef.withdraw(amount: amount) - - // Borrow a reference to the signer's flow token provider - self.flowProviderRef = signer.borrow<&{FungibleToken.Provider}>(from: /storage/flowTokenVault) - ?? panic("Could not borrow signer's flow vault provider") - - // Get the capability of the signer's flow token receiver - self.flowReceiver = signer.getCapability<&FlowToken.Vault{FungibleToken.Receiver}>(/public/flowTokenReceiver) - - } - - execute { - - // Get the recipient's public account object - let recipient = getAccount(to) - - if let switchboardRef = recipient.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() { - // Attempt to deposit the USDC funds into the receiver's switchboard - if let notDepositedVault <-switchboardRef.safeDeposit(from: <- self.sentVault.withdraw(amount: amount)) { - // If a vault is returned, then their deposit didn't succeed, so we put - // the funds into Lost And Found - let memo = "Due royalties" - let depositEstimate <- LostAndFound.estimateDeposit(redeemer: to, item: <-notDepositedVault, memo: memo, display: nil) - let storageFee <- self.flowProviderRef.withdraw(amount: depositEstimate.storageFee) - let resource <- depositEstimate.withdraw() - - LostAndFound.deposit( - redeemer: to, - item: <-resource, - memo: memo, - display: nil, - storagePayment: &storageFee as &FungibleToken.Vault, - flowTokenRepayment: self.flowReceiver - ) - - // Return any remaining storage fees in this vault to the configured - // flow receiver - self.flowReceiver!.borrow()!.deposit(from: <-storageFee) - destroy depositEstimate - } - destroy self.sentVault - } else { - // If the user did not had a switchboard we deposit the funds into L&F - let memo = "Due royalties" - let depositEstimate <- LostAndFound.estimateDeposit(redeemer: to, item: <-self.sentVault, memo: memo, display: nil) - let storageFee <- self.flowProviderRef.withdraw(amount: depositEstimate.storageFee) - let resource <- depositEstimate.withdraw() - LostAndFound.deposit( - redeemer: to, - item: <-resource, - memo: memo, - display: nil, - storagePayment: &storageFee as &FungibleToken.Vault, - flowTokenRepayment: self.flowReceiver - ) - // Return any remaining storage fees in this vault to the configured - // flow receiver - self.flowReceiver!.borrow()!.deposit(from: <-storageFee) - destroy depositEstimate - - - } - } - -} - \ No newline at end of file diff --git a/transactions/switchboard/safe_transfer_tokens.cdc b/transactions/switchboard/safe_transfer_tokens.cdc index f1ea3ef6..5adb2057 100644 --- a/transactions/switchboard/safe_transfer_tokens.cdc +++ b/transactions/switchboard/safe_transfer_tokens.cdc @@ -1,29 +1,26 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" - -// This transaction is a template for a transaction that could be used by anyone -// to send tokens to another account through a switchboard using the safeDeposit -// method. This method will not panic if the switchboard does not have the -// capability to store the desired FT, returning the deposited vault instead. -// The withdraw amount and the account from getAccount would be the parameters -// to the transaction. +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "ExampleToken" +import "FungibleTokenMetadataViews" + +/// This transaction is a template for a transaction that could be used by anyone to send tokens to another account +/// through a switchboard using the deposit method but before depositing we will explicitly check whether receiving +/// capability is borrowable or not and if yes then it will deposit the vault to the receiver capability. +/// transaction(to: Address, amount: UFix64) { - + // The reference to the vault from the payer's account - let vaultRef: &ExampleToken.Vault - // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault + let vaultRef: auth(FungibleToken.Withdraw) &ExampleToken.Vault + + prepare(signer: auth(BorrowValue) &Account) { - prepare(signer: AuthAccount) { + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) + self.vaultRef = signer.storage.borrow(from: vaultData.storagePath) ?? panic("Could not borrow reference to the owner's Vault!") - // Withdraw tokens from the signer's stored vault - self.sentVault <-self.vaultRef.withdraw(amount: amount) - } execute { @@ -31,20 +28,20 @@ transaction(to: Address, amount: UFix64) { // Get the recipient's public account object let recipient = getAccount(to) - // Get a reference to the recipient's Switchboard Receiver - let switchboardRef = recipient.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() - ?? panic("Could not borrow receiver reference to switchboard!") - - // Deposit the funds on the switchboard, if the deposit does not complete - // the method will return the funds instead of panicking, so we have to - // recover those funds - if let notDepositedVault <-switchboardRef.safeDeposit(from: <- self.sentVault.withdraw(amount: amount)){ - self.vaultRef.deposit(from: <-notDepositedVault) - } + let sentVault <- self.vaultRef.withdraw(amount: amount) - destroy self.sentVault - + // Get a reference to the recipient's SwitchboardPublic + let switchboardRef = recipient.capabilities.borrow<&{FungibleTokenSwitchboard.SwitchboardPublic}>( + FungibleTokenSwitchboard.PublicPath + ) ?? panic("Could not borrow receiver reference to switchboard!") + + // Validate the receiving capability by using safeBorrowByType + if let receivingRef = switchboardRef.safeBorrowByType(type: Type<@ExampleToken.Vault>()) { + switchboardRef.deposit(from: <-sentVault) + } else { + // Return funds to signer's account if receiver is not configured to receive the funds + self.vaultRef.deposit(from: <-sentVault) + } } } diff --git a/transactions/switchboard/safe_transfer_tokens_v2.cdc b/transactions/switchboard/safe_transfer_tokens_v2.cdc deleted file mode 100644 index 2d3e2f4e..00000000 --- a/transactions/switchboard/safe_transfer_tokens_v2.cdc +++ /dev/null @@ -1,45 +0,0 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import ExampleToken from "ExampleToken" - -// This transaction is a template for a transaction that could be used by anyone -// to send tokens to another account through a switchboard using the deposit -// method but before depositing we will explicitly check whether receiving capability is -// borrowable or not and if yes then it will deposit the vault to the receiver capability. -transaction(to: Address, amount: UFix64) { - - // The reference to the vault from the payer's account - let vaultRef: &ExampleToken.Vault - // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault - - prepare(signer: AuthAccount) { - - // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) - ?? panic("Could not borrow reference to the owner's Vault!") - - // Withdraw tokens from the signer's stored vault - self.sentVault <-self.vaultRef.withdraw(amount: amount) - - } - - execute { - - // Get the recipient's public account object - let recipient = getAccount(to) - - // Get a reference to the recipient's Switchboard Receiver - let switchboardRef = recipient.getCapability(FungibleTokenSwitchboard.PublicPath) - .borrow<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic}>() - ?? panic("Could not borrow receiver reference to switchboard!") - - // Validate the receiving capability by using safeBorrowByType - if let receivingRef = switchboardRef.safeBorrowByType(type: Type<@ExampleToken.Vault>()){ - switchboardRef.deposit(from: <-self.sentVault) - } else { - destroy self.sentVault - } - } - -} \ No newline at end of file diff --git a/transactions/switchboard/scripts/get_vault_types_and_address.cdc b/transactions/switchboard/scripts/get_vault_types_and_address.cdc new file mode 100644 index 00000000..3fae4d76 --- /dev/null +++ b/transactions/switchboard/scripts/get_vault_types_and_address.cdc @@ -0,0 +1,16 @@ +import "FungibleToken" +import "FungibleTokenSwitchboard" + +/// This script reads the stored vault capabilities from a switchboard on the passed account +/// +access(all) fun main(account: Address): {Type: Address} { + + // Get a reference to the switchboard conforming to SwitchboardPublic + let switchboardRef = getAccount(account).capabilities.borrow<&{FungibleTokenSwitchboard.SwitchboardPublic}>( + FungibleTokenSwitchboard.PublicPath + ) ?? panic("Could not borrow reference to switchboard") + + // Return the result of `getVaultTypesWithAddress()` + return switchboardRef.getVaultTypesWithAddress() + +} diff --git a/transactions/switchboard/setup_account.cdc b/transactions/switchboard/setup_account.cdc index 533e6135..6d0215a5 100644 --- a/transactions/switchboard/setup_account.cdc +++ b/transactions/switchboard/setup_account.cdc @@ -1,38 +1,42 @@ -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import FungibleToken from "FungibleToken" +import "FungibleTokenSwitchboard" +import "FungibleToken" // This transaction is a template for a transaction that could be used by // anyone to to add a Switchboard resource to their account so that they can // receive multiple fungible tokens using a single {FungibleToken.Receiver} transaction { - prepare(acct: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) { - // Check if the account already has a Switchboard resource - if acct.borrow<&FungibleTokenSwitchboard.Switchboard> - (from: FungibleTokenSwitchboard.StoragePath) == nil { + // Check if the account already has a Switchboard resource, return early if so + if signer.storage.borrow<&FungibleTokenSwitchboard.Switchboard>(from: FungibleTokenSwitchboard.StoragePath) != nil { + return + } - // Create a new Switchboard resource and put it into storage - acct.save( - <- FungibleTokenSwitchboard.createSwitchboard(), - to: FungibleTokenSwitchboard.StoragePath) + // Create a new Switchboard resource and put it into storage + signer.storage.save( + <- FungibleTokenSwitchboard.createSwitchboard(), + to: FungibleTokenSwitchboard.StoragePath + ) - // Create a public capability to the Switchboard exposing the deposit - // function through the {FungibleToken.Receiver} interface - acct.link<&FungibleTokenSwitchboard.Switchboard{FungibleToken.Receiver}>( - FungibleTokenSwitchboard.ReceiverPublicPath, - target: FungibleTokenSwitchboard.StoragePath - ) - - // Create a public capability to the Switchboard exposing both the - // {FungibleTokenSwitchboard.SwitchboardPublic} and the - // {FungibleToken.Receiver} interfaces - acct.link<&FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver}>( - FungibleTokenSwitchboard.PublicPath, - target: FungibleTokenSwitchboard.StoragePath + // Clear existing Capabilities at canonical paths + signer.capabilities.unpublish(FungibleTokenSwitchboard.ReceiverPublicPath) + signer.capabilities.unpublish(FungibleTokenSwitchboard.PublicPath) + + // Create a public capability to the Switchboard exposing the deposit + // function through the {FungibleToken.Receiver} interface + let receiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>( + FungibleTokenSwitchboard.StoragePath ) + signer.capabilities.publish(receiverCap, at: FungibleTokenSwitchboard.ReceiverPublicPath) - } + // Create a public capability to the Switchboard exposing both the + // {FungibleTokenSwitchboard.SwitchboardPublic} and the + // {FungibleToken.Receiver} interfaces + let switchboardPublicCap = signer.capabilities.storage.issue<&{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver}>( + FungibleTokenSwitchboard.StoragePath + ) + signer.capabilities.publish(switchboardPublicCap, at: FungibleTokenSwitchboard.PublicPath) } diff --git a/transactions/switchboard/setup_royalty_account.cdc b/transactions/switchboard/setup_royalty_account.cdc index 6dd8dfbe..6adcf5b7 100644 --- a/transactions/switchboard/setup_royalty_account.cdc +++ b/transactions/switchboard/setup_royalty_account.cdc @@ -1,90 +1,71 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import FlowToken from "FlowToken" -import FiatToken from "FiatToken" +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "FlowToken" +import "FiatToken" -// This transaction is a template for a transaction that could be used by -// anyone fully setup an account for receiving both Flow and USDC tokens at the same -// public path (for instance the royalties /public/GenericFTReceiver path) -// Using the addNewVaultWrappersByPath switchboard method allows anyone to use -// capability wrappers such as TokenForwarders instead of the actual token vault. +/// This transaction is a template for a transaction that could be used by +/// anyone fully setup an account for receiving both Flow and USDC tokens at the same +/// public path (for instance the royalties /public/GenericFTReceiver path) +/// Using the addNewVaultWrappersByPath switchboard method allows anyone to use +/// capability wrappers such as TokenForwarders instead of the actual token vault. transaction () { let flowTokenVaultCapability: Capability<&{FungibleToken.Receiver}> let fiatTokenVaultCapability: Capability<&{FungibleToken.Receiver}> - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(acct: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) Account) { - // Check if the account already has a Flow Vault - if acct.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault) == nil { - // If not, create a new Flow Vault resource and put it into storage - acct.save(<- FlowToken.createEmptyVault(), to: /storage/flowTokenVault) - } - // Check if the receiver capability is linked on the flow receiver path - if !acct.getCapability<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) - .check() { - // if it's not, create a public capability to the flow vault exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(/public/flowTokenReceiver) - acct.link<&{FungibleToken.Receiver}>(/public/flowTokenReceiver, - target: /storage/flowTokenVault) - } - self.flowTokenVaultCapability = acct.getCapability<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) + self.flowTokenVaultCapability = signer.capabilities.get<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) + ?? panic("Signer does not have a FlowToken receiver capability") // Check if the account already has a USDC Vault - if acct.borrow<&FiatToken.Vault>(from: FiatToken.VaultStoragePath) == nil { + if signer.storage.borrow<&FiatToken.Vault>(from: FiatToken.VaultStoragePath) == nil { // If not, create a new USDC Vault resource and put it into storage - acct.save(<- FiatToken.createEmptyVault(), + signer.storage.save(<-FiatToken.createEmptyVault(vaultType: Type<@FiatToken.Vault>()), to: FiatToken.VaultStoragePath) } // Check if the receiver capability is linked on the USDC receiver path - if !acct.getCapability<&{FungibleToken.Receiver}> - (FiatToken.VaultReceiverPubPath).check() { - // if it's not, create a public capability to the USDC vault exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(FiatToken.VaultReceiverPubPath) - acct.link<&{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath, - target: FiatToken.VaultStoragePath) + if !signer.capabilities.get<&{FungibleToken.Receiver}> + (FiatToken.VaultReceiverPubPath)!.check() { + // if it's not, create a public capability to the USDC vault + let tokenCap = signer.capabilities.storage.issue<&FiatToken.Vault>(FiatToken.VaultStoragePath) + signer.capabilities.publish(tokenCap, at: FiatToken.VaultReceiverPubPath) + let receiverCap = signer.capabilities.storage.issue<&FiatToken.Vault>(FiatToken.VaultStoragePath) + signer.capabilities.publish(receiverCap, at: FiatToken.VaultBalancePubPath) } - self.fiatTokenVaultCapability = acct.getCapability<&{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath) + self.fiatTokenVaultCapability = signer.capabilities.get<&{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath) // Check if the account already has a Switchboard resource - if acct.borrow<&FungibleTokenSwitchboard.Switchboard> + if signer.storage.borrow<&FungibleTokenSwitchboard.Switchboard> (from: FungibleTokenSwitchboard.StoragePath) == nil { // If not, create a new Switchboard resource and put it into storage - acct.save(<- FungibleTokenSwitchboard.createSwitchboard(), + signer.storage.save(<- FungibleTokenSwitchboard.createSwitchboard(), to: FungibleTokenSwitchboard.StoragePath) } // Check if the receiver capability is linked on the receiver path - if !acct.getCapability - <&FungibleTokenSwitchboard.Switchboard{FungibleToken.Receiver}> - (FungibleTokenSwitchboard.ReceiverPublicPath).check() { - // if it's not, create a public capability to the Switchboard exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(FungibleTokenSwitchboard.ReceiverPublicPath) - acct.link<&FungibleTokenSwitchboard.Switchboard{FungibleToken.Receiver}>( - FungibleTokenSwitchboard.ReceiverPublicPath, - target: FungibleTokenSwitchboard.StoragePath) + if !signer.capabilities.get + <&FungibleTokenSwitchboard.Switchboard> + (FungibleTokenSwitchboard.ReceiverPublicPath)!.check() { + // if it's not, create a public capability to the Switchboard + let receiverCap = signer.capabilities.storage.issue<&FungibleTokenSwitchboard.Switchboard>(FungibleTokenSwitchboard.StoragePath) + signer.capabilities.publish(receiverCap, at: FungibleTokenSwitchboard.ReceiverPublicPath) } // Check if the SwitchboardPublic and ft receiver capabilities are linked on // the switchboard public path - if !acct.getCapability< - &FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver} - >(FungibleTokenSwitchboard.ReceiverPublicPath) + if !signer.capabilities.get< + &FungibleTokenSwitchboard.Switchboard + >(FungibleTokenSwitchboard.ReceiverPublicPath)! .check() { - // if it's not, create a public capability to the Switchboard exposing - // both the {FungibleTokenSwitchboard.SwitchboardPublic} and the - // {FungibleToken.Receiver} interfaces - acct.unlink(FungibleTokenSwitchboard.PublicPath) - acct.link< - &FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver} - >(FungibleTokenSwitchboard.PublicPath, - target: FungibleTokenSwitchboard.StoragePath) + // if it's not, create a public capability to the Switchboard + let switchboardReceiverCap = signer.capabilities.storage.issue< + &FungibleTokenSwitchboard.Switchboard + >(FungibleTokenSwitchboard.StoragePath) + signer.capabilities.publish(switchboardReceiverCap, at: FungibleTokenSwitchboard.PublicPath) } // Get a reference to the switchboard - self.switchboardRef = acct.borrow<&FungibleTokenSwitchboard.Switchboard> + self.switchboardRef = signer.storage.borrow (from: FungibleTokenSwitchboard.StoragePath) ?? panic("Could not borrow reference to switchboard") diff --git a/transactions/switchboard/setup_royalty_account_by_paths.cdc b/transactions/switchboard/setup_royalty_account_by_paths.cdc index 6042e260..79b4e83e 100644 --- a/transactions/switchboard/setup_royalty_account_by_paths.cdc +++ b/transactions/switchboard/setup_royalty_account_by_paths.cdc @@ -1,21 +1,22 @@ -import FungibleToken from "FungibleToken" -import FungibleTokenSwitchboard from "FungibleTokenSwitchboard" -import FlowToken from "FlowToken" -import FiatToken from "FiatToken" +import "FungibleToken" +import "FungibleTokenSwitchboard" +import "FlowToken" +import "FiatToken" -// This transaction is a template for a transaction that could be used by -// anyone fully setup an account for receiving both Flow and USDC tokens at the same -// public path (for instance the royalties /public/GenericFTReceiver path) -// Using the addNewVaultWrappersByPath switchboard method allows anyone to use -// capability wrappers such as TokenForwarders instead of the actual token vault. +/// This transaction is a template for a transaction that could be used by +/// anyone fully setup an account for receiving both Flow and USDC tokens at the same +/// public path (for instance the royalties /public/GenericFTReceiver path) +/// Using the addNewVaultWrappersByPath switchboard method allows anyone to use +/// capability wrappers such as TokenForwarders instead of the actual token vault. + transaction (address: Address) { let vaultPaths: [PublicPath] let vaultTypes: [Type] - let switchboardRef: &FungibleTokenSwitchboard.Switchboard + let switchboardRef: auth(FungibleTokenSwitchboard.Owner) &FungibleTokenSwitchboard.Switchboard - prepare(acct: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) Account) { // Prepare the paths and types arrays with the Flow and USDC tokens data self.vaultPaths = [] @@ -25,75 +26,55 @@ transaction (address: Address) { self.vaultTypes.append(Type<@FlowToken.Vault>()) self.vaultTypes.append(Type<@FiatToken.Vault>()) - // Check if the account already has a Flow Vault - if acct.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault) == nil { - // If not, create a new Flow Vault resource and put it into storage - acct.save(<- FlowToken.createEmptyVault(), to: /storage/flowTokenVault) - } - // Check if the receiver capability is linked on the flow receiver path - if !acct.getCapability<&{FungibleToken.Receiver}>(/public/flowTokenReceiver) - .check() { - // if it's not, create a public capability to the flow vault exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(/public/flowTokenReceiver) - acct.link<&{FungibleToken.Receiver}>(/public/flowTokenReceiver, - target: /storage/flowTokenVault) - } - // Check if the account already has a USDC Vault - if acct.borrow<&FiatToken.Vault>(from: FiatToken.VaultStoragePath) == nil { + if signer.storage.borrow<&FiatToken.Vault>(from: FiatToken.VaultStoragePath) == nil { // If not, create a new USDC Vault resource and put it into storage - acct.save(<- FiatToken.createEmptyVault(), + signer.storage.save(<-FiatToken.createEmptyVault(vaultType: Type<@FiatToken.Vault>()), to: FiatToken.VaultStoragePath) } + // Check if the receiver capability is linked on the USDC receiver path - if !acct.getCapability<&{FungibleToken.Receiver}> - (FiatToken.VaultReceiverPubPath).check() { - // if it's not, create a public capability to the USDC vault exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(FiatToken.VaultReceiverPubPath) - acct.link<&{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath, - target: FiatToken.VaultStoragePath) + if !signer.capabilities.get<&{FungibleToken.Receiver}> + (FiatToken.VaultReceiverPubPath)!.check() { + // if it's not, create a public capability to the USDC vault + let tokenCap = signer.capabilities.storage.issue<&FiatToken.Vault>(FiatToken.VaultStoragePath) + signer.capabilities.publish(tokenCap, at: FiatToken.VaultReceiverPubPath) + let receiverCap = signer.capabilities.storage.issue<&FiatToken.Vault>(FiatToken.VaultStoragePath) + signer.capabilities.publish(receiverCap, at: FiatToken.VaultBalancePubPath) } + self.fiatTokenVaultCapability = signer.capabilities.get<&{FungibleToken.Receiver}>(FiatToken.VaultReceiverPubPath) // Check if the account already has a Switchboard resource - if acct.borrow<&FungibleTokenSwitchboard.Switchboard> + if signer.storage.borrow<&FungibleTokenSwitchboard.Switchboard> (from: FungibleTokenSwitchboard.StoragePath) == nil { // If not, create a new Switchboard resource and put it into storage - acct.save(<- FungibleTokenSwitchboard.createSwitchboard(), + signer.storage.save(<- FungibleTokenSwitchboard.createSwitchboard(), to: FungibleTokenSwitchboard.StoragePath) } // Check if the receiver capability is linked on the receiver path - if !acct.getCapability - <&FungibleTokenSwitchboard.Switchboard{FungibleToken.Receiver}> - (FungibleTokenSwitchboard.ReceiverPublicPath).check() { - // if it's not, create a public capability to the Switchboard exposing - // the deposit function through the {FungibleToken.Receiver} interface - acct.unlink(FungibleTokenSwitchboard.ReceiverPublicPath) - acct.link<&FungibleTokenSwitchboard.Switchboard{FungibleToken.Receiver}>( - FungibleTokenSwitchboard.ReceiverPublicPath, - target: FungibleTokenSwitchboard.StoragePath) + if !signer.capabilities.get + <&FungibleTokenSwitchboard.Switchboard> + (FungibleTokenSwitchboard.ReceiverPublicPath)!.check() { + // if it's not, create a public capability to the Switchboard + let receiverCap = signer.capabilities.storage.issue<&FungibleTokenSwitchboard.Switchboard>(FungibleTokenSwitchboard.StoragePath) + signer.capabilities.publish(receiverCap, at: FungibleTokenSwitchboard.ReceiverPublicPath) } // Check if the SwitchboardPublic and ft receiver capabilities are linked on // the switchboard public path - if !acct.getCapability< - &FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver} - >(FungibleTokenSwitchboard.ReceiverPublicPath) + if !signer.capabilities.get< + &FungibleTokenSwitchboard.Switchboard + >(FungibleTokenSwitchboard.ReceiverPublicPath)! .check() { - // if it's not, create a public capability to the Switchboard exposing - // both the {FungibleTokenSwitchboard.SwitchboardPublic} and the - // {FungibleToken.Receiver} interfaces - acct.unlink(FungibleTokenSwitchboard.PublicPath) - acct.link< - &FungibleTokenSwitchboard.Switchboard{FungibleTokenSwitchboard.SwitchboardPublic, FungibleToken.Receiver} - >(FungibleTokenSwitchboard.PublicPath, - target: FungibleTokenSwitchboard.StoragePath) + // if it's not, create a public capability to the Switchboard + let switchboardReceiverCap = signer.capabilities.storage.issue< + &FungibleTokenSwitchboard.Switchboard + >(FungibleTokenSwitchboard.StoragePath) + signer.capabilities.publish(switchboardReceiverCap, at: FungibleTokenSwitchboard.PublicPath) } // Get a reference to the switchboard - self.switchboardRef = acct.borrow<&FungibleTokenSwitchboard.Switchboard> + self.switchboardRef = signer.storage.borrow (from: FungibleTokenSwitchboard.StoragePath) ?? panic("Could not borrow reference to switchboard") - } execute { diff --git a/transactions/switchboard/transfer_tokens.cdc b/transactions/switchboard/transfer_tokens.cdc index 7283ddf7..9d87bf6a 100644 --- a/transactions/switchboard/transfer_tokens.cdc +++ b/transactions/switchboard/transfer_tokens.cdc @@ -1,28 +1,27 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" - -// This transaction is a template for a transaction that -// could be used by anyone to send tokens to another account -// through a switchboard, as long as they have set up their -// switchboard and have add the proper capability to it -// -// The address of the receiver account, the amount to transfer -// and the PublicPath for the generic FT receiver will be the -// parameters +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" + +/// This transaction is a template for a transaction that could be used by anyone to send tokens to another account +/// through a switchboard, as long as they have set up their switchboard and have add the proper capability to it +/// +/// The address of the receiver account, the amount to transfer and the PublicPath for the generic FT receiver will be +/// the parameters +/// transaction(to: Address, amount: UFix64, receiverPath: PublicPath) { - // The vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault + // The signer's vault to withdraw from + let sourceVault: auth(FungibleToken.Withdraw) &ExampleToken.Vault - prepare(signer: AuthAccount) { + prepare(signer: auth(BorrowValue) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get a reference to the signer's stored vault - let vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) + self.sourceVault = signer.storage.borrow(from: vaultData.storagePath) ?? panic("Could not borrow reference to the owner's Vault!") - // Withdraw tokens from the signer's stored vault - self.sentVault <- vaultRef.withdraw(amount: amount) - } execute { @@ -31,14 +30,12 @@ transaction(to: Address, amount: UFix64, receiverPath: PublicPath) { let recipient = getAccount(to) // Get a reference to the recipient's Receiver - let receiverRef = recipient - .getCapability(receiverPath) - .borrow<&{FungibleToken.Receiver}>() + let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(receiverPath) ?? panic("Could not borrow receiver reference to switchboard!") // Deposit the withdrawn tokens in the recipient's receiver - receiverRef.deposit(from: <-self.sentVault) - + receiverRef.deposit(from: <-self.sourceVault.withdraw(amount: amount)) + } } diff --git a/transactions/create_forwarder.cdc b/transactions/tokenForwarder/create_forwarder.cdc similarity index 52% rename from transactions/create_forwarder.cdc rename to transactions/tokenForwarder/create_forwarder.cdc index d6e627bb..b01427f2 100644 --- a/transactions/create_forwarder.cdc +++ b/transactions/tokenForwarder/create_forwarder.cdc @@ -23,37 +23,38 @@ Steps to set up accounts with token forwarder: getting the Receiver from the account that is the recipient. */ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" -import TokenForwarding from "TokenForwarding" +import "FungibleToken" +import "ExampleToken" +import "TokenForwarding" +import "FungibleTokenMetadataViews" transaction(receiver: Address) { - prepare(acct: AuthAccount) { + prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue, UnpublishCapability) &Account) { + + let vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("Could not get vault data view for the contract") // Get the receiver capability for the account being forwarded to - let recipient = getAccount(receiver) - .getCapability<&{FungibleToken.Receiver}>(ExampleToken.ReceiverPublicPath) + let recipient = getAccount(receiver).capabilities.get<&{FungibleToken.Receiver}>(vaultData.receiverPath) // Create the forwarder and save it to the account that is doing the forwarding let vault <- TokenForwarding.createNewForwarder(recipient: recipient) - acct.save(<-vault, to: /storage/exampleTokenForwarder) + signer.storage.save(<-vault, to: /storage/exampleTokenForwarder) - // Unlink the existing receiver capability - if acct.getCapability(ExampleToken.ReceiverPublicPath).check<&{FungibleToken.Receiver}>() { - acct.unlink(ExampleToken.ReceiverPublicPath) - } + // Unlink the existing capability + signer.capabilities.unpublish(vaultData.receiverPath) // Link the new forwarding receiver capability - acct.link<&{FungibleToken.Receiver}>( - ExampleToken.ReceiverPublicPath, - target: /storage/exampleTokenForwarder - ) + let tokenReceiverCap = signer.capabilities.storage.issue<&{FungibleToken.Receiver}>( + /storage/exampleTokenForwarder + ) + signer.capabilities.publish(tokenReceiverCap, at: vaultData.receiverPath) // Link the new ForwarderPublic capability - acct.link<&{TokenForwarding.ForwarderPublic}>( - /public/exampleTokenForwarder, - target: /storage/exampleTokenForwarder - ) + let tokenForwarderCap = signer.capabilities.storage.issue<&{TokenForwarding.ForwarderPublic}>( + /storage/exampleTokenForwarder + ) + signer.capabilities.publish(tokenForwarderCap, at: /public/exampleTokenForwarder) } -} \ No newline at end of file +} diff --git a/transactions/tokenForwarder/scripts/is_recipient_valid.cdc b/transactions/tokenForwarder/scripts/is_recipient_valid.cdc new file mode 100644 index 00000000..58d7fe42 --- /dev/null +++ b/transactions/tokenForwarder/scripts/is_recipient_valid.cdc @@ -0,0 +1,8 @@ +import "TokenForwarding" + +access(all) fun main(addr: Address, tokenForwardingPath: PublicPath): Bool { + let forwarderRef = getAccount(addr) + .capabilities.borrow<&{TokenForwarding.ForwarderPublic}>(tokenForwardingPath) + + return forwarderRef.check() +} \ No newline at end of file diff --git a/transactions/transfer_many_accounts.cdc b/transactions/transfer_many_accounts.cdc index 18af72db..736540ce 100644 --- a/transactions/transfer_many_accounts.cdc +++ b/transactions/transfer_many_accounts.cdc @@ -1,17 +1,23 @@ -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" /// Transfers tokens to a list of addresses specified in the `addressAmountMap` parameter transaction(addressAmountMap: {Address: UFix64}) { - // The Vault resource that holds the tokens that are being transferred - let vaultRef: &ExampleToken.Vault + /// FTVaultData metadata view for the token being used + let vaultData: FungibleTokenMetadataViews.FTVaultData - prepare(signer: AuthAccount) { + /// The Vault resource that holds the tokens that are being transferred + let vaultRef: auth(FungibleToken.Withdraw) &ExampleToken.Vault + + prepare(signer: auth(BorrowValue) &Account) { + self.vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("ViewResolver does not resolve FTVaultData view") // Get a reference to the signer's stored vault - self.vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) + self.vaultRef = signer.storage.borrow(from: self.vaultData.storagePath) ?? panic("Could not borrow reference to the owner's Vault!") } @@ -26,8 +32,7 @@ transaction(addressAmountMap: {Address: UFix64}) { let recipient = getAccount(address) // Get a reference to the recipient's Receiver - let receiverRef = recipient.getCapability(ExampleToken.ReceiverPublicPath) - .borrow<&{FungibleToken.Receiver}>() + let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(self.vaultData.receiverPath) ?? panic("Could not borrow receiver reference to the recipient's Vault") // Deposit the withdrawn tokens in the recipient's receiver diff --git a/transactions/transfer_tokens.cdc b/transactions/transfer_tokens.cdc index 5cba8dfe..f8e3b04e 100644 --- a/transactions/transfer_tokens.cdc +++ b/transactions/transfer_tokens.cdc @@ -5,18 +5,25 @@ // The withdraw amount and the account from getAccount // would be the parameters to the transaction -import FungibleToken from "FungibleToken" -import ExampleToken from "ExampleToken" +import "FungibleToken" +import "ExampleToken" +import "FungibleTokenMetadataViews" transaction(amount: UFix64, to: Address) { + /// FTVaultData metadata view for the token being used + let vaultData: FungibleTokenMetadataViews.FTVaultData + // The Vault resource that holds the tokens that are being transferred - let sentVault: @FungibleToken.Vault + let sentVault: @{FungibleToken.Vault} + + prepare(signer: auth(BorrowValue) &Account) { - prepare(signer: AuthAccount) { + self.vaultData = ExampleToken.resolveContractView(resourceType: nil, viewType: Type()) as! FungibleTokenMetadataViews.FTVaultData? + ?? panic("ViewResolver does not resolve FTVaultData view") // Get a reference to the signer's stored vault - let vaultRef = signer.borrow<&ExampleToken.Vault>(from: ExampleToken.VaultStoragePath) + let vaultRef = signer.storage.borrow(from: self.vaultData.storagePath) ?? panic("Could not borrow reference to the owner's Vault!") // Withdraw tokens from the signer's stored vault @@ -29,8 +36,7 @@ transaction(amount: UFix64, to: Address) { let recipient = getAccount(to) // Get a reference to the recipient's Receiver - let receiverRef = recipient.getCapability(ExampleToken.ReceiverPublicPath) - .borrow<&{FungibleToken.Receiver}>() + let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(self.vaultData.receiverPath) ?? panic("Could not borrow receiver reference to the recipient's Vault") // Deposit the withdrawn tokens in the recipient's receiver