SCSVS-GOV

Temporary Checklist

This checklist contains the SCSVS v0.0.1 verification levels (L1, L2 and L3) which we are currently reworking into "security testing profiles". The levels were assigned according to the SCSVS v1 ID that the test was previously covering and might differ in the upcoming version of the SCSTG and SCS Checklist.

For the upcoming of the SCSTG version we will progressively split the SCSTG tests into smaller tests, the so-called "atomic tests" and assign the new SCS profiles to their respective SCWE weaknesses.

SCG ID	VR ID	TEST ID	Control / SCSTG Test	Checklist
TBD	TBD.1	TBD	Verify Role-Based Access Control Implementation	- Are there different roles that have been assigned and have different access control mechanisms?
				- If yes, check and verify that correct access control mechanisms are implemented and least privilege policy is implemented.
TBD	TBD.2	TBD	Verify Timelocks for Critical Functions	- Are timelocks implemented for all critical functions in the smart contract?
				- What is the duration of the timelock for each critical function? Is it adequate for review purposes?
				- Can timelocks be bypassed or modified? If so, under what conditions?
TBD	TBD.3	TBD	Verify Contract Initialization Functions	- Are initialization functions properly marked as internal?
				- Is there a mechanism in place to ensure initialization functions cannot be executed more than once?
				- Are there any fallback functions that might unintentionally allow reinitialization?
TBD	TBD.4	TBD	Verify Modifier Logic	- Are all custom modifiers correctly implemented and applied to the intended functions?
				- Are there any modifiers that contain redundant or conflicting logic?
				- Have the modifiers been reviewed and tested for potential vulnerabilities?
TBD	TBD.5	TBD	Verify ERC20 Compliance	- Are the token's transfer functions (transfer, transferFrom) fully compliant with the EIP20 standard, including returning a boolean flag and reverting on failure?
				- Are safe transfer functions (safeTransfer, safeTransferFrom) consistently used throughout the contract?
TBD	TBD.6	TBD	Verify Approval Race Condition	- Is there a risk of race conditions in the approval process that could lead to unexpected fund loss for the signer?
				- Are there mechanisms in place to prevent double-spending or front-running attacks?
TBD	TBD.7	TBD	Verify Decimal Discrepancies	- Could differences in the number of decimals between various ERC20 tokens lead to calculation or interpretation errors?
				- Are there any conversions or calculations that might be affected by differing decimal places?
TBD	TBD.8	TBD	Verify Address Checks	- Does the token implement any forms of address whitelisting, blacklisting, or validation checks that could introduce issues?
				- Are there any hardcoded addresses in the contract that could pose security risks?
TBD	TBD.9	TBD	Verify Transfer Fees	- Does the token impose a fee on transfers, resulting in the receiver getting less than the specified amount?
				- How are transfer fees calculated and collected?
TBD	TBD.10	TBD	Verify ERC777 Compatibility	- Can the token also function as an ERC777 token, which includes hooks that execute code before and after transfers, potentially leading to reentrancy attacks?
				- Are there safeguards in place to handle the hooks securely?
TBD	TBD.11	TBD	Verify Solmate's ERC20.safeTransferLib Usage	- Does the protocol utilize Solmate's ERC20.safeTransferLib, which does not check for the existence of a contract and could be exploited for honeypot attacks?
				- Are there alternative libraries or methods that could enhance security?
TBD	TBD.12	TBD	Verify Zero Amount Transfers	- What is the token's behavior when transferring a zero amount? Does it revert, and could this cause issues in certain integrations and operations?
				- Are there any edge cases related to zero-amount transfers?
TBD	TBD.13	TBD	Verify ERC2612 Implementation	- Is the token an ERC2612 implementation, and is the DOMAIN_SEPARATOR() function properly implemented to avoid vulnerabilities?
				- How is the permit() function implemented, and are there any potential issues?
TBD	TBD.14	TBD	Verify Permit Function Replay Protection	- Does the permit() function have adequate replay protection, or could someone reuse a permit signature multiple times to authorize multiple transfers?
				- Is the nonces mapping updated correctly, and does the implementation properly prevent replays?
TBD	TBD.15	TBD	Understanding Protocol Actors	- Have all actors and their interactions within the protocol been clearly identified and documented?
				- Are the roles and permissions of each actor clearly defined and appropriate?
TBD	TBD.16	TBD	Access Control Verification	- Are there any functions lacking access control mechanisms?
				- Are there any public functions that should have a more restricted visibility (e.g., internal, private)?
				- Are access controls correctly implemented to prevent unauthorized access or modifications?
TBD	TBD.17	TBD	Whitelisting Implementation	- Are certain addresses required to be whitelisted to interact with the contract?
				- Is the whitelisting mechanism properly implemented and enforced?
TBD	TBD.18	TBD	Secure Privilege Transfer	- Does the protocol allow the transfer of privileges?
				- If yes, is the transfer process secure and includes a two-step (request and confirmation) mechanism?
				- What happens during the transfer of privileges?
TBD	TBD.19	TBD	Function Overriding	- Does the contract inherit functions from parent contracts?
				- Are functions that override parent contract functions explicitly marked with the override keyword?
TBD	TBD.20	TBD	Authorization Using msg.sender	- Does the contract use tx.origin in validation? If yes, this must be avoided as tx.origin phishing attacks are possible and can be exploited.
				- Are proper authorization mechanisms in place using msg.sender to ensure secure and accurate access control?
TBD	TBD.21	TBD	Critical Function Access Control	- Does the contract have the specified functions?
				- If yes, are proper access control measures in place?
TBD	TBD.22	TBD	Token Donation Manipulation	- Does the contract rely on balance or balanceOf for determining token balances or ownership? If so, are there safeguards against manipulation through token donations?
				- Are token balances verified against internal accounting records rather than solely using balanceOf?
				- Does the contract implement additional validation to ensure donated tokens do not alter accounting in unexpected ways?
TBD	TBD.23	TBD	Withdrawal Pattern Best Practices	- Does the contract use a pull-based withdrawal approach to avoid denial of service attacks? Verify the absence of direct fund transfers in the contract logic.
				- Are there checks to limit the maximum number of withdrawal requests to prevent abuse?
				- Is the contract designed to handle failed or reverted withdrawals gracefully, without affecting the contract's state?
TBD	TBD.24	TBD	Minimum Transaction Amount	- Is there a check in place to enforce a minimum transaction amount? Verify that transactions below this threshold are rejected.
				- Does the contract have logic to discard or revert transactions that do not meet the minimum amount requirement?
				- Are there any limits set to prevent dust transactions from accumulating or affecting the protocol?
TBD	TBD.25	TBD	Token Blacklisting Risks	- Does the protocol check for blacklisting functionality in the tokens it handles? Verify if blacklisted addresses are properly managed.
				- How does the protocol handle interactions with tokens that can blacklist addresses? Ensure there are no unintended consequences.
				- Are there mechanisms in place to handle token transfers or interactions if addresses are blacklisted?
TBD	TBD.26	TBD	Queue Processing Denial Of Service	- Is there a limit on the size or number of queued transactions to prevent denial of service? Verify that the contract enforces these limits.
				- Does the contract implement measures to prevent abuse of queue processing, such as rate limiting or prioritization?
				- How does the protocol handle excessive queue sizes or frequent updates to prevent system overload?
TBD	TBD.27	TBD	Low Decimal Tokens Issues	- Does the contract handle tokens with low decimal precision appropriately? Verify if rounding issues are addressed.
				- Are there checks to ensure that transactions involving low decimal tokens do not result in unintended failures or errors?
				- How does the contract handle rounding or precision issues to maintain accurate token transactions?
TBD	TBD.28	TBD	External Contract Interaction Safety	- Does the contract use the check-effects-interactions pattern to ensure safe interactions with external contracts?
				- Are there fallback mechanisms in place to handle failures or unexpected results from external contract interactions?
				- How does the contract ensure that external dependencies do not affect its core functionality or state?
TBD	TBD.29	TBD	Get Or Create Pattern Frontrunning	- Does the contract have protections against frontrunning in get-or-create patterns? Verify if there are mechanisms to mitigate this risk.
				- How does the protocol handle situations where a get-or-create pattern could be exploited by an attacker?
				- Are there checks or time locks to ensure that actions within get-or-create patterns cannot be front-run?
