Spherre-Labs/spherre

AI Summary: Expand the test coverage for the `execute_nft_transaction` function in the Spherre StarkNet smart contract. This involves adding tests for various failure scenarios (invalid transaction ID, unauthorized caller, invalid recipient, etc.) and verifying the correct emission of events at each stage of the transaction lifecycle (approval and execution). The tests should be written using Starknet Foundry's testing framework.

AI Summary: Expand the unit test suite for the `execute_member_add_transaction` function in a Cairo smart contract. This involves adding test cases for various failure scenarios (e.g., invalid transaction ID, unauthorized caller, duplicate member addition) and verifying the correct emission of events throughout the transaction lifecycle.

AI Summary: Expand the test coverage for the `execute_token_transaction` function in the Spherre StarkNet smart contract. This involves adding test cases for various edge cases (invalid transactions, insufficient approvals, unauthorized callers, insufficient balance, zero address recipient) and verifying the correct emission of events (`TransactionApproved`, `TransactionExecuted`, `TokenTransactionExecuted`) throughout the transaction lifecycle.

AI Summary: Expand the unit test suite for the `execute_member_remove_transaction` function in a Cairo smart contract. This involves adding tests for various failure scenarios (invalid transaction ID, unauthorized caller, non-member removal, insufficient approvals) and verifying the correct emission of events (`TransactionApproved`, `TransactionExecuted`, `MemberRemoveTransactionExecuted`). The tests should use Starknet Foundry and leverage assertions to check for expected behavior and event data.

AI Summary: Expand the unit test suite for the `execute_change_threshold_transaction` function in a Cairo smart contract. This involves adding tests for various failure scenarios (invalid transaction ID, unauthorized caller, invalid threshold, insufficient approvals) and verifying the correct emission of events (`TransactionApproved`, `TransactionExecuted`, `ChangeThresholdTransactionExecuted`). The tests should use Starknet Foundry and `snforge_std` for assertions.

AI Summary: Expand the test suite for the `execute_edit_permission_transaction` function in the Spherre StarkNet smart contract to include comprehensive testing of failure scenarios and event emissions. This involves adding test cases for invalid transactions, unauthorized callers, non-member accounts, invalid permission masks, and unapproved transactions, and verifying the correct emission of `TransactionApproved`, `TransactionExecuted`, and `PermissionEditTransactionExecuted` events.

AI Summary: Implement a paginated transaction listing function (`transaction_list`) in the Cairo smart contract's `AccountData` component. This involves adding the function, handling pagination parameters (`start`, `limit`), validating input to prevent out-of-bounds errors, and writing comprehensive unit tests.

AI Summary: Implement a `reset_will_duration` function in a Cairo smart contract for the Spherre protocol. This function should allow members to extend their smart will's duration by the default amount, but only within 30 days of expiration and only if they are a valid member with an active will wallet. The function needs comprehensive error handling and testing for various scenarios.

AI Summary: Debug and fix a bug in the `collect_fees` function of a StarkNet smart contract that incorrectly raises an 'insufficient fee' error. This involves investigating the interaction with an IERC20Dispatcher, correcting the balance retrieval and comparison logic, and writing/updating comprehensive tests to cover various scenarios, including successful and failed fee collections and edge cases.

AI Summary: Implement a comprehensive whitelist management system for the Spherre StarkNet multisig treasury contract, including adding and removing accounts and users, querying whitelist status, and emitting relevant events. The implementation should be thoroughly tested and adhere to role-based access control.

AI Summary: Implement a fee structure management system in the Spherre Cairo smart contract, including defining fee types, storage for fee amounts and token addresses, functions for updating and retrieving fees, access control, event emission, and comprehensive testing. The system should support different fee types (proposal, voting, execution, deployment) and allow for configurable fees and token selection.

AI Summary: Implement a smart will functionality within the Spherre StarkNet protocol's AccountData component. This involves creating storage maps to track wills, implementing functions to update and retrieve will information, incorporating validation checks (e.g., ensuring the will recipient isn't already a member and respecting a 90-day update cooldown), and emitting events for transparency. Thorough testing is crucial.

AI Summary: Implement a member details tracking system for the Spherre StarkNet multisig treasury contract. This involves creating data structures to store member activity metrics (proposals, approvals, rejections, executions, join date), updating existing transaction functions to increment these metrics, and creating a function to retrieve a member's complete details. Thorough testing is required.

AI Summary: Implement a token locking feature in the Spherre Protocol's TreasuryHandler smart contract. This involves creating a `SmartTokenLock` struct, adding storage for tracking locked tokens, implementing functions to lock and unlock tokens, integrating with existing transfer and balance functions, and writing unit tests.

AI Summary: Implement a new smart contract feature to propose, manage, and retrieve smart token lock transactions within a multisig treasury system built on StarkNet. This involves creating a new data structure for smart lock transactions, implementing functions to propose, retrieve, and list these transactions, integrating with existing treasury management logic, and writing comprehensive unit tests.

AI Summary: Implement the `execute_smart_token_lock_transaction` function within a StarkNet smart contract to execute approved smart lock transactions. This involves validating the transaction, interacting with a treasury handler for token locking, updating transaction status, handling errors, and emitting events. The task depends on previously completed features and requires thorough testing.

AI Summary: Refactor the NFTTransaction and TokenTransaction components in a StarkNet Cairo smart contract to use a new TreasuryHandler component for all token and NFT operations. This involves replacing direct balance checks and transfer logic with calls to the TreasuryHandler's functions and updating the mock account data contract. Testing is required to ensure no breaking changes.