1. Storage and Memory Manipulation:
Add State-Changing Operation in Receive Function
Change SHA3 Operation Storage Assignment
Modify Storage Slot Using Alternate Identifier
MisinterpretMemoryAsCallResult
Inline Assembly Removal from Memory Copy
Uninitialized Memory Allocation
Add Conditional Variable Reset in Loop
Alter Storage Slot Manipulation
Alter Memory Storage and Load Order
Calldata to Memory Conversion
Uninitialized Memory Array Mutation to Storage
Large Memory Allocation Overflow Mutation
Zero-Length Dynamic Array Initialization
Memory to Storage Pointer Confusion
Modify State Variable Initialization
Unexpected State Persistence Mutation
Remove Fallback Function
State Array Element Manipulation
Modify array length access to int mismatch
Modify Array Length to Negative Value
Replace length with variable arithmetic operation
Expand Array Initialization with Overflow Intent
Increase dynamic array length beyond expected
Insert Uninitialized Struct Member Access
Read Buffer as Non-Int and Apply mulmod
Modify array access with complex storage pattern
Modify Bytes to Dynamic Array
Replace Safe Access with Unsafe Buffer Read
insert_uninitialized_storage_reference
Insert redundant storage load
Modify Dynamic Array Initialization
Modify array length without bounds check
Modify reference variable initialization to nullified state
Modify storage array type specifier
Modify Dynamic Type Assignment with Identical Type
Modify Identical Storage Load After Store
Modify Array Concatenation to Increase Size Misalignment
Mismatched Dynamic to Static Bytes Conversion
Uninitialized Dynamic Array Access
Mismatched Storage and Memory Array Assignments
Introduce Unreachable Storage After Return
Exceed Storage Byte Array Index
Uninitialized Dynamic Type Load
Modify ArrayLengthInExpressionToMulMod
Modify Array Length in MulMod
Uninitialized Dynamic Array Access
Modify ArrayLengthInExpressionToMulMod
Introduce Unnecessary Storage Reloads
Add Dynamic Storage Deallocation with Missing Function Definition
Modify Array Length Access to Trigger Byte Order Reversal
2. Array and Struct Manipulation:
Convert Fixed-Size Array to Dynamically-Sized Array in Struct
Replace Non-Zero Start Index with Larger Value
Array Slice Malformation via Start Index Increment
Expand Storage Array
Nested Array Bounds Misinterpretation
Replace Direct Call with Manual ABI Encoding
Array Return Element Swap
Return Array and Access Element Outside Function
Alter Memory Array Dimension
Expand Storage Element Size
Reduce Elements in Struct
Change Struct Member Size
Alter Array Access to Fixed Iteration Count
Array Length Overflow Mutation
Increase Static Array Size in Struct
Struct Field Size Reduction
StructSub32ByteDirectEncodeDecode
Increase Shift Value by One
Convert uint8 to uint16 in Array
Introduce Out-of-Bounds Index Access
Packed Array Direct Update
Insert Early Return
Alter Break Condition in Loop
Replace Array Length with Invalid Cast
Insert Overflowing Rationals
Modify Dynamic Array Indices
Insert Array Length Addition with Hardcoded Value
Insert dynamic array in struct
Modify Dynamic Array Initialization
Modify array initialization
Modify multiplicative operands with incompatible types
Introduce Redundant Storage Write
Insert Empty Const Array Declaration
Modify array to incorrect buffer read
Modify Function Return with Byte Slice
Increase Struct Complexity
AddUninitializedAddressFieldToStruct
insert nested dynamic address storage deallocation
3. Type Casting and Data Location Modifications:
Replace calldata with memory
Replace Memory with Calldata in Internal Function
Alter Data Location in Overridden Function Parameters
Change data location of override function call
Promote Exponent Type to Match Base Type
Manipulate Non-Literal Exponent
Change Constant Index Access in Assembly
Add Random Element Before Push
Emit Event with Unused Array Parameter
Replace uint256 with larger surrogate in buffer reads
Modify Integer to Address Casting
Replace uint256 with uint8 in type casting
Modify Address Initialization in Comparison
Modify Integer Type Casting Compatibility
Modify Integer Type Conversion
Replace integer comparison with address comparison in LessEqual
replace integer with address in GT comparison
Modify address comparison
Modify Integer to Address casting via conversion function
replace integer with incompatible type in comparison
Replace Integer with Fraction in Multiplication
Modify Integer Arithmetic to Address Casting
Modify Array Access to Assembly Buffer Read
modify divisor to zero
Modify Integer Typecasting to Address
Inject Unreachable Code with Dead Storage Load
Modify Integer to Signed Type
Modify address to contract casting byte size mismatch
Modify internal function signature to address
Modify Address to Contract conversion
Modify integer comparison in Greater Than Expression
modify address metadata for implicit conversion edge case
4. Function and Parameter Modifications:
Incorrect Boolean Interpretation in Delegatecall
Return Type Mismatch in Delegatecall
Swap Argument Evaluation Order
Inline Function with Side-Effect-Free Check
Change Library Function to External
Externalize Internal Function Call
Alter Internal Function Logic
Alias Function Shadowing
Duplicate Free Function Mutation
Add Duplicate Function
Alter Function Visibility to Introduce Collision
Incorrect Selector Evaluation through Variable Overwrite
External Function within Limit
Modify Payable Function Logic
modify function params structure
Modify Function Return with Byte Slice
modify external function conversion to address
insert type casting in integer comparisons
modify internal function parameters
modify function return casting from smaller to larger int
modify function signature for internal function identity conversion
modify function signature to unknown
modify function to unexpected inheritance
insert type casting for address
replace address with byte array in function call
introduce frequent storageload
modify internal function conversion to address
5. Contract Modifications:
Swap Argument Order
Change Library Function to External
Replace Address with Dummy Contract
Move Event Emission Outside of Internal Function
Replace mstore with sstore
Add External Function within Limit
Remove Fallback Function
replace address with contracts
Modify Address and Contract Storage Fit in Arrays
Introduce Dynamic Contract Variables in Storage
Replace Address with Invalid Address/Hash
Modify Byte Array Index with Larger Integer
Modify Contract with invalid address comparison
6. Contract Constructor Modifications:
Introduce Incorrect Backslash Handling
Convert New Constructor to Old-Style
Omit Payable Keyword in Constructor
Parameterize Derived Without Constructor
7. Function and Call Modifications:
Inject Zero Ether Call
MisinterpretMemoryAsCallResult
Swap Tuple Elements
Replace Assembly mload with Safe Wrapper Function
Replace Direct Call with Manual ABI Encoding
Remove Assembly Result Check
Relay To Different Library Function
Insert-External-Call-Between-Assignments
Add Early Exit with Continue
Modify Integer to Address Casting
Modify: Cast Dynamic Bytes to Oversize Static
Replace function with invalid address comparison
Modify function params structure
Insert Unsupported Array Type
Cast External Function to Different Function Representation
Insert Redundant ReadFromBuffer on Array
Insert Redundant Storage Write
8. External Calls and Reentrancy:
Incorrect Address to String Encoding
Swap External Input Dependency
Add Redundant Variable and Continue
Add State-Changing Operation in Receive Function
Replace Memory with Calldata in Internal Function
Replace External Function Cast with Different Size Type
Replace External Function with invalid address comparison
alter external call to non-existing function
9. Self-Destruct and Termination Changes:
None specifically identified in the list.
None
10. Literal Modifications:
Replace String Literals with Empty String
String Payload Emission Adjustment
Alter Event String Literal
Introduce Mixed Constructor Style
Alter Keccak256 Argument Order
Wrap ecrecover in Inline Verification
modify string comparison by concatenation
replace integer division with rational-like expression
modify literal_to_coerce_error
replace literal with reference for storage assignment
11. Address and Hexadecimal Modifications:
ContractTypeInHashInsteadOfAddress
Incorrect Hash Calculation in Event Emission
Use Incorrect Hash Encoding Mechanism
Modify Address Initialization in Comparison
Replace address with byte array for comparison
Replace uint with struct contain uint
Replace uint256 with uint8 in type casting
Modify address metadata for implicit conversion edge case
Modify address to contract conversion
Treat Address as Integer
Modify Address to Contract conversion
Replace address with address-byte-array
exchange addresses with contracts
Replace address type with incompatible slice type
Replace address with bytes in dynamic context
Modify reference type comparison for address and contract
12. Encoding and Decoding Mutations:
Replace Calldata Array with Memory Array in Encoding
Calldata to Memory Conversion
Change Encoding Method
ABI Mismatch Inducer
Modify Constant Value
Alter ABI decoding
Modify ABI Decode With Nonexistent Data
Insert Unsupported Array Type
Insert erroneous internal function slice conversion
13. Arithmetic and Logical Expression Mutations:
Arithmetical Operation Replacement with Subtraction
Misalignment in Arithmetic and Bitwise Operations
Bitwise XOR to AND Mutation
Loop Condition Inversion
Negate Conditional Check
Replace Break with Conditional Continue
Modify Integer Typecasting in Arithmetic Operations
Modify Integer Operand to Non-integer Type
Increase Integer Size for Truncation Check
modify arithmetic_expression_inside_hash
inject type mismatch in modulo
Replace Integer with Fraction in Multiplication
Insert Overflowing Rationals
Introduce Invalid Expression Type
Modify Logical to Bitwise
Introduce Non-Boolean in Logical Not
Replace Static Variable Declaration with Conditional Dynamic Allocation
Modify Multiplicative Operands with Incompatible Types
modify multiplication with rational operation
14. Buffer and Byte Operations:
Incorrect Byte Mask Application
Introduce Redundant Bitwise Masking
Modify Bit Masking
Introduce Incorrect Backslash Handling
Incorrect Byte Clearing on Element Update
Read Buffer as Non-Int and Apply mulmod
Modify memory offset in readFromBuffer
Replace Array Length with Invalid Cast
modify array initialization
Modify Dynamic Bytes to Slice Conversion Misalignment
Insert Redundant ReadFromBuffer on Array
Cast Dynamic Bytes to Oversize Static
15. Storage and State Variable Mutations:
Add Redundant Variable and Continue
Add Conditional Variable Reset in Loop
Relocate Variable Declaration in Loop
Loop Control Flow Alteration with Variable Side Effects
Alter Type Conversion Operation
Change Storage Slot Access
Modify Storage Slot Using Alternate Identifier
Modify storage access
Modify Array Length Access
Modify storage array type specifier
Modify Identical Storage Load After Store
Modify Array Concatenation to Increase Size Misalignment
Uninitialized Dynamic Array Access
16. Immutable Variable Manipulations:
Change Signed Integer Variable to Immutable
None
17. Value Transfer and Ether Manipulations:
Inject Zero Ether Call
Remove Zero Out on Overflow in Logical Shifts
None
18. Error and Invalid Modifications:
Incomplete Storage Array Clearance
Incomplete Zeroing After Array Resize
Zero Selector Function Removal
ABI Mismatch Inducer
Insert Uninitialized Struct Member Access
Modify Bytes to Dynamic Array
Replace length with variable arithmetic operation
Replace Array Length with Invalid Cast
insert_uninitialized_storage_reference
Modify array initialization
Modify function to unexpected inheritance
inject Unreachable Code with Dead Storage Load
Inject Unresolved Function Type
19. Miscellaneous:
Increase Nested Shift Depth
Excessive Shift Adjustment
Relay To Different Library Function
Inject In-loop Reassignment
Alter Constructor Function Pointer Call
Increase Shift Value by One
Alter Break Condition in Loop
Modify State Variable Initialization
Unexpected State Persistence Mutation
Remove ABIEncoderV2 Activation
Insert Assembly Return
Insert Early Return
Insert Conditional Reference Type Allocation
Modify Integer Casting Compatibility
Replace array with address in parameter
Replace uint with struct containing uint
Insert Empty Const Array Declaration
Insert Redundant Storage Write
1. Storage and Memory Manipulation
Modify Storage Key-Value Allocation
Increase Storage Key-Value Allocation
Increase Redundant Storage Writes
Increase state variable data size
Increase Data Complexity in Storage Update
Explicit storage deletion with complex key
Modify Storage Structure and Hash
Modify Key Hash Generation
Modify Storage Slot Condition Handling
Modify Storage Data Type
Replace Storage Entry with Invalid Key
Modify Storage Key Hash Type
Insert Redundant Storage Write
Explicit Delete on Initialized Storage Variable
Modify Data Location for Simple Types
Remove Data Location Specifier for Complex Types
Remove Data Location for Complex Type Parameter
Replace Data Location with Transient
Assign Transient to Non-Reference Type Variables
Assign Transient Data Location to File-Level Variable
Replace State Variable Location with Transient
Modify Struct Member with Unsupported Data Location
2. Array and Struct Manipulation
Add Large Dynamic Array Initialization
Insert Recursive Struct References
Introduce Recursive Struct Definition
Add Dynamic Array Field in Recursive Struct
Append Recursive Field to Struct
Insert Dynamic Array in Self-Referencing Struct
Deep Recursive Dynamic Array Expansion
Increase Struct Nesting Depth
Nest Structs Excessively
Increase Struct Nesting Depth with Dynamic Arrays
Add Recursive Struct Reference
Introduce Dynamic Array in Recursive Struct
3. Type Casting and Data Location Modifications
Modify Internal Call with External Call
Modify delegatecall dependency registration
Modify Value Type with Invalid Data Location
Modify Function Visibility in Complex Types Context
Omit Data Location for Reference Types
Replace Valid Constant Array Size with Invalid Expression
Replace Mapping Key with Dynamic Array
Replace Integer with Unrecognized Type
Replace Valid Address with Invalid Checksum Address
Insert Invalid Function Parameter Types
Modify Function Signature with Unsupported Type
Replace Function Signature with Unmatchable Type
Insert Underscores in Address Hex
Modify Rational with Edge Case Exponents and Fractions
Replace Elementary Type with Non-Elementary in user-defined value type
Modify user-defined value type Base Type to Non-Elementary Type
Insert Non-Numeric Suffix in Numeric Literal
4. Function and Parameter Modifications
Insert immutable constructor check
Modify delegate call callee to incorrect address
Modify constructor to access immutables
Delegate Call in Constructor Accessing Immutable
Insert external call within fallback
Insert Nested External Call
Insert self-call with value transfer
Modify constructor with Reentrant Call
Add Orphaned Delegate Dependencies
Modify delegatecall dependency registration
Modify Function Signature to Have Hash Collision
Create Function Selector Collision
Modify Function Signature with Unsupported Type
Duplicate Function Signature with Different Names
Replace Internal Visibility with Public in Function Declarations
Insert Visibility in Free Function
Add Visibility to Free Function
Insert Modifier in Interface Function
Add Modifier to Abstract Function
Insert Placeholder in Unchecked Block in Modifier
Move Placeholder Statement Outside Modifier
Insert Placeholder in Unchecked Block
5. Contract Modifications
Modify Contract Address
Modify contract code hash to invalidate contract code
Replace contract address with unknown address
Replace valid address with non-existent contract address
Modify contract code hash to invalid
Replace Code Hash With Unknown
Add Non-existent Code Hash
Use Unregistered Code Hash
Modify Contract Inheritance Hierarchy to Exclude Self-Reference
Omit Interface from Inheritance List
Insert Library Inheritance
Inject Parameters to Receive in Library
Remove Payable from Receive Function
Add Parameter to Receive
Insert Global Using Directive in Interface
Insert Global Using Inside Contract
Modify 'Using for Global' Context Inside Contract
Insert Global Using Directive Without Specific Type in Contract
Modify 'Using for' Directive to Undetermined Type at File Level
6. Contract Constructor Modifications
Insert constructor access to immutable
Modify constructor with reentrant call
Modify constructor to access immutables
Modify contract code hash to invalid
Insert assignment to immutable in non-constructor function
Replace Hexadecimal Address Digits
Modify Hex Address with Invalid Characters
Extend Hex Address Length Beyond Limit
Modify Hex Address Beyond u128 Limit
7. Function and Call Modifications
Modify bytecode hash to invalidate contract code
Insert Non-Existent Contract Call
Modify Internal Call with External Call
Modify delegate call dependency registration
Insert recursive delegate calls
Self-Dependency via Code Hash Assignment
Create Function with Colliding Selector
Insert Modifier in Interface Function
Replace Function Signature with Unmatchable Type
8. External Calls and Reentrancy
Insert external call within fallback
Insert Nested External Call
Insert external call in terminate
Insert Reentrant Delegatecall During Termination
Inject Insufficient Balance During Upgrade
Insert Global Using Directive in Interface
Replace Internal Visibility with Public in Function Declarations
9. Termination Changes
Remove Placeholder from Modifier
10. Literal Modifications
Increase Wei Value Beyond Maximum Runtime Capacity
Inject Large Ether Value in Payable Function
Increase Exponent in Floating Point Literal
Increase Exponent Value to Large Negative
Insert Leading Zeros in Integer
Insert Decimal Only with Exponent
Insert Missing Decimal in Exponent Type
Increase Exponent Large Scientific Notation
Modify Trailing Zeroes in Rational Numbers
Modify Decimal Number Literal with Large Negative Exponent
Replace Integer with Large Exponential Notation
Insert Implicit Decimal with Exponential
Insert Missing Integer with Large Exponent
Insert Large Exponent in Numeric Literal
Increase Exponent in Rational Literal
Increase Floating-Point Exponent
Modify Decimal with Leading Zeros
Insert Empty Exponent in Scientific Notation
Insert Empty Exponent
Exaggerate Decimal Exponent
Insert Fractional Zero-Only Literals
Modify Literals with Trailing Zeros in Rationals
Add Trailing Zeros in Decimal Literals with Exponent
Increase Fractional Digits in Decimal Number Literal
Extend Fractional Part
Increase Fraction Length in Scientific Notation
Introduce Empty Decimal to Scientific Notation
Insert Empty Integer Literal
Insert Leading Zero Integer Literal
Replace Integer with Empty Hexadecimal Literal
Modify Decimal Literal with Leading Zeros
Add Leading Zero to Binary Literal
Insert Leading Zero to Binary Literal
Insert Empty Base Prefix Literal
Insert Empty Exponent in Scientific Notation
Replace Integer with Leading Zero
11. Address and Hexadecimal Modifications
Modify Contract Address
Replace contract address with unknown address
Replace valid address with non-existent contract address
Replace Code Hash With Unknown
Insert Non-Existent Contract Call
Replace Hexadecimal Address Digits
Modify Hex Address with Invalid Characters
Extend Hex Address Length Beyond Limit
Modify Hex Address Beyond u128 Limit
Insert Leading Zero in Exponential Integer Part
Modify Hex Address Beyond u128 Limit
Insert Leading Zero to Hexadecimal Address
Prefix Extra Zero in Address
Change Address Prefix
Modify Address Checksum
Insert Invalid Address Characters
Insert Leading Zero to Hexadecimal Address
12. Encoding and Decoding Mutations
Insert Invalid Encoding
Insert Non-Existent Contract Call
Insert Global Using Directive in Interface
Insert Global Using Inside Contract
13. Arithmetic and Logical Expression Mutations
Modify Storage Layout Without Updating References
Modify Rational with Edge Case Exponents and Fractions
Increase Fractional Digits to Overflow u16 Limit
Increase Fraction Digits in Exponent Notation
Insert Excess Decimal Zeros Before Fractional Part
Insert Excessive Fractional Digits
Exaggerate Fractional Digits
Insert Circular Inheritance Hint
Modify Leading Zero Integer Literals
14. Buffer and Byte Operations
Modify bytecode hash to invalidate contract code
Alter incorrect bytecode hash
Insert Leading Zeros in Integer Literals
Modify Leading Zero Integer Literals
15. Storage and State Variable Mutations
Initialize state variable outside constructor
Insert assignment to immutable in non-constructor function
Modify immutable data post-deployment
Modify state variable initialization with invalid size
Add Non-Constant State Variable to Library
Modify State Variable with Unsupported Data Location
Remove Data Location for Complex Type Parameter
Assign Transient Data Location to File-Level Variable
16. Immutable Variable Manipulations
Insert immutable constructor check
Insert assignment to immutable in non-constructor function
Modify Immutable Outside Constructor
Modify immutable variable declaration
Modify Immutable Variable with Excess Data
Access Immutable in Constructor
Introduce Non-Constant State Variable in Library
Introduce Non-Constant Variable in Library
17. Value Transfer and Ether Manipulations
Insert self-call with value transfer
Unchecked value transfer
Inject Large Ether Value in Payable Function
Increase Wei Value Beyond Maximum Runtime Capacity
Inject Insufficient Balance During Upgrade
Inject Parameters to Receive in Library
Remove Payable from Receive Function
18. Error and Invalid Modifications
Insert Invalid Immutable Reference
Replace correct code hash with nonexistent hash
Modify delegate call callee to incorrect address
Insert Invalid Immutable Reference
Modify Immutable Variable with Excess Data
Modify Storage Slot Condition Handling
Replace Valid Address with Invalid Checksum Address
Insert Invalid Function Parameter Types
Insert Underscores in Address Hex
Modify Address Checksum
Replace Existing Type with Non-Existent Type
Replace Function Signature with Unmatchable Type
Insert Invalid Address Characters
19. Miscellaneous
Add state variable to existing contract
Modify Function Modifiers to Access Immutable
Modify constructor to access immutables
Add Orphaned Delegate Dependencies
Modify delegatecall dependency registration
Use Unregistered Code Hash
Self-Dependency via Code Hash Assignment
Insert Invalid Encoding
Insert Placeholder in Unchecked Block
Introduce Leading Zeros in Integer Literals
Replace Numerals with Underscores
Replace Internal Visibility with Public in Function Declarations
Replace Data Location with Transient
Replace Function Signature with Unmatchable Type
Insert Global Using Directive Inside Interface