TBD	TBD.30	TBD	Two Transaction Actions Frontrunning	- Are two-transaction actions designed with measures to prevent frontrunning? Verify if there are checks or locks between transactions.
				- How does the protocol ensure that critical two-step actions are not vulnerable to attack during the intermediary state?
				- Are there safeguards to prevent malicious actors from intervening between the two transactions?
TBD	TBD.31	TBD	Dust Transactions Reversion	- Can users front-run transactions with negligible amounts to cause reverts? Verify the contract’s handling of such scenarios.
				- Are there checks to prevent transactions with minimal amounts from impacting the contract's state or execution flow?
				- How does the contract manage or mitigate the effects of dust transactions on legitimate operations?
TBD	TBD.32	TBD	Commit Reveal Scheme	- Does the protocol implement a commit-reveal scheme to protect against front-running? Verify the presence of both commit and reveal phases.
				- How does the protocol ensure that the commit-reveal pattern is followed to prevent adversaries from gaining insight into actions before they are finalized?
				- Are there mechanisms in place to ensure confidentiality and integrity of actions until the reveal phase?
TBD	TBD.33	TBD	External State Changes Impact	- Does the contract rely on external states that can be modified by other actors? Verify how these external changes impact critical functions.
				- Are there protections against state changes that could disrupt normal user transactions, particularly for crucial operations like withdrawals or repayments?
				- How does the contract ensure that its core functionality remains intact despite potential manipulations by external actors?
TBD	TBD.34	TBD	Block Timestamp Manipulation	- Is block.timestamp used for critical logic where precision is crucial? Verify that it is used appropriately.
				- How does the contract account for potential inaccuracies or manipulations in block.timestamp?
				- Are there alternative mechanisms or fallback strategies used when precise timing is required?
TBD	TBD.35	TBD	Price Manipulation Vectors	- How does the protocol obtain asset prices? Verify if the method is susceptible to manipulation through flash loans or donations.
				- Are there external or decentralized price oracles used to mitigate risks associated with price manipulation?
				- Does the contract include mechanisms to verify the accuracy and integrity of price data?
TBD	TBD.36	TBD	Read-Only Reentrancy	- Are there view functions that could be reentered in a way that might return stale or inconsistent values?
				- Does the contract have measures to prevent reentrancy issues in view functions, such as extending reentrancy guards?
				- How does the protocol ensure that read-only functions do not lead to inconsistent state or unintended actions?
TBD	TBD.37	TBD	Untrusted External Contract Calls	- Are there any state changes after interactions with untrusted external contracts? Verify if these interactions are securely managed.
				- Does the contract use the check-effects-interactions pattern or reentrancy guards to handle external contract calls?
				- How does the protocol handle potential issues arising from external contract callbacks, such as multiple withdrawals or event order?
TBD	TBD.38	TBD	Failed Transaction Replay Protection	- Is there a mechanism in place to prevent replay attacks on failed transactions? Verify the use of nonces or other protections.
				- How does the contract ensure that each transaction can only be executed once, even if it fails initially?
				- Are there specific measures to differentiate between unique and replayed transactions?
TBD	TBD.39	TBD	Signature Replay Protection	- Is there a protection mechanism to prevent signatures from being replayed on different chains? Verify the use of domain separators or chain-specific parameters.
				- How does the protocol ensure that signatures are only valid on the intended chain?
				- Are there safeguards to prevent cross-chain replay attacks on signed transactions?
TBD	TBD.40	TBD	Admin Asset Pull Privilege	- Can the admin of the protocol pull assets from the protocol? Verify the extent of the admin's privileges and access controls.
				- Are there constraints or timelocks in place to regulate admin access to protocol funds?
				- How does the protocol track and report admin actions that involve user funds?
TBD	TBD.41	TBD	Slippage Protection	- Does the protocol include slippage protection mechanisms for user transactions? Verify if users can set a minimum output amount.
				- How does the contract handle price manipulation risks from front-running attacks?
				- Are there any controls in place to prevent attackers from exploiting slippage to benefit from user transactions?
TBD	TBD.42	TBD	Sybil Attack Protection	- Is the protocol's quorum mechanism or rewarding system designed to resist sybil attacks? Verify the criteria used for participation or rewards.
				- How does the contract ensure that actions or decisions are not unduly influenced by sybil attacks?
				- Are there checks or balances in place to validate the legitimacy of addresses participating in quorum or rewarding mechanisms?
TBD	TBD.43	TBD	Cycle Edge Cases	- What happens on the first and last cycle of the iteration? Verify if there are any special conditions or different logic applied.
				- Are there any specific checks or handling required for the first and last cycles compared to others?
				- How does the contract ensure consistency and correctness throughout all cycles, including the first and last?
TBD	TBD.44	TBD	Array Deletion Method	- How does the protocol remove an item from an array? Verify the method used for array element removal.
				- Does the contract handle array reordering or element shifting after an item is deleted?
				- Are there mechanisms in place to update the array length or manage gaps created by delete?
TBD	TBD.45	TBD	Array Index Usage	- Does any function get an index of an array as an argument? Verify if this index is used in contexts where the array might be modified.
				- How does the contract handle index-based access in arrays where elements might be added or removed?
				- Are there checks to ensure that index values are valid and consistent with the current state of the array?
TBD	TBD.46	TBD	Precision in Summation	- Is the summing of variables done accurately compared to separate calculations? Verify the approach used for summation.
				- How does the contract handle precision issues in financial calculations or other critical computations?
				- Are there tests in place to verify the accuracy of summation logic and address any discrepancies?
TBD	TBD.47	TBD	Unique Array Validation	- Is it acceptable to have duplicate items in the array? Verify the expected behavior of the array regarding uniqueness.
				- How does the protocol validate and handle duplicate entries in arrays, particularly user input arrays?
				- Are there checks or validations to enforce array uniqueness where required?
TBD	TBD.48	TBD	Loop Edge Cases	- Is there any issue with the first and last iteration of loops? Verify if these iterations have different logic or edge cases.
				- How does the contract ensure consistent behavior throughout all iterations, including the initial and final ones?
				- Are there specific tests for the edge cases of loop iterations to prevent potential vulnerabilities?
TBD	TBD.49	TBD	Transaction Gas Limit	- Is there a possibility of iterating over a huge array in a single transaction? Verify the gas usage and limits associated with such operations.
				- How does the contract handle scenarios where the gas limit might be exceeded due to large-scale operations?
				- Are there safeguards or limits in place to prevent transactions from exceeding the block gas limit?
TBD	TBD.50	TBD	DoS in Loops	- Is there a potential for a Denial-of-Service (DoS) attack in loops? Verify if external calls or user inputs could impact the loop execution.
				- How does the contract ensure that a failure in a single iteration does not affect the overall operation?
				- Are there mechanisms to handle or mitigate the impact of failed or problematic iterations in loops?
TBD	TBD.51	TBD	Msg.value in Loop	- Is msg.value used within a loop? Verify if msg.value is accessed multiple times within a loop.
				- How does the contract manage msg.value to ensure consistent accounting throughout the transaction?
				- Are there potential issues or mistakes in accounting if msg.value is used in a loop?
TBD	TBD.52	TBD	Batch Fund Transfer	- Is there a loop to handle batch fund transfers? Verify how the mechanism handles residual or leftover funds.
				- How does the contract ensure that all funds are transferred correctly, including any residual amounts?
				- Are there specific checks or logic to handle the last transfer in a batch to account for dust funds?
TBD	TBD.53	TBD	Loop Control Statements	- Is there a break or continue statement inside a loop? Verify how these statements are used within the loop.
				- How does the contract ensure that the use of break or continue does not lead to unexpected behaviors or logic errors?
				- Are there tests to cover scenarios where loop control statements might affect the loop's functionality?
TBD	TBD.54	TBD	Reorg Vulnerability with CREATE	- Does the contract deployment process use CREATE2 instead of CREATE to ensure contract stability across block reorgs?
				- Is there a fallback mechanism in place to handle contract creation failures due to block reorgs?
				- Has the protocol been tested for resilience against block reorgs affecting contract creation?
