ref: CustomQuery for ExecuteContext #537

joemonem · 2024-08-12T11:28:26Z

Motivation

Closes #536

Implementation

Adjusted ExecuteContext to the following:

pub struct ExecuteContext<'a, C: CustomQuery> {
    pub deps: DepsMut<'a, C>,
    pub info: MessageInfo,
    pub env: Env,
    pub amp_ctx: Option<AMPPkt>,
}

and applied all the necessary adjustments to accommodate the above change

Testing

No tests were affected nor created

Version Changes

std from 1.1.1 to 1.2.1

coderabbitai · 2024-08-12T11:29:13Z

Warning

Walkthrough skipped

File diffs could not be summarized.

Thank you for using CodeRabbit. We offer it for free to the OSS community and would appreciate your support in helping us grow. If you find it useful, would you consider giving us a shout-out on your favorite social media?

Share

Tips

Chat

There are 3 ways to chat with CodeRabbit:

Review comments: Directly reply to a review comment made by CodeRabbit. Example:
- I pushed a fix in commit <commit_id>.
- Generate unit testing code for this file.
- Open a follow-up GitHub issue for this discussion.
Files and specific lines of code (under the "Files changed" tab): Tag @coderabbitai in a new review comment at the desired location with your query. Examples:
- @coderabbitai generate unit testing code for this file.
- @coderabbitai modularize this function.
PR comments: Tag @coderabbitai in a new PR comment to ask questions about the PR branch. For the best results, please provide a very specific query, as very limited context is provided in this mode. Examples:
- @coderabbitai generate interesting stats about this repository and render them as a table.
- @coderabbitai show all the console.log statements in this repository.
- @coderabbitai read src/utils.ts and generate unit testing code.
- @coderabbitai read the files in the src/scheduler package and generate a class diagram using mermaid and a README in the markdown format.
- @coderabbitai help me debug CodeRabbit configuration file.

Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments.

CodeRabbit Commands (invoked as PR comments)

@coderabbitai pause to pause the reviews on a PR.
@coderabbitai resume to resume the paused reviews.
@coderabbitai review to trigger an incremental review. This is useful when automatic reviews are disabled for the repository.
@coderabbitai full review to do a full review from scratch and review all the files again.
@coderabbitai summary to regenerate the summary of the PR.
@coderabbitai resolve resolve all the CodeRabbit review comments.
@coderabbitai configuration to show the current CodeRabbit configuration for the repository.
@coderabbitai help to get help.

Additionally, you can add @coderabbitai ignore anywhere in the PR description to prevent this PR from being reviewed.

CodeRabbit Configuration File (`.coderabbit.yaml`)

You can programmatically configure CodeRabbit by adding a .coderabbit.yaml file to the root of your repository.
Please see the configuration documentation for more information.
If your editor has YAML language server enabled, you can add the path at the top of this file to enable auto-completion and validation: # yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json

Documentation and Community

Visit our Documentation for detailed information on how to use CodeRabbit.
Join our Discord Community to get help, request features, and share feedback.
Follow us on X/Twitter for updates and announcements.

coderabbitai

Actionable comments posted: 0

Outside diff range, codebase verification and nitpick comments (3)

contracts/finance/andromeda-cross-chain-swap/src/contract.rs (1)
138-141: Ensure all handle_execute calls use the new generic type parameter.

The handle_execute function has been updated to include a generic type parameter C: CustomQuery. Ensure that all calls to this function across the codebase are updated to match the new signature with the CustomQuery type parameter.

Files with potential issues:

contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs

contracts/finance/andromeda-vesting/src/contract.rs

contracts/fungible-tokens/andromeda-cw20/src/contract.rs

contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs

These files show calls to handle_execute without the CustomQuery type parameter. Please review and update them accordingly.

Analysis chain

Enhance flexibility with generic CustomQuery.

The addition of the generic parameter C: CustomQuery to handle_execute allows it to handle a wider range of query types, enhancing flexibility and adaptability. Ensure that all usages of handle_execute are updated to pass the correct type parameter.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature with `CustomQuery`.

# Test: Search for function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
contracts/os/andromeda-kernel/src/ibc.rs (2)
181-185: Update function call to match new signature

The function ibc_register_username is called with execute_env, which does not match the updated signature using ExecuteContext<C>. Please update the function call to ensure it aligns with the new signature.

Location: contracts/os/andromeda-kernel/src/ibc.rs, line with ibc_register_username(execute_env, username, address)

Analysis chain

LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<C> in the ibc_register_username function improves adaptability. Ensure that all function calls match this new signature.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `ibc_register_username` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ibc_register_username(ExecuteContext<C>'
Length of output: 175

Script:
#!/bin/bash
# Description: Verify all function calls to `ibc_register_username` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 'ibc_register_username\(ExecuteContext<'
Length of output: 62

Script:
#!/bin/bash
# Description: Search for any occurrences of the function `ibc_register_username` in the codebase.

rg --type rust 'ibc_register_username'
Length of output: 232
166-170: Update Function Call to Match New Signature

The function ibc_create_ado is called with execute_env, but it should be updated to use ExecuteContext<C> as per the new signature.

File: contracts/os/andromeda-kernel/src/ibc.rs

Line: 166

Ensure the function call matches the updated signature for consistency and correctness.

Analysis chain

LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<C> in the ibc_create_ado function improves adaptability. Ensure that all function calls match this new signature.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `ibc_create_ado` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ibc_create_ado(ExecuteContext<C>'
Length of output: 154

Script:
#!/bin/bash
# Description: Verify all function calls to `ibc_create_ado` match the new signature.

# Test: Search for the function usage with corrected regex. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ibc_create_ado(ExecuteContext::<C>'
Length of output: 158

Script:
#!/bin/bash
# Description: Verify all function calls to `ibc_create_ado` match the new signature.

# Test: Search for the function usage with properly escaped angle brackets. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ibc_create_ado\\(ExecuteContext::<C>'
Length of output: 59

Script:
#!/bin/bash
# Description: Search for any occurrences of the function `ibc_create_ado` in the codebase.

# Test: Search for the function usage without specifying the signature.
rg --type rust -A 5 'ibc_create_ado'
Length of output: 948

Review details

Configuration used: CodeRabbit UI
Review profile: CHILL

Commits

Files that changed from the base of the PR and between 7688d03 and 3d0b1db.

Files ignored due to path filters (1)

Cargo.lock is excluded by !**/*.lock

Files selected for processing (46)

contracts/app/andromeda-app-contract/src/contract.rs (2 hunks)
contracts/app/andromeda-app-contract/src/execute.rs (6 hunks)
contracts/data-storage/andromeda-primitive/src/execute.rs (6 hunks)
contracts/ecosystem/andromeda-vault/src/contract.rs (7 hunks)
contracts/finance/andromeda-conditional-splitter/src/contract.rs (5 hunks)
contracts/finance/andromeda-cross-chain-swap/src/contract.rs (3 hunks)
contracts/finance/andromeda-cross-chain-swap/src/dex.rs (2 hunks)
contracts/finance/andromeda-rate-limiting-withdrawals/src/contract.rs (4 hunks)
contracts/finance/andromeda-splitter/src/contract.rs (5 hunks)
contracts/finance/andromeda-timelock/src/contract.rs (5 hunks)
contracts/finance/andromeda-validator-staking/src/contract.rs (6 hunks)
contracts/finance/andromeda-vesting/src/contract.rs (12 hunks)
contracts/finance/andromeda-weighted-distribution-splitter/src/contract.rs (8 hunks)
contracts/fungible-tokens/andromeda-cw20-exchange/src/contract.rs (7 hunks)
contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs (13 hunks)
contracts/fungible-tokens/andromeda-cw20/src/contract.rs (11 hunks)
contracts/fungible-tokens/andromeda-lockdrop/src/contract.rs (8 hunks)
contracts/fungible-tokens/andromeda-merkle-airdrop/src/contract.rs (5 hunks)
contracts/modules/andromeda-address-list/src/contract.rs (4 hunks)
contracts/modules/andromeda-rates/src/contract.rs (3 hunks)
contracts/modules/andromeda-shunting/src/contract.rs (3 hunks)
contracts/non-fungible-tokens/andromeda-auction/src/contract.rs (14 hunks)
contracts/non-fungible-tokens/andromeda-crowdfund/src/contract.rs (14 hunks)
contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs (9 hunks)
contracts/non-fungible-tokens/andromeda-marketplace/src/contract.rs (11 hunks)
contracts/os/andromeda-kernel/src/execute.rs (14 hunks)
contracts/os/andromeda-kernel/src/ibc.rs (5 hunks)
packages/andromeda-app/src/app.rs (3 hunks)
packages/andromeda-finance/src/conditional_splitter.rs (3 hunks)
packages/andromeda-finance/src/splitter.rs (2 hunks)
packages/andromeda-finance/src/validator_staking.rs (2 hunks)
packages/std/Cargo.toml (1 hunks)
packages/std/src/ado_base/rates.rs (3 hunks)
packages/std/src/ado_contract/app.rs (2 hunks)
packages/std/src/ado_contract/execute.rs (8 hunks)
packages/std/src/ado_contract/ownership.rs (5 hunks)
packages/std/src/ado_contract/permissioning.rs (10 hunks)
packages/std/src/ado_contract/rates.rs (4 hunks)
packages/std/src/amp/addresses.rs (4 hunks)
packages/std/src/amp/messages.rs (2 hunks)
packages/std/src/amp/recipient.rs (5 hunks)
packages/std/src/common/actions.rs (1 hunks)
packages/std/src/common/context.rs (1 hunks)
packages/std/src/common/denom.rs (5 hunks)
packages/std/src/os/aos_querier.rs (10 hunks)
packages/std/src/os/vfs.rs (3 hunks)

Files skipped from review due to trivial changes (1)

packages/std/Cargo.toml

Additional context used

Learnings (2)

contracts/fungible-tokens/andromeda-merkle-airdrop/src/contract.rs (1)

Learnt from: cowboy0015
PR: andromedaprotocol/andromeda-core#466
File: contracts/non-fungible-tokens/andromeda-crowdfund/src/contract.rs:0-0
Timestamp: 2024-05-20T19:05:20.474Z
Learning: The `execute_claim` function in the Andromeda Crowdfund project has been refactored into `handle_successful_claim` and `handle_failed_claim` sub-functions to improve clarity and maintainability.

contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs (1)

Learnt from: cowboy0015
PR: andromedaprotocol/andromeda-core#466
File: contracts/non-fungible-tokens/andromeda-crowdfund/src/contract.rs:0-0
Timestamp: 2024-05-20T19:05:20.474Z
Learning: The `execute_claim` function in the Andromeda Crowdfund project has been refactored into `handle_successful_claim` and `handle_failed_claim` sub-functions to improve clarity and maintainability.

Additional comments not posted (239)

packages/std/src/common/actions.rs (2)

6-6: Ensure all necessary imports are included.

The addition of CustomQuery to the import statement is correct and necessary for the updated function signature.

8-9: Review the use of generic type C in call_action.

The introduction of the generic type parameter C: CustomQuery in the function signature is a positive change, enhancing the flexibility of the function. Ensure that all usages of deps within the function correctly handle the generic type.

packages/std/src/common/context.rs (3)

2-2: Ensure all necessary imports are included.

The addition of CustomQuery to the import statement is correct and necessary for the updated struct and method signatures.

4-5: Review the use of generic type C in ExecuteContext.

The introduction of the generic type parameter C: CustomQuery in the struct definition is a positive change, enhancing the flexibility of the ExecuteContext. Ensure that all fields and methods correctly handle the generic type.

11-13: Review the new method for ExecuteContext.

The new method correctly reflects the updated struct definition by accepting DepsMut<C>. This change maintains type safety and allows for various custom query implementations.

packages/std/src/ado_contract/app.rs (2)

2-2: Ensure all necessary imports are included.

The addition of CustomQuery to the import statement is correct and necessary for the updated function signature.

20-22: Review the use of generic type C in execute_update_app_contract.

The introduction of the generic type parameter C: CustomQuery in the function signature is a positive change, enhancing the flexibility of the function. Ensure that all usages of deps within the function correctly handle the generic type.

packages/andromeda-finance/src/validator_staking.rs (1)

53-56: Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the is_validator function enhances its flexibility by allowing different query implementations. This aligns well with the PR objectives to support custom ADOs.

contracts/finance/andromeda-cross-chain-swap/src/dex.rs (1)

Line range hint 31-37:
Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the execute_swap_osmo function improves its flexibility by allowing different query implementations. This change aligns with the PR objectives to support custom ADOs and enhances the function's adaptability.

packages/std/src/common/denom.rs (4)

Line range hint 28-61:
Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the get_verified_asset method enhances its flexibility by allowing different query implementations. This change aligns with the PR objectives to support custom ADOs and improves the method's adaptability.

Line range hint 62-85:
Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the transfer method enhances its flexibility by allowing different query implementations. This change aligns with the PR objectives to support custom ADOs and improves the method's adaptability.

87-92: Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the burn method enhances its flexibility by allowing different query implementations. This change aligns with the PR objectives to support custom ADOs and improves the method's adaptability.

Line range hint 106-114:
Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to the validate_denom function enhances its flexibility by allowing different query implementations. This change aligns with the PR objectives to support custom ADOs and improves the function's adaptability.

packages/andromeda-finance/src/splitter.rs (2)

10-10: Import of CustomQuery is appropriate.

The import of CustomQuery is necessary for the generic type parameter in validate_recipient_list.

82-83: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows validate_recipient_list to handle different query types, improving flexibility.

contracts/data-storage/andromeda-primitive/src/execute.rs (5)

19-21: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows handle_execute to operate with custom query types, improving flexibility.

51-52: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows update_restriction to operate with custom query types, improving flexibility.

67-68: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows set_value to operate with custom query types, improving flexibility.

114-115: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows delete_value to operate with custom query types, improving flexibility.

134-135: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows tax_set_value to operate with custom query types, improving flexibility.

contracts/modules/andromeda-address-list/src/contract.rs (3)

78-80: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows handle_execute to operate with custom query types, improving flexibility.

91-92: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows execute_add_actor_permission to operate with custom query types, improving flexibility.

115-116: Function signature update enhances flexibility.

The addition of the generic type parameter C: CustomQuery allows execute_remove_actor_permission to operate with custom query types, improving flexibility.
contracts/modules/andromeda-shunting/src/contract.rs (2)
85-88: Improved adaptability with generic CustomQuery.

The execute_update_expression function now accepts a generic CustomQuery, which increases its adaptability for different query contexts. This change aligns with the PR objectives.

73-76: Enhance flexibility with generic CustomQuery.

The addition of the generic parameter C: CustomQuery to handle_execute allows it to handle a wider range of query types, enhancing flexibility and adaptability. Ensure that all usages of handle_execute are updated to pass the correct type parameter.

Verification successful

Consistent Usage of handle_execute with CustomQuery Generic Parameter

The handle_execute function has been consistently updated across the codebase to include the C: CustomQuery generic parameter. All usages reflect the new signature, ensuring flexibility and adaptability without any discrepancies.

The function is correctly used with the new signature in multiple modules, confirming the update has been thoroughly implemented.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature with `CustomQuery`.

# Test: Search for function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
contracts/modules/andromeda-rates/src/contract.rs (3)
87-91: Improved adaptability with generic CustomQuery.

The execute_set_rate function now accepts a generic CustomQuery, which increases its adaptability for different query contexts. This change aligns with the PR objectives.

112-115: Improved adaptability with generic CustomQuery.

The execute_remove_rate function now accepts a generic CustomQuery, which increases its adaptability for different query contexts. This change aligns with the PR objectives.

76-79: Enhance flexibility with generic CustomQuery.

The addition of the generic parameter C: CustomQuery to handle_execute allows it to handle a wider range of query types, enhancing flexibility and adaptability. Ensure that all usages of handle_execute are updated to pass the correct type parameter.

Verification successful

All usages of handle_execute have been updated to use the new generic CustomQuery.

The function handle_execute has been successfully updated across the codebase to include the generic parameter C: CustomQuery, ensuring enhanced flexibility and adaptability. The changes are consistent in various files, confirming that the new signature is being used correctly.

Instances of handle_execute with the new signature were found in multiple files, including andromeda-vault, andromeda-crowdfund, andromeda-marketplace, and others.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature with `CustomQuery`.

# Test: Search for function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
contracts/finance/andromeda-cross-chain-swap/src/contract.rs (1)

Line range hint 171-178: Improved adaptability with generic CustomQuery.

The execute_swap_and_forward function now accepts a generic CustomQuery, which increases its adaptability for different query contexts. This change aligns with the PR objectives.
contracts/app/andromeda-app-contract/src/contract.rs (2)
16-17: Ensure all necessary imports are included.

The addition of CustomQuery in the import statements aligns with the changes made to the handle_execute function. Ensure that all necessary traits and types are imported and used correctly throughout the file.

184-187: Verify the impact of the generic CustomQuery parameter.

The handle_execute function now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this function pass the correct type for C and that this change does not introduce any breaking changes in the contract's logic.

Verification successful

No Breaking Changes Detected with CustomQuery Parameter

The introduction of the generic CustomQuery parameter in the handle_execute function does not appear to introduce any breaking changes. The types used for C in ExecuteContext across various modules are consistent and likely compatible with the CustomQuery trait. If there were any type mismatches, they would have resulted in compilation errors.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311

Script:
#!/bin/bash
# Description: Gather context around each `handle_execute` invocation to identify the types passed for `C`.

# Search for `handle_execute` invocations and capture surrounding lines to identify the type used for `C`.
rg --type rust -A 10 -B 5 'handle_execute'
Length of output: 47267
packages/std/src/ado_base/rates.rs (3)
9-9: Ensure all necessary imports are included.

The addition of CustomQuery in the import statements aligns with the changes made to the methods. Ensure that all necessary traits and types are imported and used correctly throughout the file.

171-171: Verify the impact of the generic CustomQuery parameter in validate_rate.

The validate_rate method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.

115-117: Verify the impact of the generic CustomQuery parameter in generate_response.

The generate_response method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.

Verification successful

Generic CustomQuery Parameter in generate_response is Compatible

The generate_response method's use of a generic CustomQuery parameter aligns with existing function definitions that already incorporate this generic type. Therefore, this change does not introduce any breaking changes. The invocations of generate_response pass the correct type for C.

Functions like execute_rates, execute_set_rates, and query_deducted_funds already use Deps<C> with C: CustomQuery.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all method calls to `generate_response` match the new signature.

# Test: Search for the method usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'generate_response'
Length of output: 1461

Script:
#!/bin/bash
# Description: Check the type of `deps` at the call sites of `generate_response`.

# Find where `deps` is defined in the file where `generate_response` is called.
rg --type rust -A 10 'let deps' packages/std/src/ado_contract/rates.rs
Length of output: 72

Script:
#!/bin/bash
# Description: Search for function definitions in the file to locate `deps` parameter.

# Find all function definitions in the file to locate where `deps` might be passed.
rg --type rust 'fn ' packages/std/src/ado_contract/rates.rs -A 2
Length of output: 1029
packages/std/src/ado_contract/rates.rs (5)
6-6: Ensure all necessary imports are included.

The addition of CustomQuery in the import statements aligns with the changes made to the methods. Ensure that all necessary traits and types are imported and used correctly throughout the file.

38-40: Verify the impact of the generic CustomQuery parameter in execute_set_rates.

The execute_set_rates method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.

Verification successful

No Breaking Changes from Generic CustomQuery Parameter

The addition of the generic CustomQuery parameter in the execute_set_rates method does not introduce any breaking changes. The method is only invoked within rates.rs, and no other parts of the codebase are affected.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all method calls to `execute_set_rates` match the new signature.

# Test: Search for the method usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_set_rates'
Length of output: 828

Script:
#!/bin/bash
# Search for all invocations of the `execute_set_rates` method across the codebase.
rg --type rust 'execute_set_rates'
Length of output: 255
76-78: Verify the impact of the generic CustomQuery parameter in execute_remove_rates.

The execute_remove_rates method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.

119-121: Verify the impact of the generic CustomQuery parameter in query_deducted_funds.

The query_deducted_funds method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.

28-30: Verify the impact of the generic CustomQuery parameter in execute_rates.

The execute_rates method now accepts a generic type parameter C: CustomQuery. Verify that all invocations of this method pass the correct type for C and that this change does not introduce any breaking changes in its logic.
contracts/finance/andromeda-timelock/src/contract.rs (4)
99-103: Review Usage of CustomQuery in execute_hold_funds.

The function execute_hold_funds now takes a generic ExecuteContext<C>. Ensure that this change does not affect the function's logic, especially concerning the deps usage.

142-146: Verify Consistency in execute_release_funds.

The execute_release_funds function has been updated similarly with the generic ExecuteContext<C>. Verify that all logic, particularly around deps, remains consistent and unaffected by this change.

177-181: Check for Logical Consistency in execute_release_specific_funds.

The introduction of C: CustomQuery in execute_release_specific_funds should be checked for any impact on the existing logic, ensuring that deps and other context elements are handled correctly.

65-68: Ensure Compatibility with New Generic Type.

The handle_execute function now accepts a generic type C: CustomQuery. Ensure that all usages of ExecuteContext are compatible with this new generic parameter throughout the codebase.

Verification successful

Generic Type Compatibility Verified

The handle_execute function's new generic type C: CustomQuery has been consistently applied across the codebase, ensuring compatibility with all usages of ExecuteContext<C>. No issues were found with the integration of this change.

The function signature update is consistently reflected in multiple files.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all usages of `handle_execute` are compatible with the new generic type.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
contracts/finance/andromeda-rate-limiting-withdrawals/src/contract.rs (3)

90-93: Ensure Correctness with CustomQuery in handle_execute.

The handle_execute function now includes a generic C: CustomQuery. Ensure that this change is correctly propagated throughout the function and that all related logic remains intact.

113-115: Verify CustomQuery Integration in execute_deposit.

The execute_deposit function now uses ExecuteContext<C>, which should be checked for any impact on the function's logic, particularly around deps.

170-173: Check CustomQuery Impact in execute_withdraw.

The execute_withdraw function's signature now includes C: CustomQuery. Verify that the function logic, especially regarding deps and withdrawal conditions, remains consistent.

contracts/app/andromeda-app-contract/src/execute.rs (6)

17-20: Verify CustomQuery Compatibility in handle_add_app_component.

The function handle_add_app_component now uses ExecuteContext<C>. Ensure that this change is compatible with the function's logic, particularly around component handling.

110-113: Check CustomQuery Integration in claim_ownership.

The claim_ownership function has been updated to include C: CustomQuery. Verify that the function logic, especially regarding ownership checks, remains consistent.

150-154: Review CustomQuery Usage in message.

The message function now accepts ExecuteContext<C>. Ensure that this change does not affect the function's logic, particularly concerning message handling.

188-191: Ensure Correctness in update_address with CustomQuery.

The update_address function now takes a generic ExecuteContext<C>. Verify that all logic, particularly around address validation and updates, remains consistent.

224-227: Verify CustomQuery Impact in register_component_path.

The function register_component_path now uses QuerierWrapper<C>. Ensure that this change is correctly integrated and does not affect the function's logic.

249-251: Check Consistency in assign_app_to_components.

The assign_app_to_components function's signature now includes C: CustomQuery. Verify that the function logic, especially regarding component assignment, remains consistent.
packages/std/src/os/aos_querier.rs (11)
Line range hint 37-44: Enhance flexibility with generic CustomQuery.

The query_storage function now accepts a QuerierWrapper<C> with a generic CustomQuery, allowing for more flexible query types. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of query_storage match the new signature.

The function query_storage has been updated to use a generic CustomQuery, and all instances in the file aos_querier.rs correctly reflect this change. No further updates are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `query_storage` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'query_storage'
Length of output: 5190
Line range hint 66-73: Enhance flexibility with generic CustomQuery.

The ado_type_getter_smart function has been updated to accept a generic CustomQuery, allowing for more versatile querying. Ensure that all instances of this function are updated in the codebase.

Verification successful

All instances of ado_type_getter_smart are updated correctly.

The function ado_type_getter_smart is used with the new generic CustomQuery signature in all instances found in the codebase. No further updates are necessary.

Verified function call in packages/std/src/ado_base/rates.rs.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `ado_type_getter_smart` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ado_type_getter_smart'
Length of output: 937
Line range hint 149-156: Enhance flexibility with generic CustomQuery.

The kernel_address_getter function now supports a generic CustomQuery, improving its adaptability. Verify that all function calls are updated to match the new signature.

Verification successful

All calls to kernel_address_getter match the new signature. The function is consistently invoked with a QuerierWrapper<C> where C: CustomQuery, confirming the update across the codebase.

Files and Lines:

packages/std/src/os/aos_querier.rs: Verified within the same file.

packages/std/src/ado_contract/execute.rs: Verified usage.

contracts/finance/andromeda-cross-chain-swap/src/dex.rs: Verified usage.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `kernel_address_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'kernel_address_getter'
Length of output: 2408
Line range hint 178-185: Enhance flexibility with generic CustomQuery.

The ado_owner_getter function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of ado_owner_getter match the new signature. The function calls in the following files correctly implement the generic CustomQuery:

packages/std/src/ado_contract/execute.rs

contracts/os/andromeda-kernel/src/reply.rs

contracts/app/andromeda-app-contract/src/execute.rs

No further action is needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `ado_owner_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ado_owner_getter'
Length of output: 2272
133-136: Enhance flexibility with generic CustomQuery.

The vfs_address_getter function now uses a generic CustomQuery, allowing for more versatile querying. Verify that all instances of this function are updated in the codebase.

Verification successful

All instances of vfs_address_getter are updated correctly.

The function vfs_address_getter is used with the updated generic CustomQuery signature in all identified instances within the codebase. No further updates are needed.

Located in packages/std/src/ado_contract/execute.rs

Located in contracts/app/andromeda-app-contract/src/execute.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `vfs_address_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'vfs_address_getter'
Length of output: 1441
Line range hint 120-127: Enhance flexibility with generic CustomQuery.

The code_id_getter function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of code_id_getter are correctly updated to match the new signature.

The function code_id_getter with the generic CustomQuery is used correctly in the following files:

packages/andromeda-app/src/app.rs

contracts/os/andromeda-kernel/src/execute.rs

No further action is required.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `code_id_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'code_id_getter'
Length of output: 2576
Line range hint 56-63: Enhance flexibility with generic CustomQuery.

The ado_type_getter function now uses a generic CustomQuery, enhancing its flexibility. Verify that all calls to this function are updated to match the new signature.

Verification successful

All calls to ado_type_getter match the new signature with generic CustomQuery. The function is consistently used with &deps.querier as the first argument across various files, confirming the update has been applied correctly.

contracts/os/andromeda-kernel/src/execute.rs

contracts/os/andromeda-vfs/src/execute.rs

contracts/os/andromeda-kernel/src/query.rs

contracts/os/andromeda-economics/src/execute.rs

packages/std/src/ado_contract/execute.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `ado_type_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'ado_type_getter'
Length of output: 4024
141-144: Enhance flexibility with generic CustomQuery.

The adodb_address_getter function has been updated to accept a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of adodb_address_getter are updated to match the new signature.

The usage of the adodb_address_getter function in packages/std/src/ado_contract/execute.rs is consistent with the updated signature that includes the generic CustomQuery. No further changes are needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `adodb_address_getter` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'adodb_address_getter'
Length of output: 1010

Script:
#!/bin/bash
# Check the context of the usage in `packages/std/src/ado_contract/execute.rs` to ensure it matches the new function signature with the generic `CustomQuery`.
rg --type rust -A 10 'AOSQuerier::adodb_address_getter' packages/std/src/ado_contract/execute.rs
Length of output: 561
Line range hint 233-240: Enhance flexibility with generic CustomQuery.

The get_rate function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of get_rate match the new signature. The calls to get_rate in packages/std/src/ado_contract/rates.rs use &deps.querier, which is compatible with the updated function signature. No further changes are needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `get_rate` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'get_rate'
Length of output: 4406

Script:
#!/bin/bash
# Extract and examine the context around the `get_rate` calls in `packages/std/src/ado_contract/rates.rs`
rg --type rust -A 10 -B 2 'get_rate' packages/std/src/ado_contract/rates.rs
Length of output: 1500
Line range hint 217-224: Enhance flexibility with generic CustomQuery.

The get_permission function now uses a generic CustomQuery, allowing for more versatile querying. Verify that all instances of this function are updated in the codebase.

Verification successful

All instances of get_permission have been updated to use the new generic CustomQuery signature. The calls to AOSQuerier::get_permission in packages/std/src/ado_contract/permissioning.rs correctly utilize the updated signature with QuerierWrapper<C>.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `get_permission` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'get_permission'
Length of output: 3276

Script:
#!/bin/bash
# Extract lines around the function calls to `get_permission` to verify if they match the new signature.
rg --type rust -A 3 -B 2 'get_permission' packages/std/src/ado_contract/permissioning.rs
Length of output: 1420
Line range hint 91-98: Enhance flexibility with generic CustomQuery.

The verify_code_id function now supports a generic CustomQuery, improving its adaptability. Verify that all function calls are updated to match the new signature.

Verification successful

All verify_code_id function calls match the new signature.

The usage of verify_code_id in packages/std/src/amp/messages.rs is consistent with the updated function signature, ensuring compatibility with the generic CustomQuery. No discrepancies found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `verify_code_id` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'verify_code_id'
Length of output: 926

Script:
#!/bin/bash
# Extract more context around the usage of `verify_code_id` in `packages/std/src/amp/messages.rs`
rg 'verify_code_id' -A 10 -B 5 packages/std/src/amp/messages.rs
Length of output: 624
contracts/finance/andromeda-conditional-splitter/src/contract.rs (4)
107-110: Enhance flexibility with generic CustomQuery.

The handle_execute function now accepts a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of handle_execute are updated to match the new signature.

The function handle_execute with the generic CustomQuery parameter is consistently used across the codebase, confirming that all necessary updates have been made. No further action is needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
245-248: Enhance flexibility with generic CustomQuery.

The execute_update_lock function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of execute_update_lock match the new signature. The function is consistently called with the updated parameters ctx and lock_time across the codebase. No outdated usages were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_update_lock` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_update_lock'
Length of output: 8127
130-132: Enhance flexibility with generic CustomQuery.

The execute_send function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

208-211: Enhance flexibility with generic CustomQuery.

The execute_update_thresholds function now supports a generic CustomQuery, improving its adaptability. Verify that all function calls are updated to match the new signature.

Verification successful

All function calls to execute_update_thresholds are updated.

The function execute_update_thresholds in contract.rs is called with the correct new signature. No other calls are visible in the codebase, ensuring consistency with the updated generic CustomQuery.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_update_thresholds` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_update_thresholds'
Length of output: 1959

Script:
#!/bin/bash
# Description: Search for all calls to `execute_update_thresholds` in the codebase to ensure they match the new signature.

# Test: Search for the function usage in all Rust files. Expect: Only occurrences of the new signature.
rg --type rust 'execute_update_thresholds\(' -A 3
Length of output: 1033
packages/std/src/ado_contract/ownership.rs (5)
Line range hint 35-47: Enhance flexibility with generic CustomQuery.

The update_owner function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of update_owner updated to match new signature. The function update_owner with the generic CustomQuery parameter is consistently used within packages/std/src/ado_contract/ownership.rs. No outdated usages were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `update_owner` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'update_owner'
Length of output: 3314
Line range hint 83-93: Enhance flexibility with generic CustomQuery.

The accept_ownership function now includes a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Line range hint 16-25: Enhance flexibility with generic CustomQuery.

The execute_ownership function now accepts a generic CustomQuery, enhancing its flexibility. Ensure that all usages of this function in the codebase are updated to match the new signature.

Verification successful

All usages of execute_ownership are consistent with the new signature.

The function execute_ownership is correctly called with the updated signature across the codebase. No further action is required.

Verified in:

contracts/os/andromeda-economics/src/contract.rs

contracts/os/andromeda-vfs/src/contract.rs

contracts/os/andromeda-adodb/src/contract.rs

contracts/os/andromeda-kernel/src/contract.rs

packages/std/src/ado_contract/execute.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_ownership` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_ownership'
Length of output: 2883
Line range hint 68-74: Enhance flexibility with generic CustomQuery.

The revoke_ownership_offer function now supports a generic CustomQuery, improving its adaptability. Verify that all function calls are updated to match the new signature.

Verification successful

All function calls to revoke_ownership_offer are updated correctly. The search confirms that the function is invoked with the new generic CustomQuery signature wherever used. No additional updates are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `revoke_ownership_offer` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'revoke_ownership_offer'
Length of output: 2426

Script:
#!/bin/bash
# Description: Search for all usages of `OwnershipMessage::RevokeOwnershipOffer` to verify correct function invocation.

# Test: Locate all instances where `OwnershipMessage::RevokeOwnershipOffer` is used.
rg --type rust 'OwnershipMessage::RevokeOwnershipOffer'
Length of output: 193
109-115: Enhance flexibility with generic CustomQuery.

The disown function now uses a generic CustomQuery, allowing for more versatile querying. Verify that all instances of this function are updated in the codebase.

Verification successful

All instances of disown use the updated signature with CustomQuery.

The disown function is only used within the ownership.rs file, and all instances match the new signature. No other occurrences were found in the codebase.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `disown` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'disown'
Length of output: 2328

Script:
#!/bin/bash
# Description: Search for any additional occurrences of the `disown` function outside the `ownership.rs` file.

# Test: Search for the function usage across the entire codebase.
rg --type rust -A 5 $'disown' --glob '!packages/std/src/ado_contract/ownership.rs'
Length of output: 81
contracts/finance/andromeda-splitter/src/contract.rs (4)

111-114: Generic parameter addition is appropriate.

The inclusion of a generic parameter C: CustomQuery in the handle_execute function enhances flexibility and aligns with the PR objectives. The core logic remains unchanged.

134-134: Generic parameter addition is appropriate.

The addition of C: CustomQuery to the execute_send function enhances flexibility while preserving existing functionality. This change aligns with the PR's goals.

216-217: Generic parameter addition is appropriate.

The inclusion of C: CustomQuery in the execute_update_recipients function aligns with the goal of supporting diverse query types, without altering the existing logic.

252-253: Generic parameter addition is appropriate.

The addition of C: CustomQuery to the execute_update_lock function supports the goal of accommodating various query types, maintaining the existing logic.

packages/std/src/amp/recipient.rs (4)

33-33: Generic parameter addition is appropriate.

The inclusion of C: CustomQuery in the validate method enhances flexibility in query handling, consistent with the PR's goals.

64-66: Generic parameter addition is appropriate.

The addition of C: CustomQuery to the generate_direct_msg method supports diverse query types while preserving existing functionality.

87-89: Generic parameter addition is appropriate.

The inclusion of C: CustomQuery in the generate_msg_cw20 method aligns with the goal of accommodating various query types, maintaining the existing logic.

117-119: Generic parameter addition is appropriate.

The addition of C: CustomQuery to the generate_amp_msg method enhances flexibility while preserving existing functionality.

packages/andromeda-app/src/app.rs (2)

127-131: Generic parameter addition is appropriate.

The inclusion of C: CustomQuery in the get_new_addr method enhances flexibility in query handling, consistent with the PR's goals.

246-248: Generic parameter addition is appropriate.

The addition of C: CustomQuery to the generate_instantiation_message method supports diverse query types while preserving existing functionality.

contracts/finance/andromeda-validator-staking/src/contract.rs (5)

79-82: Generic CustomQuery type parameter added to handle_execute.

The addition of the generic CustomQuery type parameter enhances flexibility and aligns with the PR objectives.

113-116: Generic CustomQuery type parameter added to execute_stake.

The change enhances the function's flexibility without altering its logic.

150-153: Generic CustomQuery type parameter added to execute_unstake.

The change aligns with the PR objectives and maintains the function's existing logic.

208-211: Generic CustomQuery type parameter added to execute_claim.

The change enhances flexibility while preserving the function's logic.

266-268: Generic CustomQuery type parameter added to execute_withdraw_fund.

The change aligns with the PR objectives and maintains the function's existing logic.

contracts/fungible-tokens/andromeda-merkle-airdrop/src/contract.rs (4)

108-111: Generic CustomQuery type parameter added to handle_execute.

The addition of the generic CustomQuery type parameter enhances flexibility and aligns with the PR objectives.

Line range hint 139-144: Generic CustomQuery type parameter added to execute_register_merkle_root.

The change enhances the function's flexibility without altering its logic.

184-188: Generic CustomQuery type parameter added to execute_claim.

The change aligns with the PR objectives and maintains the function's existing logic.

258-261: Generic CustomQuery type parameter added to execute_burn.

The change enhances flexibility while preserving the function's logic.

packages/andromeda-finance/src/conditional_splitter.rs (2)

60-62: Generic CustomQuery type parameter added to validate.

The addition of the generic CustomQuery type parameter enhances flexibility and aligns with the PR objectives.

109-112: Generic CustomQuery type parameter added to validate_thresholds.

The change enhances the function's flexibility without altering its logic.
contracts/fungible-tokens/andromeda-cw20/src/contract.rs (9)
Line range hint 131-135: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the execute_transfer_from function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Line range hint 141-148: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the handle_transfer function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Verification successful

Function Usage Verified: The handle_transfer function is used correctly with the new ExecuteContext<Empty> signature in the codebase. The calls in contract.rs match the updated function signature.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_transfer` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_transfer(ExecuteContext<Empty>'
Length of output: 165

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_transfer` match the new signature.

# Corrected Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_transfer\\(ExecuteContext<Empty>'
Length of output: 62

Script:
#!/bin/bash
# Description: Search for all occurrences of `handle_transfer` to verify usage.

# Search for all instances of `handle_transfer`.
rg --type rust 'handle_transfer'
Length of output: 359
Line range hint 250-255: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the execute_send function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Line range hint 260-266: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the execute_send_from function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Verification successful

Function Usage Verified: The execute_send_from function is used correctly with the new ExecuteContext<Empty> signature in the codebase. The mock implementation in mock.rs does not affect this verification.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_send_from` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_send_from(ExecuteContext<Empty>'
Length of output: 171

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_send_from` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_send_from\\(ExecuteContext<Empty>'
Length of output: 64

Script:
#!/bin/bash
# Description: Search for all occurrences of the `execute_send_from` function to verify its usage and signature.

# Test: Search for the function usage in the entire codebase.
rg --type rust 'execute_send_from' -A 5
Length of output: 1696
Line range hint 122-126: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the execute_transfer function is consistent with the PR objectives. Ensure that all function calls match this new signature.

70-73: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the handle_execute function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Line range hint 55-62: LGTM! Verify the function usage in the codebase.

The change to DepsMut<Empty> in the execute function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Line range hint 236-240: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the execute_burn function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Verification successful

Function Usage Verified: execute_burn Signature is Consistent

The execute_burn function in contracts/fungible-tokens/andromeda-cw20/src/contract.rs is correctly used with the new signature ExecuteContext<Empty>. No discrepancies found in its usage across the codebase.

File: contracts/fungible-tokens/andromeda-cw20/src/contract.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_burn` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_burn(ExecuteContext<Empty>'
Length of output: 156

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_burn` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_burn(ExecuteContext<Empty>)'
Length of output: 59

Script:
#!/bin/bash
# Description: Search for all occurrences of `execute_burn` in the codebase.

# Test: Find all instances of `execute_burn` function calls.
rg --type rust -A 5 'execute_burn('
Length of output: 114

Script:
#!/bin/bash
# Description: Search for all occurrences of `execute_burn` in the codebase.

# Test: Find all instances of `execute_burn` function calls.
rg --type rust -A 5 'execute_burn\('
Length of output: 3091
Line range hint 271-279: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<Empty> in the handle_send function is consistent with the PR objectives. Ensure that all function calls match this new signature.

Verification successful

Function Usage Verified: handle_send Calls Match New Signature

The function handle_send is correctly used in the codebase with the updated signature ExecuteContext<Empty>. No issues were found in its usage.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_send` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_send(ExecuteContext<Empty>'
Length of output: 153

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_send` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_send\\(ExecuteContext<Empty>'
Length of output: 58

Script:
#!/bin/bash
# Description: Search for any usage of `handle_send` in the codebase to verify its calls.

# Test: Search for the function usage. Expect: Occurrences of `handle_send`.
rg --type rust -A 5 'handle_send('
Length of output: 111

Script:
#!/bin/bash
# Description: Search for any usage of `handle_send` in the codebase to verify its calls.

# Test: Search for the function usage. Expect: Occurrences of `handle_send`.
rg --type rust -A 5 'handle_send\('
Length of output: 1245
packages/std/src/ado_contract/execute.rs (9)
22-23: LGTM!

The addition of the generic parameter C in the ExecuteContextFunction type alias enhances flexibility and aligns with the PR objectives.

202-206: LGTM! Verify the function usage in the codebase.

The change to QuerierWrapper<C> in the get_vfs_address function enhances flexibility. Ensure that all function calls match this new signature.

279-283: LGTM! Verify the function usage in the codebase.

The change to DepsMut<C> in the update_kernel_address function improves extensibility. Ensure that all function calls match this new signature.

Verification successful

Function usage verified successfully.

The update_kernel_address function is called with the correct parameters matching the new signature. No further issues were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `update_kernel_address` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'update_kernel_address(DepsMut<C>'
Length of output: 161

Script:
#!/bin/bash
# Description: Verify all function calls to `update_kernel_address` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 'update_kernel_address'
Length of output: 1468
157-161: LGTM! Verify the function usage in the codebase.

The change to Deps<C> in the validate_andr_addresses function improves extensibility. Ensure that all function calls match this new signature.

Verification successful

Function usage is consistent with the new signature.

The validate_andr_addresses function is used correctly in packages/std/src/ado_contract/app.rs with the new Deps<C> signature. No further issues were found.

packages/std/src/ado_contract/app.rs: Correct usage with deps.as_ref()
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `validate_andr_addresses` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'validate_andr_addresses(Deps<C>'
Length of output: 161

Script:
#!/bin/bash
# Description: Verify all function calls to `validate_andr_addresses` match the new signature.

# Search for all occurrences of `validate_andr_addresses` to check its usage.
rg --type rust 'validate_andr_addresses' -A 5
Length of output: 1055
213-217: LGTM! Verify the function usage in the codebase.

The change to QuerierWrapper<C> in the get_adodb_address function enhances flexibility. Ensure that all function calls match this new signature.

254-258: LGTM! Verify the function usage in the codebase.

The change to QuerierWrapper<C> in the pay_fee function enhances flexibility. Ensure that all function calls match this new signature.

180-184: LGTM! Verify the function usage in the codebase.

The change to Deps<C> in the validate_andr_address function improves extensibility. Ensure that all function calls match this new signature.

Verification successful

Function usage verified successfully. The validate_andr_address function is used correctly within the codebase, matching the new signature with Deps<C>. No issues found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `validate_andr_address` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'validate_andr_address(Deps<C>'
Length of output: 155

Script:
#!/bin/bash
# Description: Verify all function calls to `validate_andr_address` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'validate_andr_address(Deps<\\w+>'
Length of output: 159

Script:
#!/bin/bash
# Description: Verify all function calls to `validate_andr_address` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'validate_andr_address\\(Deps<[^>]+>'
Length of output: 58

Script:
#!/bin/bash
# Description: Search for any usage of the `validate_andr_address` function in the codebase.

rg --type rust -A 5 'validate_andr_address'
Length of output: 1945
225-230: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<C> and ExecuteContextFunction<M, C> in the execute_amp_receive function improves adaptability. Ensure that all function calls match this new signature.

Verification successful

Verification Successful: Function Usage Matches New Signature

The execute_amp_receive function is correctly used with the new signature across the codebase. The ctx parameter is consistently initialized as ExecuteContext, ensuring compatibility with the updated function definition.

Verified in multiple contract files that ctx is of type ExecuteContext<C>.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_amp_receive` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_amp_receive(ExecuteContext<C>'
Length of output: 169

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_amp_receive`.

# Test: Search for the function usage. Expect: Occurrences of the function call.
rg --type rust -A 5 'execute_amp_receive'
Length of output: 12164

Script:
#!/bin/bash
# Description: Verify that `ctx` is of type `ExecuteContext<C>` in the files where `execute_amp_receive` is called.

# Search for the definition of `ctx` in the relevant files to ensure it matches the expected type.
rg --type rust 'let ctx' contracts/
Length of output: 3023
90-94: LGTM! Verify the function usage in the codebase.

The change to ExecuteContext<'a, C> in the execute function enhances adaptability and maintainability. Ensure that all function calls match this new signature.
contracts/os/andromeda-kernel/src/ibc.rs (2)
Line range hint 255-262: LGTM! Verify the function usage in the codebase.

The change to Deps<C> in the generate_transfer_message function improves extensibility. Ensure that all function calls match this new signature.

Verification successful

Function Signature Updated Correctly in execute.rs

The generate_transfer_message function in contracts/os/andromeda-kernel/src/execute.rs matches the new signature with Deps<C>. Other occurrences in contracts/fungible-tokens/andromeda-cw20-exchange/src/contract.rs appear to be unrelated and have different signatures. Ensure that these are intended to be different functions or contexts.

Location of updated usage: contracts/os/andromeda-kernel/src/execute.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `generate_transfer_message` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'generate_transfer_message(Deps<C>'
Length of output: 167

Script:
#!/bin/bash
# Description: Verify all function calls to `generate_transfer_message` match the new signature.

# Correct the regex error by escaping angle brackets
rg --type rust -A 5 'generate_transfer_message\('
Length of output: 2844
311-315: LGTM! Verify the function usage in the codebase.

The change to Deps<C> in the unwrap_denom_path function improves extensibility. Ensure that all function calls match this new signature.

Verification successful

Function Usage Verified

The unwrap_denom_path function is used correctly with the new Deps<C> signature in the codebase. No discrepancies were found.

Usage found in contracts/os/andromeda-kernel/src/ibc.rs matches the updated function signature.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `unwrap_denom_path` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'unwrap_denom_path(Deps<C>'
Length of output: 143

Script:
#!/bin/bash
# Description: Verify all function calls to `unwrap_denom_path` match the new signature.

# Correct the regex pattern to avoid syntax errors.
rg --type rust -A 5 'unwrap_denom_path<Deps<' 
Length of output: 47

Script:
#!/bin/bash
# Description: Find all occurrences of `unwrap_denom_path` to verify its usage.

# Search for all instances of the function call.
rg --type rust 'unwrap_denom_path' 
Length of output: 217
contracts/fungible-tokens/andromeda-cw20-exchange/src/contract.rs (6)

94-97: Enhance flexibility with CustomQuery.

The addition of the C: CustomQuery generic parameter to handle_execute increases flexibility for handling different query types. Ensure that all invocations of this function specify the appropriate CustomQuery type.

117-118: Enhance flexibility with CustomQuery.

The execute_receive function now accepts a generic ExecuteContext<C>, allowing for more versatile query handling. This change is consistent with the overall enhancement of query flexibility.

163-164: Enhance flexibility with CustomQuery.

The execute_start_sale function now supports a generic CustomQuery, aligning with the goal of accommodating various query implementations.

274-275: Enhance flexibility with CustomQuery.

The execute_purchase function's update to include a generic CustomQuery parameter is consistent with the overall design improvements for query handling.

361-362: Enhance flexibility with CustomQuery.

The execute_purchase_native function now supports a generic CustomQuery, enhancing its adaptability to different query scenarios.

384-385: Enhance flexibility with CustomQuery.

The execute_cancel_sale function's update to include a generic CustomQuery parameter aligns with the goal of improving query flexibility.

packages/std/src/amp/addresses.rs (3)

81-81: Enhance flexibility with CustomQuery.

The get_raw_address method now accepts a generic Deps<C>, allowing it to handle different query types. This change improves the method's adaptability.

96-98: Enhance flexibility with CustomQuery.

The get_raw_address_from_vfs method now supports a generic Deps<C>, aligning with the goal of handling various query implementations.

122-125: Enhance flexibility with CustomQuery.

The local_path_to_vfs_path method now accepts a QuerierWrapper<C>, enhancing its ability to interact with different query types.

contracts/finance/andromeda-weighted-distribution-splitter/src/contract.rs (7)

103-106: Enhance flexibility with CustomQuery.

The addition of the C: CustomQuery generic parameter to handle_execute increases flexibility for handling different query types. Ensure that all invocations of this function specify the appropriate CustomQuery type.

129-130: Enhance flexibility with CustomQuery.

The execute_update_recipient_weight function now supports a generic CustomQuery, aligning with the goal of accommodating various query implementations.

176-177: Enhance flexibility with CustomQuery.

The execute_add_recipient function's update to include a generic CustomQuery parameter is consistent with the overall design improvements for query handling.

234-234: Enhance flexibility with CustomQuery.

The execute_send function now supports a generic CustomQuery, enhancing its adaptability to different query scenarios.

319-320: Enhance flexibility with CustomQuery.

The execute_update_recipients function's update to include a generic CustomQuery parameter aligns with the goal of improving query flexibility.

366-367: Enhance flexibility with CustomQuery.

The execute_remove_recipient function now supports a generic CustomQuery, enhancing its ability to handle various query types.

413-416: Enhance flexibility with CustomQuery.

The execute_update_lock function's update to include a generic CustomQuery parameter is consistent with the overall design improvements for query handling.
contracts/ecosystem/andromeda-vault/src/contract.rs (6)
79-82: Ensure compatibility with the new generic type.

The handle_execute function now accepts a generic CustomQuery type. Verify that all calls to this function throughout the codebase correctly handle this new requirement.

Verification successful

All usages of handle_execute are consistent with the new generic type signature. The function handle_execute has been updated to include a generic CustomQuery type, and this change has been consistently applied throughout the codebase. No issues found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
237-241: Check withdraw_vault for correct CustomQuery handling.

The withdraw_vault function now uses DepsMut<C>. Verify that all internal logic and external interactions are compatible with the new generic type.

Verification successful

withdraw_vault function correctly handles DepsMut<C> with CustomQuery.

The withdraw_vault function's logic is compatible with the generic DepsMut<C>, as it primarily interacts with storage without requiring specific methods from CustomQuery. No issues found with the current implementation.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `withdraw_vault` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'withdraw_vault'
Length of output: 956

Script:
#!/bin/bash
# Extract the full implementation of the `withdraw_vault` function to analyze its usage of `DepsMut<C>` and `CustomQuery`.
ast-grep --lang rust --pattern $'pub fn withdraw_vault<C: CustomQuery>($_) { $$$ }'
Length of output: 84

Script:
#!/bin/bash
# Use ripgrep to search for the `withdraw_vault` function definition and include enough lines to capture its full implementation.
rg --type rust -A 30 'pub fn withdraw_vault<C: CustomQuery>'
Length of output: 2995
216-220: Verify execute_withdraw for CustomQuery integration.

The execute_withdraw function has been updated to use ExecuteContext<C>. Ensure that the function's logic and any external dependencies are compatible with this change.

Verification successful

execute_withdraw function is correctly integrated with CustomQuery. The function uses ExecuteContext<C> appropriately, ensuring compatibility with its logic and dependencies. The withdrawal logic, including strategy handling, is well-implemented. No issues found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_withdraw` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_withdraw'
Length of output: 16010

Script:
#!/bin/bash
# Description: Retrieve the implementation details of `execute_withdraw` in the specified file.
ast-grep --lang rust --pattern $'pub fn execute_withdraw<C: CustomQuery>($_) {
  $$$
}' contracts/ecosystem/andromeda-vault/src/contract.rs
Length of output: 140

Script:
#!/bin/bash
# Description: Retrieve the implementation of `execute_withdraw` in the specified file.
rg --type rust -A 50 'pub fn execute_withdraw<' contracts/ecosystem/andromeda-vault/src/contract.rs
Length of output: 1984
307-311: Ensure withdraw_strategy handles CustomQuery properly.

The withdraw_strategy function has been updated to use DepsMut<C>. Check that all logic and dependencies are correctly integrated with the new type.

Verification successful

withdraw_strategy function handles DepsMut<C> correctly.

The function implementation shows proper use of DepsMut<C> for storage operations. There is no direct handling of CustomQuery in the visible code, indicating that its integration is likely managed elsewhere or not required in this context.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `withdraw_strategy` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'withdraw_strategy'
Length of output: 1004

Script:
#!/bin/bash
# Extract the implementation of the `withdraw_strategy` function to review its handling of `DepsMut<C>`.
ast-grep --lang rust --pattern $'pub fn withdraw_strategy<C: CustomQuery>($_) {
  $$$
}'
Length of output: 89

Script:
#!/bin/bash
# Use ripgrep to search for the `withdraw_strategy` function definition and its implementation.
rg --type rust -A 20 'pub fn withdraw_strategy'
Length of output: 1894
107-110: Ensure execute_deposit handles CustomQuery correctly.

The execute_deposit function now uses ExecuteContext<C>. Ensure that the logic within the function correctly handles the generic context and that any dependencies on CustomQuery are satisfied.

Verification successful

execute_deposit Handles CustomQuery Correctly

The execute_deposit function in contracts/ecosystem/andromeda-vault/src/contract.rs correctly utilizes the CustomQuery through the ExecuteContext<C>. The function accesses deps to perform operations such as address validation, which suggests it properly handles any custom queries or dependencies. No issues were found regarding the handling of CustomQuery.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_deposit` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_deposit'
Length of output: 4276

Script:
#!/bin/bash
# Search for the implementation of `execute_deposit` in the specified file to verify how `CustomQuery` is handled.
ast-grep --lang rust --pattern 'fn execute_deposit<C: CustomQuery>($_, $_, $_) { $$$ }'
Length of output: 89

Script:
#!/bin/bash
# Use ripgrep to search for the implementation of `execute_deposit` in the specified file.
rg --type rust -A 10 'fn execute_deposit<' contracts/ecosystem/andromeda-vault/src/contract.rs
Length of output: 402

Script:
#!/bin/bash
# Extend the search to capture more lines of the `execute_deposit` function implementation.
rg --type rust -A 30 'fn execute_deposit<' contracts/ecosystem/andromeda-vault/src/contract.rs
Length of output: 1151
341-345: Verify execute_update_strategy for CustomQuery compatibility.

Ensure that the execute_update_strategy function, now using ExecuteContext<C>, correctly integrates with the generic CustomQuery type and that all dependencies are satisfied.
contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs (10)

91-94: Ensure handle_execute uses ExecuteContext<Empty> correctly.

The function now uses ExecuteContext<Empty>. Verify that the logic within the function is consistent with the new context type and that all dependencies are satisfied.

152-155: Verify execute_cw721 for correct context usage.

The function now uses ExecuteContext<Empty>. Ensure that the function's logic and any external dependencies are compatible with this change.

Line range hint 160-165: Check execute_mint for ExecuteContext<Empty> integration.

Ensure that the execute_mint function correctly integrates with the new context type and that all logic and dependencies are consistent.

Line range hint 184-189: Ensure mint handles ExecuteContext<Empty> properly.

Verify that the mint function's logic and dependencies are compatible with the new context type.

215-218: Verify execute_batch_mint for correct context usage.

The function now uses ExecuteContext<Empty>. Ensure that the logic and any external dependencies are consistent with this change.

Line range hint 256-261: Check execute_transfer for ExecuteContext<Empty> integration.

Ensure that the execute_transfer function correctly integrates with the new context type and that all logic and dependencies are consistent.

Line range hint 394-398: Ensure execute_update_transfer_agreement uses ExecuteContext<Empty> correctly.

Verify that the function's logic and dependencies are compatible with the new context type.

422-425: Check execute_archive for ExecuteContext<Empty> integration.

Ensure that the execute_archive function correctly integrates with the new context type and that all logic and dependencies are consistent.

442-444: Verify execute_burn for correct context usage.

The function now uses ExecuteContext<Empty>. Ensure that the logic and any external dependencies are consistent with this change.

Line range hint 466-471: Ensure execute_send_nft handles ExecuteContext<Empty> properly.

Verify that the function's logic and dependencies are compatible with the new context type.

packages/std/src/amp/messages.rs (1)

304-308: Ensure verify_origin handles CustomQuery correctly.

The function now uses a generic Deps<C>. Verify that the logic within the function is consistent with the new type and that all dependencies are satisfied.
contracts/finance/andromeda-vesting/src/contract.rs (11)
264-267: LGTM! Verify the function usage.

The changes to execute_claim_all are appropriate. Ensure all calls to this function are updated to use ExecuteContext<Empty>.

Verification successful

Function Usage Verified

The execute_claim_all function is correctly used with the new signature in the codebase. No issues found with its usage.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_claim_all` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_claim_all'
Length of output: 1275
Line range hint 121-126: LGTM! Verify the function usage.

The changes to execute_create_batch are appropriate. Ensure all calls to this function are updated to use ExecuteContext<Empty>.

Verification successful

Function usage verified. All calls to execute_create_batch use the updated signature with ExecuteContext<Empty>. No further issues found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_create_batch` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_create_batch'
Length of output: 1038
328-331: LGTM! Verify the function usage.

The changes to execute_delegate are appropriate. Ensure all calls to this function are updated to use DepsMut<Empty>.

Verification successful

Function Usage Verified: All calls to execute_delegate have been updated to use DepsMut<Empty>, matching the new function signature.

Calls found in contracts/finance/andromeda-vesting/src/contract.rs confirm the update.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_delegate` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_delegate'
Length of output: 1861
Line range hint 474-479: LGTM! Verify the function usage.

The changes to claim_batch are appropriate. Ensure all calls to this function are updated to use QuerierWrapper<Empty>.

Verification successful

Verification Successful: Function Usage Updated

The claim_batch function calls in contract.rs are consistent with the new signature using QuerierWrapper<Empty>. The tests in testing/tests.rs indirectly cover this function's behavior. No further updates are needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `claim_batch` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'claim_batch'
Length of output: 8597
362-365: LGTM! Verify the function usage.

The changes to execute_redelegate are appropriate. Ensure all calls to this function are updated to use the new generic CustomQuery.

Verification successful

Verification Successful: Function Usage Updated

The execute_redelegate function is correctly used with the updated generic CustomQuery signature in the codebase. No further action is needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_redelegate` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_redelegate'
Length of output: 1251
443-445: LGTM! Verify the function usage.

The changes to execute_withdraw_rewards are appropriate. Ensure all calls to this function are updated to use the new generic CustomQuery.

Verification successful

Function usage verified. The execute_withdraw_rewards function is correctly called with the new signature in the codebase. No further updates are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_withdraw_rewards` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_withdraw_rewards'
Length of output: 1076
404-407: LGTM! Verify the function usage.

The changes to execute_undelegate are appropriate. Ensure all calls to this function are updated to use the new generic CustomQuery.

Verification successful

Function Usage Verified

The usage of execute_undelegate in the codebase is consistent with the updated function signature. All calls to this function have been appropriately updated to use the new generic CustomQuery.

contracts/finance/andromeda-vesting/src/contract.rs: The call to execute_undelegate matches the new signature.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_undelegate` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_undelegate'
Length of output: 1173
79-82: LGTM! Verify the function usage.

The changes to handle_execute are appropriate. Ensure all calls to this function are updated to use ExecuteContext<Empty>.

Verification successful

Verification Complete: Consistent Usage Across Codebase

The handle_execute function in contracts/finance/andromeda-vesting/src/contract.rs is correctly using ExecuteContext<Empty>. The usage across the codebase aligns with its intended flexibility to support both specific and generic contexts. No further changes are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `handle_execute` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'handle_execute'
Length of output: 25311
221-224: LGTM! Verify the function usage.

The changes to execute_claim are appropriate. Ensure all calls to this function are updated to use ExecuteContext<Empty>.

Verification successful

Verification Successful: Function Usage Updated

The execute_claim function in contracts/finance/andromeda-vesting/src/contract.rs has been correctly updated to use ExecuteContext<Empty>. All relevant calls in this file match the new function signature. No further action is required.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_claim` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_claim'
Length of output: 25879
550-553: LGTM! Verify the function usage.

The changes to get_amount_delegated are appropriate. Ensure all calls to this function are updated to use the new generic CustomQuery.

Verification successful

Function Usage Verified

The get_amount_delegated function calls in contracts/finance/andromeda-vesting/src/contract.rs have been correctly updated to match the new generic signature. No further changes are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `get_amount_delegated` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'get_amount_delegated'
Length of output: 1624
528-531: LGTM! Verify the function usage.

The changes to execute_vote are appropriate. Ensure all calls to this function are updated to use the new generic CustomQuery.

Verification successful

Function usage verified successfully.

The execute_vote function is used with the updated generic CustomQuery signature in the codebase. No issues were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all function calls to `execute_vote` match the new signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 5 $'execute_vote'
Length of output: 1007
packages/std/src/os/vfs.rs (2)

232-235: Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to vfs_resolve_path allows for more flexible querying capabilities. The change is well-implemented and maintains the function's original logic.

248-251: Enhance flexibility with generic CustomQuery.

The addition of the generic type parameter C: CustomQuery to vfs_resolve_symlink enhances the function's adaptability to different querying contexts. The implementation is sound and retains the original functionality.

contracts/non-fungible-tokens/andromeda-crowdfund/src/contract.rs (13)

119-122: Enhance handle_execute with generic CustomQuery.

The addition of C: CustomQuery to handle_execute allows for more versatile interactions with the contract's state. This change aligns with the goal of enhancing flexibility and modularity.

154-157: Enhance execute_add_tier with generic CustomQuery.

The function now supports a generic query type, improving its adaptability to different querying needs. The change is well-implemented.

192-195: Enhance execute_update_tier with generic CustomQuery.

The use of C: CustomQuery enhances flexibility while maintaining the function's core logic. This change is consistent with the overall enhancement strategy.

230-233: Enhance execute_remove_tier with generic CustomQuery.

The function now supports a generic query type, which improves its adaptability. The change is well-executed.

Line range hint 260-269: Enhance execute_start_campaign with generic CustomQuery.

The addition of C: CustomQuery allows for more flexible interactions with the contract's state. The implementation is consistent with the PR's objectives.

323-326: Enhance execute_purchase_tiers with generic CustomQuery.

The function now supports a generic query type, enhancing its flexibility. The change is well-implemented.

351-354: Enhance handle_receive_cw20 with generic CustomQuery.

The use of C: CustomQuery allows for more adaptable querying capabilities. This change is consistent with the goal of enhancing flexibility.

367-370: Enhance execute_end_campaign with generic CustomQuery.

The function now supports a generic query type, improving its adaptability. The change is well-executed.

Line range hint 457-462: Enhance purchase_tiers with generic CustomQuery.

The addition of C: CustomQuery enhances the function's flexibility and adaptability. The implementation is consistent with the PR's objectives.

Line range hint 576-581: Enhance withdraw_to_recipient with generic CustomQuery.

The function now supports a generic query type, improving its adaptability. The change is well-implemented.

607-610: Enhance execute_claim with generic CustomQuery.

The use of C: CustomQuery allows for more flexible interactions with the contract's state. The implementation aligns with the overall enhancement strategy.

632-635: Enhance handle_successful_claim with generic CustomQuery.

The function now supports a generic query type, enhancing its flexibility. The change is well-executed.

664-667: Enhance handle_failed_claim with generic CustomQuery.

The addition of C: CustomQuery improves the function's adaptability to different querying needs. The change is well-implemented.

contracts/non-fungible-tokens/andromeda-marketplace/src/contract.rs (10)

98-101: Enhance handle_execute with generic CustomQuery.

The addition of C: CustomQuery to handle_execute allows for more versatile interactions with the contract's state. This change aligns with the goal of enhancing flexibility and modularity.

137-140: Enhance handle_receive_cw721 with generic CustomQuery.

The function now supports a generic query type, improving its adaptability. The change is well-executed.

167-170: Enhance handle_receive_cw20 with generic CustomQuery.

The use of C: CustomQuery allows for more adaptable querying capabilities. This change is consistent with the goal of enhancing flexibility.

Line range hint 208-220: Enhance execute_start_sale with generic CustomQuery.

The addition of C: CustomQuery enhances the function's flexibility and adaptability. The implementation is consistent with the PR's objectives.

Line range hint 276-282: Enhance execute_update_sale with generic CustomQuery.

The function now supports a generic query type, improving its adaptability. The change is well-executed.

325-329: Enhance execute_buy with generic CustomQuery.

The addition of C: CustomQuery allows for more flexible interactions with the contract's state. The implementation aligns with the overall enhancement strategy.

Line range hint 460-465: Enhance execute_buy_cw20 with generic CustomQuery.

The function now supports a generic query type, enhancing its flexibility. The change is well-implemented.

600-603: Enhance execute_cancel with generic CustomQuery.

The use of C: CustomQuery allows for more adaptable querying capabilities. This change is consistent with the goal of enhancing flexibility.

Line range hint 648-653: Enhance purchase_token with generic CustomQuery.

The addition of C: CustomQuery improves the function's adaptability to different querying needs. The change is well-implemented.

849-852: Enhance query_owner_of with generic CustomQuery.

The function now supports a generic query type, improving its adaptability. The change is well-executed.
contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs (12)
125-128: Ensure consistency with ExecuteContext<Empty>.

The handle_execute function now uses ExecuteContext<Empty>. Verify that this change is consistent across all function calls and that the Empty type is appropriate for all use cases within this function.

Verification successful

Consistency of ExecuteContext<Empty> Usage Verified

The usage of ExecuteContext<Empty> is consistent across the codebase, including in the file contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs. This indicates that the change aligns with the intended design and is applied appropriately. No further action is needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify consistency of `ExecuteContext<Empty>` usage across the codebase.

# Test: Search for `ExecuteContext<Empty>` usage. Expect: Consistent usage across function calls.
rg --type rust 'ExecuteContext<Empty>'
Length of output: 3011
794-794: Ensure get_staking_token supports generic CustomQuery.

The function now supports a generic C: CustomQuery. Verify that this change allows for the correct handling of staking tokens with various query types.

676-676: Check update_global_index for potential issues.

The function now uses QuerierWrapper<Empty>. Ensure that this change does not introduce any issues related to updating individual global indexes.

Verification successful

Comprehensive Test Coverage for update_global_index with QuerierWrapper<Empty>

The function update_global_index and its use of QuerierWrapper<Empty> appear to be well-tested through various scenarios, including selective updates and handling invalid assets. This suggests that the integration of QuerierWrapper<Empty> does not introduce issues.

Tests like test_update_global_indexes, test_update_global_indexes_selective, and others cover different aspects of global index updates.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `update_global_index` with `QuerierWrapper<Empty>`.

# Test: Search for `update_global_index` usage. Expect: Correct handling of individual global index updates.
rg --type rust 'update_global_index'
Length of output: 3031

Script:
#!/bin/bash
# Search for the definition of `update_global_index` to understand its implementation.
ast-grep --lang rust --pattern 'fn update_global_index($_, $_, $_, $_) { $$$ }'

# Check the tests related to `update_global_index` to ensure they cover the usage of `QuerierWrapper<Empty>`.
rg --type rust 'test_update_global_indexes|test_update_global_indexes_selective|test_update_global_indexes_invalid_asset|test_update_global_indexes_cw20_deposit' -A 10
Length of output: 5245
418-418: Validate execute_stake_tokens with DepsMut<Empty>.

The function now uses DepsMut<Empty>. Ensure that this change does not affect the staking logic, particularly in terms of token validation and state updates.

Verification successful

Staking Logic with DepsMut<Empty> Verified

The execute_stake_tokens function appropriately uses DepsMut<Empty> for accessing and updating contract state. The staking logic, including token validation and state updates, remains intact and correctly implemented. No issues found with this change.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `execute_stake_tokens` with `DepsMut<Empty>`.

# Test: Search for `execute_stake_tokens` usage. Expect: Proper handling of staking logic with `DepsMut<Empty>`.
rg --type rust 'execute_stake_tokens'
Length of output: 285

Script:
#!/bin/bash
# Description: Retrieve the implementation of `execute_stake_tokens` to verify its logic with `DepsMut<Empty>`.
ast-grep --lang rust --pattern 'fn execute_stake_tokens($_, $_, $_, $_, $_) { $$$ }'
Length of output: 86

Script:
#!/bin/bash
# Description: Search for the implementation of `execute_stake_tokens` and include surrounding lines for context.
rg --type rust 'fn execute_stake_tokens' -A 20
Length of output: 2100
276-276: Review execute_remove_reward_token for consistency.

The function now uses ExecuteContext<Empty>. Ensure that this change is consistent with the logic for removing reward tokens and does not affect the state or permissions.

Verification successful

The execute_remove_reward_token function is consistent with its intended logic. The use of ExecuteContext<Empty> does not affect the state or permissions adversely. The function correctly handles authorization, state updates, and configuration changes. No issues were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `execute_remove_reward_token` with `ExecuteContext<Empty>`.

# Test: Search for `execute_remove_reward_token` usage. Expect: Consistent logic for removing reward tokens.
rg --type rust 'execute_remove_reward_token'
Length of output: 265

Script:
#!/bin/bash
# Search for the definition and implementation of `execute_remove_reward_token` to review its logic.
rg --type rust -A 20 'fn execute_remove_reward_token' contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs
Length of output: 936

Script:
#!/bin/bash
# Continue gathering more lines from the implementation of `execute_remove_reward_token` to ensure a complete review.
rg --type rust -A 40 'fn execute_remove_reward_token' contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs
Length of output: 1564
476-476: Check execute_unstake_tokens for potential issues.

The function now uses ExecuteContext<Empty>. Ensure that this change does not introduce any issues related to unstaking tokens, particularly in terms of permissions and state updates.

Verification successful

No issues found with execute_unstake_tokens using ExecuteContext<Empty>. The function appears to handle state updates and permissions correctly by loading necessary data and updating indexes. The use of ExecuteContext<Empty> does not seem to omit any critical information needed for these operations.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `execute_unstake_tokens` with `ExecuteContext<Empty>`.

# Test: Search for `execute_unstake_tokens` usage. Expect: Correct handling of unstaking tokens.
rg --type rust 'execute_unstake_tokens'
Length of output: 281

Script:
#!/bin/bash
# Search for the implementation of `execute_unstake_tokens` to analyze its logic.
ast-grep --lang rust --pattern 'fn execute_unstake_tokens($_, $_) { $$$ }'
Length of output: 76

Script:
#!/bin/bash
# Use `rg` to search for the `execute_unstake_tokens` function definition and include context lines.
rg --type rust 'fn execute_unstake_tokens' -A 20
Length of output: 2121
543-543: Review execute_claim_rewards for consistency.

The function now uses ExecuteContext<Empty>. Ensure that this change is consistent with the logic for claiming rewards and does not affect the state or permissions.

Verification successful

The use of ExecuteContext<Empty> in execute_claim_rewards is consistent. The function correctly accesses the necessary components of the execution context and maintains the expected logic for claiming rewards without affecting state or permissions.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `execute_claim_rewards` with `ExecuteContext<Empty>`.

# Test: Search for `execute_claim_rewards` usage. Expect: Consistent logic for claiming rewards.
rg --type rust 'execute_claim_rewards'
Length of output: 560

Script:
#!/bin/bash
# Description: Retrieve the implementation details of `execute_claim_rewards` to verify the use of `ExecuteContext<Empty>`.

# Search for the implementation of `execute_claim_rewards` in the andromeda-cw20-staking contract.
ast-grep --lang rust --pattern 'fn execute_claim_rewards($_) { $$$ }'
Length of output: 71

Script:
#!/bin/bash
# Description: Retrieve the implementation details of `execute_claim_rewards` to verify the use of `ExecuteContext<Empty>`.

# Search for the implementation of `execute_claim_rewards` in the andromeda-cw20-staking contract with a refined pattern.
ast-grep --lang rust --pattern 'fn execute_claim_rewards($_) -> $_ { $$$ }'
Length of output: 9313
181-184: Verify receive_cw20 functionality with ExecuteContext<Empty>.

The receive_cw20 function has been updated to use ExecuteContext<Empty>. Ensure that this change does not affect the functionality of receiving CW20 tokens, especially in terms of permissions and context handling.

726-726: Review update_nonallocated_index for consistency.

The function now uses QuerierWrapper<Empty>. Ensure that this change is consistent with the logic for updating non-allocated indexes and does not affect the state or permissions.

Verification successful

Verified Consistency of update_nonallocated_index with QuerierWrapper<Empty>.

The function correctly uses QuerierWrapper<Empty> to query balances, ensuring the logic for updating non-allocated indexes is consistent and does not affect state or permissions adversely.

update_nonallocated_index uses QuerierWrapper<Empty> to query balances, which is integral to its logic.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `update_nonallocated_index` with `QuerierWrapper<Empty>`.

# Test: Search for `update_nonallocated_index` usage. Expect: Consistent logic for updating non-allocated indexes.
rg --type rust 'update_nonallocated_index'
Length of output: 241

Script:
#!/bin/bash
# Extract the implementation details of `update_nonallocated_index` to verify the use of `QuerierWrapper<Empty>`.
ast-grep --lang rust --pattern 'fn update_nonallocated_index($$$) {
  $$$
}'
Length of output: 78

Script:
#!/bin/bash
# Use `rg` to search for the definition of `update_nonallocated_index` and include surrounding context lines.
rg --type rust 'fn update_nonallocated_index' -A 20
Length of output: 2191
631-631: Verify update_global_indexes with QuerierWrapper<Empty>.

The function now uses QuerierWrapper<Empty>. Ensure that this change does not affect the logic for updating global indexes, particularly in terms of querying and state updates.

211-211: Check execute_add_reward_token for potential issues.

The function now uses ExecuteContext<Empty>. Ensure that this change does not introduce any issues related to reward token addition, particularly in terms of permissions and state updates.

Verification successful

No issues found with execute_add_reward_token using ExecuteContext<Empty>.

The function correctly handles permissions, state updates, and validation checks. The use of ExecuteContext<Empty> is appropriate and does not introduce any issues.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify the functionality of `execute_add_reward_token` with `ExecuteContext<Empty>`.

# Test: Search for `execute_add_reward_token` usage. Expect: Correct handling of reward token addition.
rg --type rust 'execute_add_reward_token'
Length of output: 300

Script:
#!/bin/bash
# Search for the implementation of `execute_add_reward_token` to analyze its logic.
ast-grep --lang rust --pattern 'fn execute_add_reward_token($_, $_) { $$$ }'
Length of output: 78

Script:
#!/bin/bash
# Use `rg` to search for the definition of `execute_add_reward_token` to analyze its implementation.
rg --type rust 'fn execute_add_reward_token'
Length of output: 140

Script:
#!/bin/bash
# Extract the full implementation of `execute_add_reward_token` for analysis.
rg --type rust -A 20 'fn execute_add_reward_token' contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs
Length of output: 851

Script:
#!/bin/bash
# Extract additional lines to capture the full implementation of `execute_add_reward_token`.
rg --type rust -A 40 'fn execute_add_reward_token' contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs
Length of output: 1648
327-327: Ensure execute_replace_reward_token maintains logic integrity.

The function now uses ExecuteContext<Empty>. Verify that this change maintains the integrity of the logic for replacing reward tokens, including state updates and permission checks.
contracts/fungible-tokens/andromeda-lockdrop/src/contract.rs (8)
17-18: Import CustomQuery for enhanced flexibility.

The addition of CustomQuery to the imports allows for greater flexibility in handling different query types. This change is beneficial for making the contract more adaptable.

142-143: Generic CustomQuery in receive_cw20.

The receive_cw20 function is now generic over CustomQuery, allowing it to handle different query implementations. This change should be reflected in all calls to this function.

Verification successful

All invocations of receive_cw20 match the new generic signature.

The function receive_cw20 is correctly invoked with the new generic signature across the codebase. No changes are necessary.

contracts/fungible-tokens/andromeda-lockdrop/src/contract.rs

contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `receive_cw20` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'receive_cw20<'
Length of output: 1649

Script:
#!/bin/bash
# Description: Search for all invocations of `receive_cw20` to verify they match the new generic signature.

# Test: Search for the function invocation. Expect: Occurrences of the new signature.
rg --type rust 'receive_cw20\('
Length of output: 760
350-351: Generic CustomQuery in execute_enable_claims.

The function execute_enable_claims is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

178-179: Generic CustomQuery in execute_increase_incentives.

The function execute_increase_incentives now supports a generic CustomQuery, enhancing its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

Verification successful

Generic CustomQuery in execute_increase_incentives is correctly used.

The function execute_increase_incentives is invoked in the codebase without explicit generic type parameters, indicating reliance on type inference. This suggests compatibility with the new generic signature. No issues found with its usage.

Invocation found in contracts/fungible-tokens/andromeda-lockdrop/src/contract.rs.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_increase_incentives` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_increase_incentives<'
Length of output: 436

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_increase_incentives` to verify compatibility with the new generic signature.

# Test: Search for the function usage without assuming explicit generic type parameters.
rg --type rust 'execute_increase_incentives\('
Length of output: 206
393-394: Generic CustomQuery in execute_claim_rewards.

The execute_claim_rewards function now supports a generic CustomQuery, enhancing its adaptability for different query contexts. Ensure that this change is reflected in all related code.

Verification successful

Generic CustomQuery in execute_claim_rewards is correctly implemented.

The execute_claim_rewards function in contracts/fungible-tokens/andromeda-lockdrop/src/contract.rs uses the generic CustomQuery as intended, and its invocation matches this new signature. The function in contracts/fungible-tokens/andromeda-cw20-staking/src/contract.rs is a separate implementation with a specific context, which does not conflict with the changes. No further action is required.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_claim_rewards` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_claim_rewards<'
Length of output: 452

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_claim_rewards` in the codebase.

# Test: Find all occurrences of the function call and check if they use the generic signature.
rg --type rust 'execute_claim_rewards<' -A 3
Length of output: 452

Script:
#!/bin/bash
# Description: Search for all calls to `execute_claim_rewards` in the codebase.

# Test: Find all occurrences of the function call.
rg --type rust 'execute_claim_rewards' -A 3
Length of output: 1749
274-275: Generic CustomQuery in execute_withdraw_native.

The execute_withdraw_native function now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

210-211: Generic CustomQuery in execute_deposit_native.

The function execute_deposit_native is now generic over CustomQuery, which allows for greater flexibility in handling various query types. Verify that all calls to this function are updated accordingly.

Verification successful

Generic CustomQuery in execute_deposit_native is correctly handled.

The function execute_deposit_native is invoked without explicitly specifying the generic type, which is acceptable as the Rust compiler can infer the type based on the context. No changes are needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_deposit_native` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_deposit_native<'
Length of output: 430

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_deposit_native` to verify their usage.
rg --type rust 'execute_deposit_native' --v 'pub fn' -A 3
Length of output: 463

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_deposit_native` to verify their usage.
rg --type rust 'execute_deposit_native' -v 'pub fn' -A 3
Length of output: 103

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_deposit_native` to verify their usage.
rg --type rust 'execute_deposit_native' -v '^pub fn' -A 3
Length of output: 105

Script:
#!/bin/bash
# Description: Search for all occurrences of `execute_deposit_native` to verify their usage.
rg --type rust 'execute_deposit_native' -A 3
Length of output: 964
109-112: Generic CustomQuery in handle_execute.

The function handle_execute now accepts a generic parameter C: CustomQuery, which enhances its ability to work with various query types. Ensure that all invocations of this function throughout the codebase are updated to accommodate this change.
contracts/os/andromeda-kernel/src/execute.rs (14)
16-16: Import CustomQuery for enhanced flexibility.

The addition of CustomQuery to the imports allows for greater flexibility in handling different query types. This change is beneficial for making the contract more adaptable.

261-262: Generic CustomQuery in assign_channels.

The assign_channels function is now generic over CustomQuery, which enhances its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

91-92: Generic CustomQuery in upsert_key_address.

The upsert_key_address function is now generic over CustomQuery, which enhances its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

Verification successful

Generic CustomQuery in upsert_key_address verified.

The upsert_key_address function is invoked in contracts/os/andromeda-kernel/src/contract.rs with the new generic signature. Ensure that any additional logic interacting with this function is compatible with the changes.

File: contracts/os/andromeda-kernel/src/contract.rs

Invocation: execute::upsert_key_address(execute_env, key, value)
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `upsert_key_address` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'upsert_key_address<'
Length of output: 338

Script:
#!/bin/bash
# Description: Search for all invocations of `upsert_key_address` to verify compatibility with the new generic signature.

# Test: Search for the function usage in the codebase.
rg --type rust -A 5 'upsert_key_address'
Length of output: 3246
332-333: Generic CustomQuery in update_chain_name.

The update_chain_name function is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

209-210: Generic CustomQuery in register_user_cross_chain.

The register_user_cross_chain function now supports a generic CustomQuery, enhancing its adaptability for different query contexts. Ensure that this change is reflected in all related code.

120-121: Generic CustomQuery in create.

The create function now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

407-409: Generic CustomQuery in MsgHandler::handle_local.

The handle_local method of MsgHandler is now generic over CustomQuery, which enhances its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

Verification successful

Generic CustomQuery in MsgHandler::handle_local is correctly utilized.

The handle_local method is used in multiple locations, and its generic nature over CustomQuery is being effectively leveraged. The codebase appears to be compatible with this change, and the functionality is being tested. No issues found.

Usage in contracts/os/andromeda-kernel/src/execute.rs

Tests in contracts/os/andromeda-kernel/src/testing/test_handler.rs
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `MsgHandler::handle_local` match the new generic signature.

# Test: Search for the method usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'MsgHandler::handle_local<'
Length of output: 49

Script:
#!/bin/bash
# Description: Verify all invocations of `MsgHandler::handle_local` to ensure they match the new generic signature.

# Test: Search for the method usage without specifying the generic type directly.
rg --type rust -A 3 'handle_local('
Length of output: 114

Script:
#!/bin/bash
# Description: Verify all invocations of `MsgHandler::handle_local` to ensure they match the new generic signature.

# Test: Search for the method usage with escaped parentheses.
rg --type rust -A 3 'handle_local\('
Length of output: 1535
373-375: Generic CustomQuery in MsgHandler::handle.

The handle method of MsgHandler now supports a generic CustomQuery, enhancing its ability to work with various query types. Ensure that all invocations of this method throughout the codebase are updated to accommodate this change.

505-507: Generic CustomQuery in MsgHandler::handle_ibc.

The handle_ibc method of MsgHandler now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

26-29: Generic CustomQuery in send.

The send function now supports a generic CustomQuery, enhancing its ability to work with various query types. Ensure that all invocations of this function throughout the codebase are updated to accommodate this change.

Verification successful

All invocations of send match the new generic signature.

The send function is correctly invoked with the new generic CustomQuery signature in the relevant parts of the codebase, specifically in contracts/os/andromeda-kernel/src/ibc.rs and contracts/os/andromeda-kernel/src/contract.rs. No further updates are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `send` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'send<'
Length of output: 1623

Script:
#!/bin/bash
# Description: Search for invocations of the `send` function to verify if they match the new generic signature.

# Test: Search for the function calls. Expect: All occurrences should match the new signature.
rg --type rust 'send\(' -A 2
Length of output: 12548

Script:
#!/bin/bash
# Description: Search for all possible invocations of the `send` function, considering variations in usage.

# Test: Search for the function calls with different contexts. Expect: All occurrences should match the new signature.
rg --type rust '\bsend\b' -A 2
Length of output: 13250
311-311: Generic CustomQuery in recover.

The recover function now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

Verification successful

Verification Successful: Generic CustomQuery in recover is correctly implemented.

The invocation of the recover function in contracts/os/andromeda-kernel/src/contract.rs matches the new generic signature with ExecuteContext, confirming that the change is properly reflected in the related code.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `recover` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'recover<'
Length of output: 447

Script:
#!/bin/bash
# Description: Search for all invocations of the `recover` function across the codebase.

# Test: Find all occurrences of `recover` function calls.
rg --type rust 'recover('
Length of output: 94

Script:
#!/bin/bash
# Description: Search for all invocations of the `recover` function across the codebase.

# Test: Find all occurrences of `recover` function calls.
rg --type rust 'recover\('
Length of output: 139

Script:
#!/bin/bash
# Description: Search for the definition or type of `execute_env` in the file where `recover` is invoked.

# Test: Find `execute_env` in the relevant file to verify its type.
rg --type rust 'execute_env' contracts/os/andromeda-kernel/src/contract.rs
Length of output: 742
579-581: Generic CustomQuery in MsgHandler::handle_ibc_hooks.

The handle_ibc_hooks method of MsgHandler now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

534-536: Generic CustomQuery in MsgHandler::handle_ibc_direct.

The handle_ibc_direct method of MsgHandler is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

196-197: Generic CustomQuery in internal.

The internal function is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

Verification successful

Invocation of internal is consistent with the new generic signature.

The execute_env variable is correctly typed as ExecuteContext, ensuring that the invocation of the internal function matches the updated generic signature. No inconsistencies were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `internal` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'internal<'
Length of output: 335

Script:
#!/bin/bash
# Description: Find all invocations of the `internal` function to verify consistency with the new generic signature.

# Test: Search for the function usage across the codebase.
rg --type rust 'internal<' -A 3
Length of output: 335

Script:
#!/bin/bash
# Description: Find all invocations of the `internal` function using a more general pattern to verify consistency.

# Test: Search for the function usage across the codebase.
rg --type rust 'internal\(' -A 3
Length of output: 440

Script:
#!/bin/bash
# Description: Find the definition or type of `execute_env` to verify it matches `ExecuteContext<C>`.

# Test: Search for the definition or type of `execute_env` in the relevant file.
rg --type rust 'execute_env' -A 5 contracts/os/andromeda-kernel/src/contract.rs
Length of output: 1511
packages/std/src/ado_contract/permissioning.rs (10)
9-10: Import CustomQuery for enhanced flexibility.

The addition of CustomQuery to the imports allows for greater flexibility in handling different query types. This change is beneficial for making the contract more adaptable.

288-290: Generic CustomQuery in execute_remove_permission.

The execute_remove_permission function now supports a generic CustomQuery, enhancing its adaptability for different query contexts. Ensure that this change is reflected in all related code.

Verification successful

Generic CustomQuery in execute_remove_permission is correctly used.

The invocation of execute_remove_permission within permissioning.rs aligns with the new generic signature. There are no discrepancies found in its usage.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_remove_permission` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_remove_permission<'
Length of output: 364

Script:
#!/bin/bash
# Search for all invocations of `execute_remove_permission` to verify if they match the new generic signature.
rg --type rust 'execute_remove_permission'
Length of output: 257
342-344: Generic CustomQuery in execute_disable_action_permission.

The execute_disable_action_permission function now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

Verification successful

Generic CustomQuery usage verification.

The execute_disable_action_permission function's generic CustomQuery is used in the same file where it is defined. The codebase does not show any other invocations, suggesting that the change is localized and correctly integrated.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_disable_action_permission` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_disable_action_permission<'
Length of output: 390

Script:
#!/bin/bash
# Description: Search for all occurrences of `execute_disable_action_permission` to verify its usage.
rg --type rust 'execute_disable_action_permission'
Length of output: 274
75-77: Generic CustomQuery in is_permissioned.

The is_permissioned function is now generic over CustomQuery, which enhances its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

325-327: Generic CustomQuery in execute_permission_action.

The execute_permission_action function is now generic over CustomQuery, which enhances its adaptability for different query contexts. Ensure that all related logic is compatible with this change.

Verification successful

Verification Successful: Generic CustomQuery in execute_permission_action.

All invocations of execute_permission_action in the codebase align with the new generic signature, confirming compatibility with the change. No issues were found.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_permission_action` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_permission_action<'
Length of output: 374

Script:
#!/bin/bash
# Description: Find all invocations of `execute_permission_action` to verify they match the new generic signature.
rg --type rust 'execute_permission_action<' -A 3
Length of output: 374

Script:
#!/bin/bash
# Description: Find all invocations of `execute_permission_action` in the codebase.
rg --type rust 'execute_permission_action' -A 3
Length of output: 1399
432-433: Generic CustomQuery in is_context_permissioned.

The is_context_permissioned function is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

Verification successful

All invocations of is_context_permissioned are consistent with the new generic signature. The function calls correctly utilize the generic CustomQuery type, ensuring compatibility with various query types.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `is_context_permissioned` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'is_context_permissioned<'
Length of output: 350

Script:
#!/bin/bash
# Search for invocations of the `is_context_permissioned` function to verify consistency with the new generic signature.
rg --type rust 'is_context_permissioned<' -A 3
Length of output: 350

Script:
#!/bin/bash
# Search for all invocations of the `is_context_permissioned` function to verify consistency with the new signature.
rg --type rust 'is_context_permissioned' -A 3
Length of output: 7130
259-261: Generic CustomQuery in execute_set_permission.

The execute_set_permission function is now generic over CustomQuery, allowing it to handle various query types. Ensure that all invocations are consistent with this new signature.

469-470: Generic CustomQuery in is_context_permissioned_strict.

The is_context_permissioned_strict function now supports a generic CustomQuery, enhancing its adaptability for different query contexts. Ensure that this change is reflected in all related code.

Verification successful

Verification Complete: Generic CustomQuery Implementation is Consistent

The function is_context_permissioned_strict with the generic CustomQuery signature is correctly used in the codebase, including in andromeda-cw721/src/contract.rs. All usages align with the updated function signature.

contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs: Correct usage with ctx.deps.branch(), &ctx.info, and &ctx.env.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `is_context_permissioned_strict` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'is_context_permissioned_strict<'
Length of output: 363

Script:
#!/bin/bash
# Description: Search for all occurrences of `is_context_permissioned_strict` to verify usage with the new generic signature.

# Test: Search for all occurrences of the function in the codebase.
rg --type rust 'is_context_permissioned_strict'
Length of output: 1080

Script:
#!/bin/bash
# Description: Check the context around usages of `is_context_permissioned_strict` in `andromeda-cw721/src/contract.rs` to verify correct implementation.

# Test: Display lines around the function usage to verify the signature.
rg --type rust -A 3 -B 3 'is_context_permissioned_strict' contracts/non-fungible-tokens/andromeda-cw721/src/contract.rs
Length of output: 883
148-150: Generic CustomQuery in is_permissioned_strict.

The is_permissioned_strict function now supports a generic CustomQuery, enhancing its capability to handle different query contexts. Ensure that this change is reflected in all related code.

Verification successful

All invocations of is_permissioned_strict match the new generic signature.

The invocations of is_permissioned_strict in the codebase use the new generic CustomQuery signature, as they utilize methods like deps.branch() and deps.as_mut(), which are compatible with DepsMut<C>. No further action is needed.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `is_permissioned_strict` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'is_permissioned_strict<'
Length of output: 345

Script:
#!/bin/bash
# Search for all invocations of the `is_permissioned_strict` function in the codebase.
rg --type rust 'is_permissioned_strict('
Length of output: 139

Script:
#!/bin/bash
# Correct the search pattern to find all invocations of the `is_permissioned_strict` function in the codebase.
rg --type rust 'is_permissioned_strict\('
Length of output: 853
50-52: Generic CustomQuery in execute_permissioning.

The execute_permissioning function now supports a generic CustomQuery, enhancing its ability to work with various query types. Ensure that all invocations of this function throughout the codebase are updated to accommodate this change.

Verification successful

All invocations of execute_permissioning are updated correctly.

The invocation of execute_permissioning in packages/std/src/ado_contract/execute.rs uses the correct generic ExecuteContext<C>, ensuring compatibility with the updated function signature. No further updates are necessary.
Scripts executed

The following scripts were executed for the analysis:

Script:
#!/bin/bash
# Description: Verify all invocations of `execute_permissioning` match the new generic signature.

# Test: Search for the function usage. Expect: Only occurrences of the new signature.
rg --type rust -A 3 $'execute_permissioning<'
Length of output: 366

Script:
#!/bin/bash
# Description: Search for all invocations of `execute_permissioning` in the codebase.

# Test: Search for any usage of the function `execute_permissioning`.
rg --type rust 'execute_permissioning'
Length of output: 266

Script:
#!/bin/bash
# Description: Verify the type of `ctx` in the invocation of `execute_permissioning`.

# Test: Search for the definition or context of `ctx` in `execute.rs`.
rg --type rust -A 5 'ctx' packages/std/src/ado_contract/execute.rs
Length of output: 1786
contracts/non-fungible-tokens/andromeda-auction/src/contract.rs (13)

174-175: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

208-209: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

258-259: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

343-344: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

449-450: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

576-577: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

700-701: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

761-762: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

852-853: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

883-884: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

903-904: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

1167-1168: Approved: Function signature update.

The function signature update to include CustomQuery is consistent with the PR objectives.

109-112: LGTM! But verify the function usage in the codebase.

The code changes are approved.

However, ensure that all function calls to handle_execute match the new signature.

crnbarr93 · 2024-08-13T14:43:52Z

@mdjakovic0920

Mind taking a look at this for the issue you raised?

#536

mdjakovic0920 · 2024-08-13T18:39:54Z

@crnbarr93 @joemonem
I can not use InjectiveQueryWrapper as CustomQuery for query from Injective.
For example:

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(
    deps: DepsMut<injective_cosmwasm::InjectiveQueryWrapper>,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> Result<Response, ContractError> {

Here, deps: DepsMut<injective_cosmwasm::InjectiveQueryWrapper> occurs an error:

crnbarr93 · 2024-08-27T08:33:28Z

packages/std/src/ado_contract/execute.rs

 };
 use cw2::{get_contract_version, set_contract_version};
 use semver::Version;
 use serde::de::DeserializeOwned;
 use serde::Serialize;

-type ExecuteContextFunction<M, E = ContractError> = fn(ExecuteContext, M) -> Result<Response, E>;
+type ExecuteContextFunction<M, C, E = ContractError> =


I think you could have save a pretty significant amount of overhead by adding a default similar to the E = ContractError next to the generic. I think the generic param for DepsMut is Empty but worth double checking. We should add a default so that developers don't need to specify a non-required generic param.

We also need to add a changelog entry.

joemonem added 2 commits August 12, 2024 10:36

feat: implement CustomQuery to ExecuteContext

4f31324

feat: complete implementation of CustomQuery

70deaa3

joemonem requested review from crnbarr93 and cowboy0015 August 12, 2024 11:28

chore: version bump

3d0b1db

coderabbitai bot reviewed Aug 12, 2024

View reviewed changes

crnbarr93 requested changes Aug 27, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ref: CustomQuery for ExecuteContext #537

ref: CustomQuery for ExecuteContext #537

joemonem commented Aug 12, 2024 •

edited

Loading

coderabbitai bot commented Aug 12, 2024 •

edited

Loading

Walkthrough skipped

Chat

CodeRabbit Commands (invoked as PR comments)

CodeRabbit Configuration File (`.coderabbit.yaml`)

Documentation and Community

coderabbitai bot left a comment

crnbarr93 commented Aug 13, 2024

mdjakovic0920 commented Aug 13, 2024 •

edited

Loading

crnbarr93 Aug 27, 2024

crnbarr93 Aug 27, 2024

ref: CustomQuery for ExecuteContext #537

Are you sure you want to change the base?

ref: CustomQuery for ExecuteContext #537

Conversation

joemonem commented Aug 12, 2024 • edited Loading

Motivation

Implementation

Testing

Version Changes

coderabbitai bot commented Aug 12, 2024 • edited Loading

Walkthrough skipped

Chat

CodeRabbit Commands (invoked as PR comments)

CodeRabbit Configuration File (.coderabbit.yaml)

Documentation and Community

coderabbitai bot left a comment

Choose a reason for hiding this comment

crnbarr93 commented Aug 13, 2024

mdjakovic0920 commented Aug 13, 2024 • edited Loading

crnbarr93 Aug 27, 2024

Choose a reason for hiding this comment

crnbarr93 Aug 27, 2024

Choose a reason for hiding this comment

joemonem commented Aug 12, 2024 •

edited

Loading

coderabbitai bot commented Aug 12, 2024 •

edited

Loading

CodeRabbit Configuration File (`.coderabbit.yaml`)

mdjakovic0920 commented Aug 13, 2024 •

edited

Loading