TBD	TBD.55	TBD	Event Emitting on State Change	- Are events emitted for all critical state changes and function executions to ensure traceability?
				- Is there a comprehensive list of all state-changing functions that should emit events?
				- Does the contract's event logging cover edge cases and error scenarios effectively?
TBD	TBD.56	TBD	Input Validation	- Are all function inputs validated for type, range, and format before processing?
				- Is there validation logic for boundary values and unexpected input scenarios?
				- Are there checks in place to prevent unauthorized or malicious data from being processed?
TBD	TBD.57	TBD	Output Validation	- Are outputs validated for correctness and consistency before being returned or used?
				- Does the contract include checks to ensure outputs do not introduce security vulnerabilities or logical errors?
				- Is there validation to confirm that outputs are within expected ranges and formats?
TBD	TBD.58	TBD	Front-Running Risk	- Are there safeguards to prevent front-running attacks by ensuring fair transaction processing?
				- Does the protocol include measures to handle transactions in a way that mitigates the risk of priority manipulation?
				- Is there a mechanism to protect against attacks that exploit transaction ordering or timing?
TBD	TBD.59	TBD	Comment Accuracy	- Are comments and documentation reviewed and updated regularly to match the current implementation?
				- Does the code review process include verification of comment accuracy and relevance?
				- Are there automated tools or practices in place to flag outdated or inconsistent comments?
TBD	TBD.60	TBD	Edge Case Handling	- Are edge cases (such as zero or maximum values) specifically tested to ensure the contract handles them correctly?
				- Is there logic in place to handle unusual or extreme input values gracefully without failure?
				- Does the contract have mechanisms to validate and handle boundary values appropriately?
TBD	TBD.61	TBD	Arbitrary Input and Low-Level Calls	- Are all low-level calls restricted or validated to prevent exploitation with arbitrary user input?
				- Does the contract include checks to ensure that arbitrary data used in low-level calls does not lead to unintended behavior?
				- Is there a mechanism to sanitize and validate user input before passing it to low-level calls?
TBD	TBD.62	TBD	Visibility Modifier	- Is the visibility of each function limited to the strictest level necessary (private or internal)?
				- Are there any functions that are currently public or external but could be restricted to internal or private?
				- Does the contract expose any sensitive operations or state changes to external parties that should be restricted?
TBD	TBD.63	TBD	Caller Checking	- Does the function restrict calls to only externally owned accounts (EOA) or only contract addresses as intended?
				- Are there access control checks in place to differentiate between EOA and contract callers when required?
				- Has the protocol been reviewed to ensure it meets the intended caller requirements?
TBD	TBD.64	TBD	Access Control	- Are functions that modify the contract state or handle sensitive operations protected by access control mechanisms?
				- Is access control implemented using modifiers such as onlyOwner or custom access control modifiers where necessary?
				- Have access control mechanisms been tested to ensure they function as intended?
TBD	TBD.65	TBD	Parent Contract Visibility	- Have you reviewed the visibility of functions in parent contracts to ensure they are appropriately exposed?
				- Are there any public or external functions in parent contracts that should be restricted or hidden in the derived contract?
				- Is the visibility of inherited functions aligned with the desired access levels?
TBD	TBD.66	TBD	Inherited Function Implementation	- Have all required functions specified by parent contracts been implemented in the derived contract?
				- Are there any missing implementations that could affect the functionality or purpose of inheritance?
				- Is the inherited contract’s behavior consistent with the parent contract’s expectations?
TBD	TBD.67	TBD	Interface Implementation	- Does the contract correctly implement all functions defined in the interface it adheres to?
				- Have you verified that the interface methods are fully implemented and operational?
				- Are there any discrepancies between the interface specification and the contract implementation?
TBD	TBD.68	TBD	Inheritance Order	- Is the inheritance chain ordered from the most base-like contract to the most derived contract?
				- Have you verified that the inheritance order does not affect variable initialization or functionality?
				- Are there any issues with storage layout or state variable initialization due to incorrect inheritance order?
TBD	TBD.69	TBD	State Variable Initialization	- Are all important state variables explicitly initialized in the constructor or initialization functions?
				- Have you reviewed the contract to ensure no uninitialized state variables could lead to vulnerabilities or errors?
				- Is there a clear initialization strategy for all state variables used in the contract?
TBD	TBD.70	TBD	Using Initializable	- Does the contract use the onlyInitializing modifier if it is intended to be inherited?
				- Is the initializer modifier used appropriately and not exposed to inherited contracts?
				- Have you ensured that initialization is restricted correctly to avoid unauthorized access?
TBD	TBD.71	TBD	Initializer Front Running	- Does the contract use a factory pattern or other mechanism to prevent front-running of the initializer function?
				- Is the initializer function protected from being called by unauthorized parties immediately after deployment?
				- Have you implemented safeguards to ensure the initializer cannot be front-run to alter critical access controls?
TBD	TBD.72	TBD	Initializer Front Running	- Does the contract use a factory pattern or other mechanism to prevent front-running of the initializer function?
				- Is the initializer function protected from being called by unauthorized parties immediately after deployment?
				- Have you implemented safeguards to ensure the initializer cannot be front-run to alter critical access controls?
TBD	TBD.73	TBD	Nested Structure Deletion	- Does the deletion logic ensure that all nested fields within a structure are properly handled and reset?
				- Are there mechanisms in place to delete or reset nested fields before removing the top-level field?
				- Have you verified that nested structures are correctly managed to avoid residual data issues?
TBD	TBD.74	TBD	Mathematical Calculation Accuracy	- Have all mathematical calculations been reviewed to ensure accuracy and adherence to established rules?
				- Is there a clear and documented approach to handle mathematical operations in the contract?
				- Are there any potential sources of error or miscalculation that need to be addressed?
TBD	TBD.75	TBD	Precision Loss	- Is there potential for loss of precision in any calculations, especially those involving frequent or large numbers?
				- Are appropriate data types used to minimize precision loss and ensure accurate results?
				- Have rounding methods and precision handling been correctly applied and verified?
TBD	TBD.76	TBD	Data Type Conversion	- Have you verified that expressions like 1 day are explicitly cast to avoid unintended conversions (e.g., to uint24)?
				- Are there any expressions in the contract where implicit type conversions could lead to unexpected behavior or overflow?
				- Is type conversion handled explicitly to prevent data loss or overflow issues?
TBD	TBD.77	TBD	Multiplication Before Division	- Does the contract ensure that multiplication occurs before division in calculations to preserve precision?
				- Are there any instances where division is performed before multiplication, potentially causing precision loss?
				- Have you reviewed all calculations to confirm that multiplication precedes division where necessary?
TBD	TBD.78	TBD	Rounding Direction	- Is the rounding direction considered and correctly applied in accounting operations?
				- Does the rounding direction align with the protocol’s requirements and user share calculations?
				- Have you verified that rounding is handled consistently across all relevant operations?
TBD	TBD.79	TBD	Division by Zero	- Is there a check in place to prevent division by zero in any calculations?
				- Have you reviewed all divisions to ensure that denominators are never zero?
				- Are there safety checks implemented to handle potential division by zero scenarios?
TBD	TBD.80	TBD	Variable Bounds	- Have you ensured that variables do not exceed their bounds and cause reverts, even in versions greater than 0.8.0?
				- Are there explicit checks to prevent variable underflows and overflows in all critical operations?
				- Is there any logic to handle boundary conditions for variables to avoid unintended reverts?
TBD	TBD.81	TBD	Unsigned Integer Values	- Are you aware of and have you ensured that unsigned integers are never assigned negative values?
				- Is there validation in place to prevent negative values from being assigned to unsigned integers?
				- Have you reviewed all assignments to ensure that only non-negative values are used for unsigned integers?
TBD	TBD.82	TBD	Unchecked Blocks	- Have you reviewed all usages of the unchecked{} block to ensure they are applied correctly?
				- Is there a clear guarantee that no overflow or underflow occurs within unchecked{} blocks?
				- Are there sufficient tests to confirm that operations inside unchecked{} blocks do not cause unintended behavior?
TBD	TBD.83	TBD	Incorrect Inequality	- In comparisons involving < or >, have you ensured that the correct operators (≤ or ≥) are used where appropriate?
				- Are all edge cases covered to avoid unexpected behavior due to incorrect inequality operators?
				- Have you reviewed the logic to confirm that the appropriate comparison operators are applied?
TBD	TBD.84	TBD	Inline Assembly	- Have you thoroughly tested and verified all mathematical operations performed in inline assembly?
				- Is there an awareness of how inline assembly handles division by zero, overflow, or underflow differently from high-level constructs?
				- Are there checks in place to handle potential issues with inline assembly operations?
TBD	TBD.85	TBD	Edge Case Calculation	- Have you tested calculations with minimum and maximum values for all terms to ensure accurate outcomes?
				- Are edge cases handled correctly to prevent unexpected results in complex calculations?
				- Is there a thorough review of calculations involving numerous terms to validate behavior with extreme values?
TBD	TBD.86	TBD	Forced Type Casting	- Is there any forced type casting in the contract?
				- Have you ensured that all forced type casting operations are validated to avoid overflow or underflow issues?
				- Is there a review of all type casting to confirm that values fall within the acceptable range for the target type?
TBD	TBD.87	TBD	Time Units Overflow	- Does the contract use time units (like days) and handle them as uint8?
				- Have you verified that all calculations involving time units are checked for potential overflow, considering their range?
				- Are there safeguards in place to prevent overflow in time-related calculations using uint8?
TBD	TBD.88	TBD	Hardcoded Slippage	- Is slippage implemented as a hardcoded value in the contract?
				- Have you ensured that slippage can be adjusted dynamically based on market conditions?
				- Is there functionality allowing users to specify slippage parameters based on their own calculations?
TBD	TBD.89	TBD	Deadline Protection	- Does the protocol implement deadline protection to prevent transactions from being manipulated?
				- Is there an option for users to set deadlines for their transactions?
				- Have you validated that transactions cannot be processed outside the specified deadline?
TBD	TBD.90	TBD	Reserve Validation	- Is there a validation check in place for protocol reserves?
				- Have you ensured that reserves are verified before being used or lent out?
				- Does the protocol include mechanisms to safeguard against reserve depletion?
TBD	TBD.91	TBD	Forked Code Risks	- Is the AMM using code forked from known projects?
				- Have you reviewed the forked code for known vulnerabilities?
				- Is there a comparison of the forked code against the original to identify potential security issues?
TBD	TBD.92	TBD	Rounding Issues	- Are rounding issues addressed in the AMM's product constant formulas?
				- Have you verified that rounding does not introduce inaccuracies in token swaps?
				- Is there a review of mathematical operations to ensure proper handling of rounding?
TBD	TBD.93	TBD	Arbitrary Calls	- Can the contract make arbitrary calls based on user input?
				- Have you validated and sanitized user inputs to prevent executing unintended calls?
				- Is there a mechanism to prevent execution of arbitrary code based on user input?
TBD	TBD.94	TBD	Slippage Protection	- Is there a mechanism to protect against excessive slippage in trades?
				- Can users specify their own slippage parameters to manage risk?
				- Are there safeguards to prevent losses from large price deviations?
TBD	TBD.95	TBD	Token Decimals Support	- Does the AMM handle tokens with varying decimal places and types correctly?
				- Have you verified compatibility with tokens of different decimal configurations?
				- Is there validation for token types and decimal places before processing?
TBD	TBD.96	TBD	Fee On Transfer Support	- Does the AMM support fee-on-transfer tokens?
				- Have you accounted for discrepancies between the sent and received amounts with fee-on-transfer tokens?
				- Is there functionality to handle or adjust for fee-on-transfer tokens appropriately?
TBD	TBD.97	TBD	Rebasing Tokens Support	- Does the AMM support rebasing tokens?
				- Have you accounted for changes in balance due to rebasing tokens?
				- Is there functionality to correctly handle rebasing tokens and their balance changes?
TBD	TBD.98	TBD	Min Amount Out Calculation	- Does the protocol calculate minAmountOut before executing swaps?
				- Is the source of rates for minAmountOut reliable and protected from manipulation?
				- Have you validated the minAmountOut logic to prevent unfavorable rates and potential vulnerabilities?
TBD	TBD.99	TBD	Callback Address Validation	- Does the integrating contract verify the caller address in its callback functions?
				- Have you implemented checks to validate the address of the calling contract in callback functions?
				- Is there a review of callback logic to ensure it prevents unauthorized access or manipulation?
TBD	TBD.100	TBD	OnChainSlippageManipulation	- Is slippage calculated directly on-chain?
				- Can the slippage calculation be influenced or manipulated by attackers?
				- Is there a mechanism to allow users to specify slippage based on off-chain calculations?
TBD	TBD.101	TBD	IntermediateSlippageEnforcement	- Is the slippage parameter enforced at all stages of the swap process, including the final step?
				- Can users receive less than the specified minimum if the final step does not enforce slippage?
TBD	TBD.102	TBD	WithdrawalsInSameBlock	- Are withdrawals disabled within the same block as other significant actions?
				- Does the protocol prevent flashloan attacks by implementing a delay or restriction on withdrawals within the same block?
TBD	TBD.103	TBD	ERC4626FlashloanRisk	- Can ERC4626 be manipulated through flashloans?
				- Are there protections in place against flashloan attacks in ERC4626-related operations?
				- Is the protocol aware of flashloan risks and has it implemented safeguards?
TBD	TBD.104	TBD	ERC20DecimalsSupport	- Can the protocol handle ERC20 tokens with decimals other than 18?
				- Are there mechanisms in place to adjust for different decimal configurations of ERC20 tokens?
TBD	TBD.105	TBD	UnexpectedRewards	- Are there additional rewards accruing for user deposited assets?
				- Does the protocol track and manage all potential rewards for user deposits?
				- Are users provided with clear methods to claim or manage unexpected rewards?
TBD	TBD.106	TBD	DirectTransfersVulnerabilities	- Could direct transfers of assets affect the protocol's internal accounting?
				- Does the protocol rely on balanceOf or address.balance for accounting purposes?
				- Have you ensured that direct transfers do not disrupt the protocol’s logic or accounting?
TBD	TBD.107	TBD	FirstDepositInitialization	- Does the initial deposit set parameters or conditions for subsequent deposits?
				- Have you tested to ensure that the first deposit initializes parameters correctly?
TBD	TBD.108	TBD	TokenPegging	- Are the protocol tokens pegged to any other asset?
				- Have you tested the protocol’s behavior when the pegged asset depegs?
TBD	TBD.109	TBD	HighAllowancesRisk	- Does the protocol implement safeguards against excessively high allowances?
				- Is there a revert mechanism in place for overly high approval values?
TBD	TBD.110	TBD	ResidualAmounts	- What happens if a small residual amount (e.g., 1 wei) remains in the pool?
				- Does the protocol handle minimal residual amounts appropriately?
TBD	TBD.111	TBD	FlashloanDepositWithdrawAttack	- Is it possible to withdraw in the same transaction as the deposit?
				- Does the protocol have protections against flashloan-based deposit-harvest-withdraw cycles?
TBD	TBD.112	TBD	ERC20Compliance	- Does the protocol support all kinds of ERC20 tokens?
				- Is there a whitelist or compatibility check for ERC20 tokens?
				- Are there any unsupported token types clearly documented?
TBD	TBD.113	TBD	LiquidationDuringPriceDrops	- Does the liquidation mechanism include logic to handle extreme price drops effectively?
				- Is there a safeguard to ensure liquidation occurs even when price volatility is high?
				- How is the liquidation trigger threshold adjusted during rapid market downturns?
TBD	TBD.114	TBD	PositionLiquidationRisk	- Is there a mechanism to automatically trigger liquidation if a position's collateral falls below the required threshold?
				- Are there specific conditions that can prevent liquidation, and how are these managed?
				- How does the system handle outstanding loans when the collateral value drops significantly?
TBD	TBD.115	TBD	SelfLiquidationProfitLoopholes	- Is there validation to prevent users from exploiting self-liquidation for profit?
				- How are self-liquidation scenarios tested for potential vulnerabilities?
				- Are there limits or conditions imposed on self-liquidation to prevent abuse?
TBD	TBD.116	TBD	OperationalPausesAndLiquidations	- Does the protocol prevent liquidations during operational pauses or interruptions?
				- Are there mechanisms to handle user intentions to increase collateral during such pauses?
				- How does the system manage collateral and liquidation processes during temporary pauses?
TBD	TBD.117	TBD	PausedLiquidationsResumption	- What specific procedures are in place for resuming liquidations after a pause?
				- How is solvency monitored and maintained during and after a liquidation pause?
				- Are there mechanisms to ensure that resumed liquidations do not disrupt system stability?
TBD	TBD.118	TBD	FrontRunningLiquidation	- Are there protections to prevent users from front-running liquidations to increase their collateral and avoid liquidation?
				- How does the protocol handle front-running attempts in the liquidation process?
				- What mechanisms are in place to ensure fair execution of liquidation orders?
TBD	TBD.119	TBD	IncentivesForSmallPositions	- Does the protocol provide adequate incentives for liquidators to address small positions?
				- How are incentives structured to ensure small positions are effectively managed?
				- Are there measures in place to prevent neglect of small liquidation opportunities?
TBD	TBD.120	TBD	InterestInLTVCalculations	- Is accrued interest included in the Loan-to-Value (LTV) calculations?
				- How does the system ensure that interest is factored into credit evaluations accurately?
				- Are there checks to confirm that interest calculations do not affect LTV assessments?
TBD	TBD.121	TBD	LiquidationAndRepayingConsistency	- Can the liquidation and repaying mechanisms be independently enabled or disabled?
				- What controls are in place to ensure consistent operation of both mechanisms?
				- How does the protocol prevent operational discrepancies between liquidation and repaying functions?
TBD	TBD.122	TBD	LendAndBorrowSameToken	- Are there constraints to prevent lending and borrowing the same token within a single transaction?
				- How does the protocol handle rapid price changes or flash loans involving the same token?
				- What measures are in place to prevent manipulation by exploiting lend-borrow actions?
TBD	TBD.123	TBD	DiscrepanciesInLiquidationReturns	- Is there a mechanism to ensure that liquidation returns are consistent and predictable?
				- How does the protocol handle discrepancies in liquidation returns?
				- What steps are taken to ensure that liquidators receive the expected returns?
TBD	TBD.124	TBD	PerpetualDebtRisk	- Can users be trapped in perpetual debt due to protocol conditions or system design?
				- What safeguards are in place to prevent users from being unable to repay their loans?
				- How does the protocol address situations where repayment becomes unfeasible?
TBD	TBD.125	TBD	ValidatorWithdrawalCredentialRisk	- Does the function that calls DepositContract::deposit verify that the deposit root matches the current one using DepositContract.get_deposit_root?
				- How does the protocol handle potential manipulation of withdrawal credentials by malicious validators?
				- What measures are in place to ensure that withdrawal credentials are not compromised by front-running attacks?
TBD	TBD.126	TBD	SandwichAttackExchangeRate	- Does the protocol allow instant withdrawals that could be exploited through sandwich attacks?
				- Can an attacker manipulate the exchange rate through immediate deposits and withdrawals?
				- Is there a mechanism to prevent front-running and back-running attacks affecting ETH drainage from the protocol?
TBD	TBD.127	TBD	ReentrancyInRewardsWithdrawals	- Does the reward or withdrawal code of the protocol handle ETH transfers or NFT minting in a manner that prevents re-entrancy attacks?
				- Are all state changes completed before external calls to prevent re-entrancy vulnerabilities?
				- Can re-entrancy be exploited in the reward distribution or withdrawal process due to improper sequencing of operations?
TBD	TBD.128	TBD	ArbitraryExchangeRateInWithdrawals	- Can an arbitrary exchange rate be set during the processing of queued withdrawals?
				- Does the protocol ensure that the exchange rate used during withdrawal matches the rate at the time of withdrawal request?
				- Are there safeguards to prevent manipulation of the exchange rate during withdrawal processing?
TBD	TBD.129	TBD	PausingFunctionality	- Can functionality be bypassed if a related pause check is missing in one of the functions?
				- Are all functions that should be paused during a system-wide pause consistently checked for the paused state?
				- Is there a mechanism to ensure all related functions respect the pause state uniformly?
TBD	TBD.130	TBD	CorruptionOfInterRelatedStorage	- Can functions that update inter-related data structures lead to corruption or overwriting of related storage records?
				- Are there safeguards against the corruption of inter-related storage structures, especially those related to operators and validators?
				- How does the protocol ensure the integrity of data when updating inter-related storage?
TBD	TBD.131	TBD	IterationOverOperatorsValidators	- Does the protocol avoid iterating over the entire set of operators or validators to prevent gas limit issues?
				- Are there mechanisms to manage large sets of operators or validators without causing denial of service?
				- How does the protocol handle large numbers of operators or validators to maintain efficiency and avoid out-of-gas errors?
TBD	TBD.132	TBD	StaleDataInProofOfReservesOracle	- Does the protocol verify the freshness of data retrieved from the Proof of Reserves Oracle?
				- Can the protocol process stale data due to lack of timestamp validation from the Oracle?
				- What measures are in place to ensure the data from the Proof of Reserves Oracle is current and reliable?
TBD	TBD.133	TBD	PrecisionLossInCalculations	- Does the protocol avoid precision loss in deposit, withdrawal, and reward calculations?
				- Are there any instances of division before multiplication or rounding errors that could affect calculations?
				- How does the protocol handle precision and rounding to prevent inaccuracies in financial operations?
TBD	TBD.134	TBD	DeprecatedChainlinkFunctions	- Is the protocol using deprecated Chainlink functions like latestAnswer() that may return stale data?
				- Are there updated Chainlink methods in use to ensure accurate and current data retrieval?
				- How does the protocol handle deprecated functions to maintain data integrity?
TBD	TBD.135	TBD	ZeroPriceValidation	- Does the protocol validate that the returned price from the price feed is non-zero?
				- What safeguards are in place to handle zero or invalid price values?
				- How does the protocol ensure that price feeds do not return zero values that could affect operations?
TBD	TBD.136	TBD	PriceUpdateTimeValidation	- Does the protocol validate the last update timestamp of the price feed to ensure it is within an acceptable delay?
				- What mechanisms are in place to compare the price feed's update time against predefined maximum delays?
				- How does the protocol handle outdated price feeds to prevent inaccuracies in price usage?
TBD	TBD.137	TBD	RollupSequencerValidation	- Does the protocol validate the operational status of the rollup sequencer to ensure it is online?
				- Is there a method to check if the rollup sequencer is running to prevent stale price issues?
				- How does the protocol handle the scenario where the rollup sequencer is offline?
TBD	TBD.138	TBD	TWAPPeriodManipulation	- Can the TWAP period be adjusted to mitigate risks of price manipulation?
				- If the TWAP period is set, does it align with the protocol’s requirements for accurate price updates?
				- Are there mechanisms in place to adjust the TWAP period based on identified manipulation risks?
TBD	TBD.139	TBD	PriceFeedConsistencyAcrossChains	- Does the desired price feed pair consistently appear across all deployed chains?
				- If there is a process to verify price feed pairs, is it effective in maintaining consistency across chains?
				- Are there checks in place to ensure that price feed pairs remain uniform across all chains?
TBD	TBD.140	TBD	PriceFeedHeartbeatSuitability	- Is the heartbeat of the price feed appropriate for the protocol’s specific use case?
				- If the price feed heartbeat is set, does it meet the operational needs of the protocol?
				- Are there controls to ensure the price feed heartbeat aligns with the protocol’s requirements?
TBD	TBD.141	TBD	DecimalPrecisionConsistency	- Can variations in decimal precision from different price feeds lead to inaccuracies?
				- If decimal precision varies, does the contract handle these variations correctly?
				- Are there measures to standardize decimal precision across different price feeds?
TBD	TBD.142	TBD	HardCodedPriceFeedAddresses	- Are price feed addresses hard-coded in the contract?
				- If price feed addresses are hard-coded, is there a mechanism to update them if they become deprecated?
				- Can the contract manage risks associated with outdated or inaccurate hard-coded price feed addresses?
TBD	TBD.143	TBD	OraclePriceUpdateFrontRunning	- Can oracle price updates be front-run to manipulate outcomes?
				- If oracle price updates are vulnerable to front-running, are there protections in place?
				- Are there mechanisms to safeguard the protocol from front-running attacks on oracle price updates?
TBD	TBD.144	TBD	OracleReverts	- Does the system handle potential oracle reverts effectively?
				- If an oracle revert occurs, are there safeguards to prevent Denial-of-Service conditions?
				- Are there alternative strategies in place to address oracle reverts?
TBD	TBD.145	TBD	PriceFeedAppropriateness	- Are the price feeds accurately matched to the underlying assets they represent?
				- If using a price feed, does it correctly reflect the value of the underlying asset?
				- Are there checks to ensure the appropriateness of the price feeds for the underlying assets?
TBD	TBD.146	TBD	AMMSpotPriceVulnerabilities	- Can the protocol be manipulated through AMM spot prices, especially with flash loans?
				- If spot prices from AMMs are used, are there additional checks to prevent manipulation?
				- Are there safeguards to ensure the reliability of price data from AMMs?
TBD	TBD.147	TBD	FlashCrashPriceInaccuracies	- Does the system have measures to handle inaccuracies in price feeds during flash crashes?
				- If a flash crash occurs, are price feed values validated to be within an acceptable range?
				- Are there safeguards to manage potential flash crash vulnerabilities in price feeds?
TBD	TBD.148	TBD	TimeLockAmplification	- Can users extend another user’s time lock duration by stacking tokens on their behalf?
				- If token stacking is possible, are there checks to prevent unintended extensions of time locks?
				- Are there controls to ensure that time locks cannot be manipulated through token stacking?
TBD	TBD.149	TBD	RewardDistributionManipulation	- Can reward distribution be manipulated to delay or accelerate payouts?
				- If rewards are distributed, are there controls to ensure timely and correct distribution?
				- Are there mechanisms to prevent premature or delayed reward claims?
TBD	TBD.150	TBD	UpdateRewardsFunction	- Does the updateRewards function get called appropriately before relevant operations?
				- Can the reward update function be overlooked or missed in any use-case scenarios?
				- Are there checks to ensure that rewards are up-to-date in all relevant cases?
TBD	TBD.151	TBD	InconsistentLogicImplementations	- Can inconsistent implementations of the same logic lead to errors or vulnerabilities?
				- If logic is implemented in multiple places, are there measures to ensure consistency?
				- Are there checks to standardize and consolidate repeated logic into a single function?
TBD	TBD.152	TBD	NestedStructureDeletion	- Does the contract use nested structures, and if so, are inner fields properly reset when outer fields are deleted?
				- Can failure to reset nested fields lead to unintended behavior?
				- Are there mechanisms to ensure all levels of nested structures are handled during deletion?
TBD	TBD.153	TBD	SenderRecipientConsistency	- Are there checks to ensure that behavior is correct when src equals dst (or caller equals receiver)?
				- If src and dst are the same, does the protocol maintain expected behavior?
				- Can unintended issues arise when the sender and recipient are identical?
TBD	TBD.154	TBD	ModifierOrder	- Is the NonReentrant modifier correctly placed before other modifiers?
				- Can the order of modifiers influence function behavior or security?
				- Are there checks to ensure that NonReentrant comes before other modifiers in all relevant functions?
TBD	TBD.155	TBD	TryCatchGas	- Does the try/catch block account for potential gas shortages?
				- Can insufficient gas lead to failure in try/catch blocks?
				- Are there safeguards to ensure sufficient gas is provided for try/catch operations?
TBD	TBD.156	TBD	EIPImplementation	- Did the implementation follow all relevant EIP recommendations and security concerns?
				- If EIP recommendations are used, are they implemented correctly and completely?
				- Are there checks to ensure adherence to EIP recommendations and security guidelines?
TBD	TBD.157	TBD	OffByOneErrors	- Can off-by-one errors occur in the contract, such as using <= instead of <?
				- If variables are set to the length of a list or the length minus one, is this done correctly?
				- Are there any potential off-by-one errors in iterations or boundary conditions?
TBD	TBD.158	TBD	LogicalOperators	- Are logical operators such as ==, !=, &&, ||, and ! used correctly?
				- If there are logical conditions, are they implemented accurately and thoroughly tested?
				- Are there potential issues with the use of logical operators that could affect contract behavior?
TBD	TBD.159	TBD	UnexpectedAddressInputs	- What happens if addresses of the protocol’s contracts are used as if they are normal actors?
				- Can unexpected addresses lead to unintended behaviors or vulnerabilities?
				- Are there checks in place to validate the addresses and ensure proper protocol behavior?
TBD	TBD.160	TBD	RoundingErrors	- Are there rounding errors that can be magnified or cause significant issues?
				- If rounding errors occur, can they be amplified through repeated function invocations or specific conditions?
				- Are there safeguards to prevent rounding errors from adversely affecting the system or its users?
TBD	TBD.161	TBD	UninitializedState	- Is there any uninitialized state being incorrectly identified by default values?
				- Can relying on default values for state detection lead to vulnerabilities?
				- Are there alternative methods to verify initialization status beyond default values?
TBD	TBD.162	TBD	FunctionInvocationUniqueness	- Can functions be called multiple times with identical parameters, potentially causing issues?
				- If functions are designed to be unique per parameters, are there measures to prevent duplicate calls?
				- Are there controls to ensure that functions are invoked correctly without unintended repetitions?
TBD	TBD.163	TBD	GlobalStateMemory	- Can failures occur if the global state is not updated correctly when using memory?
				- If a memory copy is used for optimization, are global state changes accurately mirrored?
				- Are there tools or practices in place to highlight discrepancies between memory and global state?
TBD	TBD.164	TBD	ETHWETHHandling	- Does the contract correctly differentiate between ETH and WETH handling?
				- Are there checks to prevent errors due to assumptions of exclusivity between ETH and WETH?
				- If special logic is applied for ETH and WETH, is it implemented correctly and without overlap?
TBD	TBD.165	TBD	BlockchainSensitiveData	- Does the protocol store any sensitive data on the blockchain, and if so, how is it protected?
				- Can sensitive data marked 'private' in smart contracts be exposed through blockchain queries or transaction analysis?
				- Are there measures to ensure sensitive data is either kept off-chain or encrypted securely before being stored on-chain?
TBD	TBD.166	TBD	CodeAsymmetries	- Are there any asymmetries between paired functions, such as withdraw not properly undoing changes made by deposit?
				- Does each function correctly counteract the state changes of its paired function?
				- Are there missing functions or fields, such as lacking a function to remove from a whitelist when there is one to add?
TBD	TBD.167	TBD	FinancialOperationConsistency	- Does calling a function multiple times with smaller amounts produce the same contract state as calling it once with the aggregate amount?
				- Are there inconsistencies or unintended discrepancies when performing financial operations in parts versus as a whole?
				- If variations exist, are they intentional and well-documented, or do they indicate potential issues?
TBD	TBD.168	TBD	cETHTokenIntegration	- Does the protocol use the cETH token, and if so, how is the absence of underlying() handled?
				- If cETH token integration is utilized, are there any issues or errors due to the absence of the underlying() function?
				- Are integration tests performed to ensure proper functionality with the cETH token?
TBD	TBD.169	TBD	HighUtilizationRate	- What mechanisms are in place to handle scenarios where the utilization rate is too high to allow for collateral withdrawal?
				- If the utilization rate exceeds acceptable levels, are there fallback strategies for collateral retrieval?
				- Does the protocol have safeguards for user withdrawals in case of high utilization rates?
TBD	TBD.170	TBD	AAVEProtocolPaused	- What happens to protocol interactions if the AAVE protocol is paused?
				- Are there contingency plans or alternative mechanisms in place if AAVE is paused?
				- Does the protocol handle the paused state of AAVE without causing disruptions?
TBD	TBD.171	TBD	DeprecatedPools	- What mechanisms are in place to handle pools that become deprecated?
				- If a pool is deprecated, how does the protocol adjust or manage its operations?
				- Are there fallback strategies for deprecated pools to avoid service interruptions?
TBD	TBD.172	TBD	eModeCategoryAssets	- What are the rules or limitations when lending or borrowing assets within the same eMode category?
				- Does the protocol handle transactions involving assets in the same eMode category without issues?
				- Are there constraints in place for interacting with assets in the same eMode category?
TBD	TBD.173	TBD	FlashLoansPoolIndex	- Do flash loans impact the pool index, and if so, how is this managed?
				- Are there mechanisms to mitigate the effects of flash loans on the pool index?
				- How does the protocol address the maximum number of flash loans per block affecting the pool index?
TBD	TBD.174	TBD	RewardClaimsImplementation	- Does the protocol properly implement AAVE/COMP reward claims?
				- Are there any discrepancies in the implementation of reward claims for AAVE/COMP?
				- How is the accuracy of reward claims ensured and tested?
TBD	TBD.175	TBD	MaximumDebtIsolatedAsset	- What happens when a user reaches the maximum debt on an isolated asset?
				- Are there safeguards in place to handle maximum debt scenarios on isolated assets?
				- Does the protocol handle these conditions without causing disruptions or limitations?
TBD	TBD.176	TBD	SiloedAssetBorrowing	- Does borrowing an AAVE siloed asset prevent borrowing of other assets?
				- How does the protocol manage borrowing restrictions for siloed assets?
				- Are there checks in place to enforce borrowing limitations for siloed assets?
TBD	TBD.177	TBD	BalancerFlashloanFees	- Does the protocol currently use Balancer's flash loans, and how are potential fees handled?
				- If Balancer implements flash loan fees in the future, how will the protocol manage these fees?
				- Are there mechanisms to ensure the repayment of fees along with the original debt in the receiveFlashLoan function?
TBD	TBD.178	TBD	BalancerOraclePricing	- Does the protocol rely on Balancer's Oracle for pricing?
				- If Balancer's Oracle is used, are there safeguards against price updates that do not reflect the true asset value?
				- What are the potential risks of using Balancer's Oracle, and how are they mitigated?
TBD	TBD.179	TBD	BalancerBoostedPoolSupply	- Does the protocol use Balancer's Boosted Pool, and if so, does it use virtualSupply correctly?
				- How is the total BPT supply in circulation determined in the context of Balancer's Boosted Pool?
				- Are there any discrepancies in using virtualSupply versus totalSupply?
TBD	TBD.180	TBD	BalancerVaultPoolLiquidity	- Does the protocol use Balancer vault pool liquidity status for pricing or other calculations?
				- How is the protocol protected against manipulation of token balances and BPT supply in Balancer pools?
				- Are there precautions in place to prevent inaccuracies caused by manipulation of external queries?
TBD	TBD.181	TBD	ChainlinkVRFParameters	- Are all parameters thoroughly verified before calling Chainlink VRF to ensure correct results?
				- What mechanisms are in place to validate parameters for Chainlink VRF calls?
				- How does the protocol handle potential issues with parameter verification in Chainlink VRF?
TBD	TBD.182	TBD	ChainlinkVRFSubscription	- Is it ensured that sufficient LINK is maintained in the Chainlink VRF subscription to avoid pending states?
				- How does the protocol handle scenarios where the subscription is low on LINK?
				- What measures are in place to prevent vulnerabilities related to insufficient LINK in the Chainlink VRF subscription?
TBD	TBD.183	TBD	RequestConfirmationNumber	- Is the request confirmation number chosen high enough to account for potential chain re-orgs?
				- What considerations are made to evaluate the chain's vulnerability to re-orgs?
				- Are there adjustments made to the request confirmation number based on re-org risk assessments?
TBD	TBD.184	TBD	VRFCallFrontrunning	- Are there measures implemented to prevent frontrunning of VRF calls?
				- How does the protocol ensure user interactions are closed before initiating a VRF call?
				- What safeguards are in place to prevent exploitation of VRF call timing?
TBD	TBD.185	TBD	GuardHooksExecution	- Are the Guard's hooks (checkTransaction(), checkAfterExecution()) executed properly in your modules?
				- If not executed, could critical security checks be bypassed?
				- How does the protocol ensure the execution of these hooks?
TBD	TBD.186	TBD	NonceIncrementInExecTransaction	- Does the execTransactionFromModule() function increment the nonce appropriately?
				- What mechanisms are in place to ensure the nonce is incremented?
				- Can issues arise if the nonce is not incremented in this function?
TBD	TBD.187	TBD	DebitFromFunctionValidation	- Does the _debitFrom function properly verify token ownership and transfer permissions?
				- Are there any gaps in validation that could impact token security?
				- How does the function ensure that only authorized transfers occur?
TBD	TBD.188	TBD	BlockingMechanismRisk	- Does the system use blocking or non-blocking mechanisms?
				- Can the use of a blocking mechanism lead to a DoS attack?
				- What are the risks associated with the current mechanism used?
TBD	TBD.189	TBD	GasEstimationAccuracy	- Is gas estimated accurately for cross-chain messages?
				- What measures are in place to validate gas estimates?
				- Can inaccuracies in gas estimation lead to message failures?
TBD	TBD.190	TBD	LzAppFunctionUtilization	- Is the _lzSend function correctly utilized in place of direct lzEndpoint.send calls?
				- Are there vulnerabilities associated with using direct calls to lzEndpoint.send?
				- How does the protocol ensure proper usage of _lzSend?
TBD	TBD.191	TBD	LayerZeroUserApplicationConfig	- Is the ILayerZeroUserApplicationConfig interface implemented correctly?
				- Does the implementation include the forceResumeReceive function?
				- How does the system handle unexpected scenarios that require unblocking the message queue?
TBD	TBD.192	TBD	DefaultContractConfiguration	- Are default configuration contracts used in the application?
				- What steps are taken to ensure applications are configured uniquely?
				- How are default settings avoided in the contract configuration?
TBD	TBD.193	TBD	ConfirmationNumberChoice	- Is the number of confirmations chosen appropriate for the chain's history and risks?
				- How does the choice of confirmations address past reorg events?
				- Are there any adjustments made based on the chain's reorg vulnerabilities?
TBD	TBD.194	TBD	cbETHRateControl	- How is control over the cbETH/ETH rate determined?
				- Are there specific addresses with control due to the onlyOracle modifier?
				- Can centralization risks or manipulations arise from this control?
TBD	TBD.195	TBD	cbETHRateDecreaseImpact	- How does the system handle potential decreases in the cbETH/ETH rate?
				- What mechanisms are in place to inform users about significant rate changes?
				- Can users be affected by a dramatic decrease in the cbETH/ETH rate?
TBD	TBD.196	TBD	EthereumBeaconChainPenalties	- Does the application account for potential penalties or slashes from validator misbehavior?
				- How are these potential penalties or slashes reflected in the value of rETH?
				- Are there mechanisms to manage or mitigate the impact of such penalties on rETH?
TBD	TBD.197	TBD	StakingRewardsManagement	- How does the system manage rewards accrued from staking?
				- Are these rewards properly accounted for in the management of rETH?
				- What mechanisms are in place to ensure accurate distribution of staking rewards?
TBD	TBD.198	TBD	RocketDepositPoolBurnHandling	- Does the system handle potential reverts in the burn() function when there is insufficient ether in the RocketDepositPool?
				- Is there a mechanism to prevent or manage failures in the burn() function?
				- Can the application gracefully handle a revert due to insufficient ether?
TBD	TBD.199	TBD	ConsensusAttackMitigation	- What measures are in place to counteract potential consensus attacks on RPL nodes?
				- Does the system have a method to correct incorrect data submissions by nodes?
				- Are there safeguards against discrepancies in exchange rate data due to malicious node behavior?
TBD	TBD.200	TBD	ETHtoRETHConversionHandling	- How does the system manage the conversion rate between ETH and rETH?
				- Is the conversion rate updated to reflect changes in staking rewards?
				- Does the system accurately capture the dynamic nature of the ETH to rETH conversion?
TBD	TBD.201	TBD	SfrxETHDetachmentHandling	- Does the system handle potential detachment of sfrxETH from frxETH during reward transfers?
				- Is there transparency regarding actions of the Frax team's multi-sig contract in managing sfrxETH and frxETH?
				- Are mechanisms in place to alert users about discrepancies between sfrxETH and frxETH?
TBD	TBD.202	TBD	SfrxETHRateStability	- Does the system guarantee the stability of the sfrxETH/ETH rate, or can it change in the future?
				- Are users informed about potential changes to the sfrxETH/ETH rate?
				- Is there documentation available regarding the stability and future changes of the sfrxETH/ETH rate?
TBD	TBD.203	TBD	StETHRebasingAwareness	- Is the application aware of the rebasing nature of stETH?
				- Does the system consider using wstETH for simpler DeFi integrations?
				- Are there mechanisms in place to handle complexities introduced by rebasing tokens?
TBD	TBD.204	TBD	StETHWithdrawalOverheads	- Does the system account for overheads when withdrawing stETH or wstETH?
				- Are there mechanisms in place to handle queue time and limits associated with withdrawals?
				- How does the protocol address issues related to NFT receipt and withdrawal amount limits?
TBD	TBD.205	TBD	StETHtoWstETHConversion	- Does the system handle conversions between stETH and wstETH accurately?
				- Are the rebasing characteristics of stETH managed correctly during conversions?
				- What measures are in place to ensure correct handling of stETH to wstETH conversions?
TBD	TBD.206	TBD	OnChainSlippageCalculation	- Is slippage calculated on-chain?
				- Can users specify the slippage parameter in the asset amount?
				- What measures are in place to ensure accurate slippage calculation?
TBD	TBD.207	TBD	RefundsForFailedOrders	- Does the protocol issue refunds for failed or partially filled orders?
				- What mechanisms are in place to handle refunds after swaps?
				- Are there clear procedures for managing failed or incomplete transactions?
TBD	TBD.208	TBD	TokenOrderConsistency	- Is the order of token0 and token1 consistent across different chains?
				- What steps are taken to verify token order when interacting with various chains?
				- Can inconsistencies in token order impact functionality?
TBD	TBD.209	TBD	PoolVerification	- Are the pools being interacted with whitelisted?
				- How does the system verify the pool's factory address before interaction?
				- Are there risks associated with interacting with non-whitelisted pools?
TBD	TBD.210	TBD	PoolReservesReliance	- Is there excessive reliance on pool reserves?
				- What alternative methods or checks are implemented to mitigate risks associated with pool reserves?
				- Can pool reserves be manipulated through techniques like flashloans?
TBD	TBD.211	TBD	DirectPoolSwapUsage	- Is pool.swap() used directly in the application?
				- What security mechanisms are bypassed by using pool.swap() directly?
				- Does the system use the Router contract for swaps to enhance security?
TBD	TBD.212	TBD	UniswapMathLibrariesUsage	- Is unchecked used appropriately with Uniswap's TickMath and FullMath libraries?
				- How does the application ensure compliance with Solidity version specifics regarding unchecked?
				- Are there any safety concerns with the current usage of unchecked?
TBD	TBD.213	TBD	IntermediateSwapSlippage	- Is the slippage parameter enforced at the last step before transferring funds to users?
				- How is slippage enforced during the final fund transfer step?
				- Does the system check the slippage parameter before completing transactions?
TBD	TBD.214	TBD	Slot0Manipulation	- Is pool.slot0 used for calculating sensitive information like current price and exchange rates?
				- What alternatives are used for sensitive calculations to avoid manipulation risks?
				- Are secure mechanisms like UniswapV3 TWAP or Chainlink Price Oracle used for price and rate calculations?
TBD	TBD.215	TBD	HardCodedFeeTier	- Is there a hard-coded fee tier parameter in swap functions?
				- Can users specify the fee tier parameter when initiating Uniswap V3 swaps?
				- What impact does hard-coding the fee tier have on swap functionality?
TBD	TBD.216	TBD	InputDataValidation	- Is there validation on the size of the input data?
				- How does the system handle input data that exceeds the expected size?
				- Are there measures to revert or clean unused bits if data size is invalid?
TBD	TBD.217	TBD	FunctionSignatureMatching	- What happens if there is no matching function signature in the contract?
				- Does the code revert if no supported function signature or fallback is matched?
				- How does the system handle unmatched function signatures?
TBD	TBD.218	TBD	CodePresenceCheck	- Is it checked if the target address of a call has code deployed?
				- How does the system handle calls to addresses without code?
				- What mechanisms are in place to verify code presence before making calls?
TBD	TBD.219	TBD	PrecompiledCodeReturnSize	- Is there a check on the return data size when calling precompiled code?
				- How does the system handle calls to precompiled code that return a size of 0?
				- What checks are in place for detecting failures in precompiled code calls?
TBD	TBD.220	TBD	ZeroDenominatorCheck	- Is there a non-zero check for the denominator before division or modulo operations?
				- How does the system handle division or modulo by zero in Yul/inline assembly?
				- What measures are in place to prevent division or modulo by zero?
TBD	TBD.221	TBD	BlockTimeConsistency	- Are there hardcoded time values dependent on block.number?
				- What impact does block time variability have on the protocol?
				- How does the system address potential timing discrepancies?
TBD	TBD.222	TBD	ChainCompatibility	- Has the protocol been reviewed for compatibility with target chains?
				- What steps are taken to address differences between chains?
				- How does the system ensure compatibility with various chains?
TBD	TBD.223	TBD	EVMOpcodeCompatibility	- Are the EVM opcodes and operations used by the protocol compatible across all targeted chains?
				- What steps are taken to ensure compatibility with chains like Arbitrum and Optimism?
				- How does the system handle unsupported EVM operations?
TBD	TBD.224	TBD	SenderBehaviorConsistency	- Does the expected behavior of tx.origin and msg.sender remain consistent across all deployment chains?
				- What testing is performed to verify consistency of tx.origin and msg.sender?
				- How does the system handle inconsistencies in tx.origin and msg.sender?
TBD	TBD.225	TBD	GasFeeExploitation	- Is there a risk of exploiting low gas fees to execute a high volume of transactions?
				- What measures are in place to mitigate potential attacks associated with low gas fees?
				- How does the system address issues related to transaction volume and gas costs?
TBD	TBD.226	TBD	ERC20DecimalsConsistency	- Is there consistency in ERC20 token decimals across different chains?
				- What measures are taken to handle discrepancies in ERC20 decimals?
				- How does the system ensure uniformity in token decimals across chains?
TBD	TBD.227	TBD	ContractUpgradability	- Have contract upgradability implications been evaluated for different chains?
				- What upgradability characteristics are documented for each chain?
				- How does the system address upgradability differences across chains?
TBD	TBD.228	TBD	CrossChainMessagingSecurity	- Have cross-chain messaging implementations been thoroughly reviewed for permissions and functionality?
				- What security checks are in place for cross-chain messaging?
				- How does the system ensure correct permissions for cross-chain messages?
TBD	TBD.229	TBD	UnsupportedChainMessages	- Is there a whitelist of compatible chains for message handling?
				- What measures are in place to block messages from unsupported chains?
				- How does the system handle messages from non-whitelisted chains?
TBD	TBD.230	TBD	zkSyncEraCompatibility	- Have contracts been checked for compatibility with zkSync Era?
				- What specific requirements or differences are considered for zkSync Era deployments?
				- How does the system address compatibility issues with zkSync Era?
TBD	TBD.231	TBD	BlockProductionConsistency	- Is block production consistency ensured in the protocol?
				- How does the system handle potential inconsistencies in block production?
				- What measures are in place to address unexpected application behaviors due to block production variability?
TBD	TBD.232	TBD	Push0Support	- Is the PUSH0 opcode supported for Solidity version >=0.8.20 on the target chain?
				- What compatibility checks are performed for the PUSH0 opcode?
				- How does the system handle chains that do not support PUSH0?