├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.md │ └── feature_request.md ├── pull_request_template.md └── workflows │ └── secrets_scanner.yaml ├── .gitignore ├── CONTRIBUTING.md ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── SECURITY.md ├── eraLogo.svg ├── eravm ├── default.zasm └── return_calldata_ptr.zasm ├── llvm ├── eravm │ ├── clz.ll │ ├── default.ll │ ├── intrinsics │ │ ├── bswap.ll │ │ ├── ctlz.ll │ │ ├── ctpop.ll │ │ ├── cttz.ll │ │ ├── sadd.sat.ll │ │ ├── sadd.with.overflow.ll │ │ ├── ssub.sat.ll │ │ ├── ssub.with.overflow.ll │ │ ├── uadd.sat.ll │ │ ├── umul.with.overflow.ll │ │ └── usub.sat.ll │ ├── load │ │ ├── load.ll │ │ ├── small_load_known_crossing.ll │ │ ├── small_load_known_lb.ll │ │ ├── small_load_known_mid.ll │ │ ├── small_load_known_rb.ll │ │ └── small_load_unknown.ll │ ├── memcpy │ │ ├── memcpy_as1_as3_36.ll │ │ ├── memcpy_as1_as3_36n.ll │ │ ├── memcpy_as1_as3_48.ll │ │ ├── memcpy_as1_as3_48n.ll │ │ ├── memcpy_as1_as3_64.ll │ │ └── memcpy_as1_as3_64n.ll │ ├── memset │ │ ├── memset_0.ll │ │ ├── memset_0n.ll │ │ ├── memset_20.ll │ │ ├── memset_20n.ll │ │ ├── memset_32.ll │ │ ├── memset_32n.ll │ │ ├── memset_41.ll │ │ ├── memset_41n.ll │ │ ├── memset_64.ll │ │ └── memset_64n.ll │ ├── signed-operations │ │ ├── sdiv.i256.ll │ │ ├── sdiv.i8.ll │ │ ├── sdivrem.i256.ll │ │ ├── sdivrem.i8.ll │ │ ├── srem.i256.ll │ │ ├── srem.i8.ll │ │ ├── udivrem.i256.ll │ │ └── udivrem.i8.ll │ ├── stack │ │ ├── array_allocation_fix_index.ll │ │ └── array_allocation_variable_index.ll │ └── store │ │ ├── small_store_crossing.ll │ │ ├── small_store_lb.ll │ │ ├── small_store_mid.ll │ │ ├── small_store_rb.ll │ │ ├── small_store_unknown.ll │ │ └── store.ll └── evm │ ├── bit-intrinsics │ ├── bitreverse.ll │ ├── bswap.ll │ ├── ctlz.ll │ ├── ctpop.ll │ └── cttz.ll │ ├── complex │ ├── addmod_emul.ll │ ├── byte_emul.ll │ ├── complex_mod.ll │ ├── div_emul.ll │ ├── egcd.ll │ ├── exp_emul.ll │ ├── factorial.ll │ ├── factorial2.ll │ ├── fibonacci.ll │ ├── gcd.ll │ ├── mod_emul.ll │ ├── mret2_call.ll │ ├── mret_call.ll │ ├── mulmod_emul.ll │ ├── sar_emul.ll │ ├── sdiv_emul.ll │ ├── shl_emul.ll │ ├── shr_emul.ll │ ├── signextend_emul.ll │ └── smod_emul.ll │ ├── memcpy │ ├── memcpy_as1_as3_36.ll │ ├── memcpy_as1_as3_36n.ll │ └── memcpy_code.ll │ ├── memset │ └── memset_41.ll │ ├── stdlib │ ├── addmod_stdlib.ll │ ├── byte_stdlib.ll │ ├── div_stdlib.ll │ ├── exp_stdlib.ll │ ├── mod_stdlib.ll │ ├── mulmod_stdlib.ll │ ├── sar_stdlib.ll │ ├── sdiv_stdlib.ll │ ├── sha3_stdlib.ll │ ├── shl_stdlib.ll │ ├── shr_stdlib.ll │ ├── signextend_stdlib.ll │ └── smod_stdlib.ll │ └── storage │ └── storage.ll ├── solidity ├── complex │ ├── array_one_element │ │ ├── callable.sol │ │ ├── main.sol │ │ └── test.json │ ├── call_by_signature │ │ ├── main.sol │ │ ├── storage.sol │ │ └── test.json │ ├── call_chain │ │ ├── first.sol │ │ ├── second.sol │ │ ├── test.json │ │ └── third.sol │ ├── create │ │ ├── create │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── create2 │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── create2_chain │ │ │ ├── first.sol │ │ │ ├── second.sol │ │ │ ├── test.json │ │ │ └── third.sol │ │ ├── create2_many │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── create_chain │ │ │ ├── first.sol │ │ │ ├── second.sol │ │ │ ├── test.json │ │ │ └── third.sol │ │ ├── create_in_library │ │ │ ├── callable.sol │ │ │ ├── library.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ └── create_many │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ ├── default │ │ ├── callable.sol │ │ ├── main.sol │ │ └── test.json │ ├── default_single_file │ │ ├── main.sol │ │ └── test.json │ ├── defi │ │ ├── Mooniswap │ │ │ ├── Migrations.sol │ │ │ ├── MooniFactory.sol │ │ │ ├── MooniswapPool │ │ │ │ ├── ERC20 │ │ │ │ │ ├── ERC20.sol │ │ │ │ │ ├── IERC20.sol │ │ │ │ │ ├── IERC20Metadata.sol │ │ │ │ │ └── SafeERC20.sol │ │ │ │ ├── Mooniswap.sol │ │ │ │ ├── access │ │ │ │ │ └── Ownable.sol │ │ │ │ ├── libraries │ │ │ │ │ ├── Sqrt.sol │ │ │ │ │ └── UniERC20.sol │ │ │ │ ├── math │ │ │ │ │ ├── Math.sol │ │ │ │ │ └── SafeMath.sol │ │ │ │ ├── test.json │ │ │ │ └── utils │ │ │ │ │ ├── Address.sol │ │ │ │ │ ├── Context.sol │ │ │ │ │ └── ReentrancyGuard.sol │ │ │ ├── test_eravm.json │ │ │ └── test_evm.json │ │ ├── UniswapV2Router01 │ │ │ ├── LICENSE.txt │ │ │ ├── UniswapV2Pair │ │ │ │ ├── ERC20 │ │ │ │ │ ├── Context.sol │ │ │ │ │ ├── ERC20.sol │ │ │ │ │ ├── IERC20.sol │ │ │ │ │ ├── IERC20Metadata.sol │ │ │ │ │ └── test.json │ │ │ │ ├── UniswapV2ERC20.sol │ │ │ │ ├── UniswapV2Pair.sol │ │ │ │ ├── interfaces │ │ │ │ │ ├── IUniswapV2ERC20.sol │ │ │ │ │ └── IUniswapV2Pair.sol │ │ │ │ ├── libraries │ │ │ │ │ ├── Math.sol │ │ │ │ │ └── UQ112x112.sol │ │ │ │ └── test.json │ │ │ ├── UniswapV2Router01.sol │ │ │ ├── interfaces │ │ │ │ ├── IERC20.sol │ │ │ │ ├── IUniswapV2Pair.sol │ │ │ │ ├── IUniswapV2Router01.sol │ │ │ │ └── IWETH.sol │ │ │ ├── libraries │ │ │ │ ├── SafeMath.sol │ │ │ │ └── TransferHelper.sol │ │ │ ├── test_eravm.json │ │ │ └── test_evm.json │ │ ├── UniswapV3 │ │ │ ├── IUniswapV2Pair.sol │ │ │ ├── WETH9.sol │ │ │ ├── _init_wrapper.sol │ │ │ ├── base64-sol │ │ │ │ └── base64.sol │ │ │ ├── lib │ │ │ │ └── libraries │ │ │ │ │ ├── AddressStringUtil.sol │ │ │ │ │ └── SafeERC20Namer.sol │ │ │ ├── openzeppelin-contracts │ │ │ │ ├── cryptography │ │ │ │ │ └── ECDSA.sol │ │ │ │ ├── drafts │ │ │ │ │ ├── EIP712.sol │ │ │ │ │ ├── ERC20Permit.sol │ │ │ │ │ └── IERC20Permit.sol │ │ │ │ ├── introspection │ │ │ │ │ ├── ERC165.sol │ │ │ │ │ └── IERC165.sol │ │ │ │ ├── math │ │ │ │ │ ├── SafeMath.sol │ │ │ │ │ └── SignedSafeMath.sol │ │ │ │ ├── token │ │ │ │ │ ├── ERC20 │ │ │ │ │ │ ├── ERC20.sol │ │ │ │ │ │ └── IERC20.sol │ │ │ │ │ └── ERC721 │ │ │ │ │ │ ├── ERC721.sol │ │ │ │ │ │ ├── IERC721.sol │ │ │ │ │ │ ├── IERC721Enumerable.sol │ │ │ │ │ │ ├── IERC721Metadata.sol │ │ │ │ │ │ └── IERC721Receiver.sol │ │ │ │ └── utils │ │ │ │ │ ├── Address.sol │ │ │ │ │ ├── Context.sol │ │ │ │ │ ├── Counters.sol │ │ │ │ │ ├── EnumerableMap.sol │ │ │ │ │ ├── EnumerableSet.sol │ │ │ │ │ └── Strings.sol │ │ │ ├── test_eravm.json │ │ │ ├── test_evm.json │ │ │ ├── v3-core │ │ │ │ ├── NoDelegateCall.sol │ │ │ │ ├── UniswapV3Factory.sol │ │ │ │ ├── UniswapV3Pool.sol │ │ │ │ ├── UniswapV3PoolDeployer.sol │ │ │ │ ├── interfaces │ │ │ │ │ ├── IERC20Minimal.sol │ │ │ │ │ ├── IUniswapV3Factory.sol │ │ │ │ │ ├── IUniswapV3Pool.sol │ │ │ │ │ ├── IUniswapV3PoolDeployer.sol │ │ │ │ │ ├── callback │ │ │ │ │ │ ├── IUniswapV3FlashCallback.sol │ │ │ │ │ │ ├── IUniswapV3MintCallback.sol │ │ │ │ │ │ └── IUniswapV3SwapCallback.sol │ │ │ │ │ └── pool │ │ │ │ │ │ ├── IUniswapV3PoolActions.sol │ │ │ │ │ │ ├── IUniswapV3PoolDerivedState.sol │ │ │ │ │ │ ├── IUniswapV3PoolEvents.sol │ │ │ │ │ │ ├── IUniswapV3PoolImmutables.sol │ │ │ │ │ │ ├── IUniswapV3PoolOwnerActions.sol │ │ │ │ │ │ └── IUniswapV3PoolState.sol │ │ │ │ ├── libraries │ │ │ │ │ ├── BitMath.sol │ │ │ │ │ ├── FixedPoint128.sol │ │ │ │ │ ├── FixedPoint96.sol │ │ │ │ │ ├── FullMath.sol │ │ │ │ │ ├── LiquidityMath.sol │ │ │ │ │ ├── LowGasSafeMath.sol │ │ │ │ │ ├── Oracle.sol │ │ │ │ │ ├── Position.sol │ │ │ │ │ ├── SafeCast.sol │ │ │ │ │ ├── SqrtPriceMath.sol │ │ │ │ │ ├── SwapMath.sol │ │ │ │ │ ├── Tick.sol │ │ │ │ │ ├── TickBitmap.sol │ │ │ │ │ ├── TickMath.sol │ │ │ │ │ ├── TransferHelper.sol │ │ │ │ │ └── UnsafeMath.sol │ │ │ │ └── test │ │ │ │ │ ├── BitMathEchidnaTest.sol │ │ │ │ │ ├── BitMathTest.sol │ │ │ │ │ ├── FullMathEchidnaTest.sol │ │ │ │ │ ├── FullMathTest.sol │ │ │ │ │ ├── LiquidityMathTest.sol │ │ │ │ │ ├── LowGasSafeMathEchidnaTest.sol │ │ │ │ │ ├── MockTimeUniswapV3Pool.sol │ │ │ │ │ ├── MockTimeUniswapV3PoolDeployer.sol │ │ │ │ │ ├── NoDelegateCallTest.sol │ │ │ │ │ ├── OracleEchidnaTest.sol │ │ │ │ │ ├── OracleTest.sol │ │ │ │ │ ├── SqrtPriceMathEchidnaTest.sol │ │ │ │ │ ├── SqrtPriceMathTest.sol │ │ │ │ │ ├── SwapMathEchidnaTest.sol │ │ │ │ │ ├── SwapMathTest.sol │ │ │ │ │ ├── TestERC20.sol │ │ │ │ │ ├── TestUniswapV3Callee.sol │ │ │ │ │ ├── TestUniswapV3ReentrantCallee.sol │ │ │ │ │ ├── TestUniswapV3Router.sol │ │ │ │ │ ├── TestUniswapV3SwapPay.sol │ │ │ │ │ ├── TickBitmapEchidnaTest.sol │ │ │ │ │ ├── TickBitmapTest.sol │ │ │ │ │ ├── TickEchidnaTest.sol │ │ │ │ │ ├── TickMathEchidnaTest.sol │ │ │ │ │ ├── TickMathTest.sol │ │ │ │ │ ├── TickOverflowSafetyEchidnaTest.sol │ │ │ │ │ ├── TickTest.sol │ │ │ │ │ ├── UniswapV3PoolSwapTest.sol │ │ │ │ │ └── UnsafeMathEchidnaTest.sol │ │ │ └── v3-periphery │ │ │ │ ├── NonfungiblePositionManager.sol │ │ │ │ ├── NonfungibleTokenPositionDescriptor.sol │ │ │ │ ├── SwapRouter.sol │ │ │ │ ├── V3Migrator.sol │ │ │ │ ├── base │ │ │ │ ├── BlockTimestamp.sol │ │ │ │ ├── ERC721Permit.sol │ │ │ │ ├── LiquidityManagement.sol │ │ │ │ ├── Multicall.sol │ │ │ │ ├── PeripheryImmutableState.sol │ │ │ │ ├── PeripheryPayments.sol │ │ │ │ ├── PeripheryPaymentsWithFee.sol │ │ │ │ ├── PeripheryValidation.sol │ │ │ │ ├── PoolInitializer.sol │ │ │ │ └── SelfPermit.sol │ │ │ │ ├── examples │ │ │ │ └── PairFlash.sol │ │ │ │ ├── interfaces │ │ │ │ ├── IERC20Metadata.sol │ │ │ │ ├── IERC721Permit.sol │ │ │ │ ├── IMulticall.sol │ │ │ │ ├── INonfungiblePositionManager.sol │ │ │ │ ├── INonfungibleTokenPositionDescriptor.sol │ │ │ │ ├── IPeripheryImmutableState.sol │ │ │ │ ├── IPeripheryPayments.sol │ │ │ │ ├── IPeripheryPaymentsWithFee.sol │ │ │ │ ├── IPoolInitializer.sol │ │ │ │ ├── IQuoter.sol │ │ │ │ ├── IQuoterV2.sol │ │ │ │ ├── ISelfPermit.sol │ │ │ │ ├── ISwapRouter.sol │ │ │ │ ├── ITickLens.sol │ │ │ │ ├── IV3Migrator.sol │ │ │ │ └── external │ │ │ │ │ ├── IERC1271.sol │ │ │ │ │ ├── IERC20PermitAllowed.sol │ │ │ │ │ └── IWETH9.sol │ │ │ │ ├── lens │ │ │ │ ├── Quoter.sol │ │ │ │ ├── QuoterV2.sol │ │ │ │ ├── TickLens.sol │ │ │ │ └── UniswapInterfaceMulticall.sol │ │ │ │ ├── libraries │ │ │ │ ├── BytesLib.sol │ │ │ │ ├── CallbackValidation.sol │ │ │ │ ├── ChainId.sol │ │ │ │ ├── HexStrings.sol │ │ │ │ ├── LiquidityAmounts.sol │ │ │ │ ├── NFTDescriptor.sol │ │ │ │ ├── NFTSVG.sol │ │ │ │ ├── OracleLibrary.sol │ │ │ │ ├── Path.sol │ │ │ │ ├── PoolAddress.sol │ │ │ │ ├── PoolTicksCounter.sol │ │ │ │ ├── PositionKey.sol │ │ │ │ ├── PositionValue.sol │ │ │ │ ├── SqrtPriceMathPartial.sol │ │ │ │ ├── TokenRatioSortOrder.sol │ │ │ │ └── TransferHelper.sol │ │ │ │ └── test │ │ │ │ ├── Base64Test.sol │ │ │ │ ├── LiquidityAmountsTest.sol │ │ │ │ ├── MockObservable.sol │ │ │ │ ├── MockObservations.sol │ │ │ │ ├── MockTimeNonfungiblePositionManager.sol │ │ │ │ ├── MockTimeSwapRouter.sol │ │ │ │ ├── NFTDescriptorTest.sol │ │ │ │ ├── NonfungiblePositionManagerPositionsGasTest.sol │ │ │ │ ├── OracleTest.sol │ │ │ │ ├── PathTest.sol │ │ │ │ ├── PeripheryImmutableStateTest.sol │ │ │ │ ├── PoolAddressTest.sol │ │ │ │ ├── PoolTicksCounterTest.sol │ │ │ │ ├── PositionValueTest.sol │ │ │ │ ├── SelfPermitTest.sol │ │ │ │ ├── TestCallbackValidation.sol │ │ │ │ ├── TestERC20.sol │ │ │ │ ├── TestERC20Metadata.sol │ │ │ │ ├── TestERC20PermitAllowed.sol │ │ │ │ ├── TestMulticall.sol │ │ │ │ ├── TestPositionNFTOwner.sol │ │ │ │ ├── TestUniswapV3Callee.sol │ │ │ │ └── TickLensTest.sol │ │ ├── UniswapV4 │ │ │ ├── TickMath_loop.sol │ │ │ ├── lib │ │ │ │ └── libraries │ │ │ │ │ ├── BitMath.sol │ │ │ │ │ ├── CustomRevert.sol │ │ │ │ │ └── TickMath.sol │ │ │ └── test.json │ │ ├── shitdao │ │ │ ├── SHITv1.sol │ │ │ └── test.json │ │ └── starkex-verifier │ │ │ ├── Fri.sol │ │ │ ├── FriLayer.sol │ │ │ ├── FriStatementContract.sol │ │ │ ├── FriStatementVerifier.sol │ │ │ ├── FriTransform.sol │ │ │ ├── HornerEvaluator.sol │ │ │ ├── IMerkleVerifier.sol │ │ │ ├── MemoryAccessUtils.sol │ │ │ ├── MerkleStatementContract.sol │ │ │ ├── MerkleStatementVerifier.sol │ │ │ ├── MerkleVerifier.sol │ │ │ ├── PrimeFieldElement0.sol │ │ │ ├── Prng.sol │ │ │ ├── StarkVerifier.sol │ │ │ ├── VerifierChannel.sol │ │ │ ├── components │ │ │ └── FactRegistry.sol │ │ │ ├── cpu │ │ │ ├── CairoBootloaderProgram.sol │ │ │ ├── CairoVerifierContract.sol │ │ │ ├── CpuFrilessVerifier.sol │ │ │ ├── CpuPublicInputOffsets.sol │ │ │ ├── CpuPublicInputOffsetsBase.sol │ │ │ ├── CpuVerifier.sol │ │ │ ├── MemoryPageFactRegistry.sol │ │ │ ├── PageInfo.sol │ │ │ ├── layout_dydx │ │ │ │ ├── CpuConstraintPoly.sol │ │ │ │ ├── CpuOods.sol │ │ │ │ ├── LayoutSpecific.sol │ │ │ │ ├── MemoryMap.sol │ │ │ │ └── StarkParameters.sol │ │ │ └── periodic_columns │ │ │ │ ├── EcdsaPointsXColumn.sol │ │ │ │ ├── EcdsaPointsYColumn.sol │ │ │ │ ├── PedersenHashPointsXColumn.sol │ │ │ │ └── PedersenHashPointsYColumn.sol │ │ │ ├── gps │ │ │ ├── GpsOutputParser.sol │ │ │ └── GpsStatementVerifier.sol │ │ │ ├── interfaces │ │ │ ├── IFactRegistry.sol │ │ │ ├── IPeriodicColumn.sol │ │ │ ├── IQueryableFactRegistry.sol │ │ │ ├── IStarkVerifier.sol │ │ │ └── Identity.sol │ │ │ └── test.json │ ├── evaluation_order │ │ ├── safe_transfer │ │ │ ├── ERC20Minimal.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ └── solady_signature_checker │ │ │ ├── Main.sol │ │ │ ├── SignatureCheckerLib.sol │ │ │ ├── Wallet.sol │ │ │ └── test.json │ ├── forwarding │ │ ├── assembly │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── constant_size │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── return │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── revert │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ ├── simple │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ └── swap │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ ├── immutable_delegate_call │ │ ├── Main.sol │ │ ├── TestContract.sol │ │ └── test.json │ ├── import_library_inline │ │ ├── Foo.sol │ │ ├── Import.sol │ │ └── test.json │ ├── indirect_recursion_fact │ │ ├── first.sol │ │ ├── second.sol │ │ └── test.json │ ├── interface_casting │ │ ├── main.sol │ │ └── test.json │ ├── internal_function_pointers │ │ ├── mixed_features_1 │ │ │ ├── main.sol │ │ │ └── test.json │ │ └── mixed_features_2 │ │ │ ├── main.sol │ │ │ └── test.json │ ├── interpreter │ │ ├── Dummy.sol │ │ └── test.json │ ├── invalid_signature │ │ ├── require │ │ │ ├── requireInterface.sol │ │ │ ├── simpleRequire.sol │ │ │ ├── test.json │ │ │ └── wrapper.sol │ │ └── simple │ │ │ ├── callable.sol │ │ │ ├── icallable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ ├── library_call_tuple │ │ ├── main.sol │ │ └── test.json │ ├── many_arguments │ │ ├── complex │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ └── simple │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ ├── nested_calls │ │ ├── code_address │ │ │ ├── delegatecall │ │ │ │ ├── Main.sol │ │ │ │ ├── TestContract.sol │ │ │ │ └── test.json │ │ │ ├── delegatecall_delegatecall │ │ │ │ ├── First.sol │ │ │ │ ├── Second.sol │ │ │ │ ├── Third.sol │ │ │ │ └── test.json │ │ │ └── staticcall_delegatecall │ │ │ │ ├── First.sol │ │ │ │ ├── Second.sol │ │ │ │ ├── Third.sol │ │ │ │ └── test.json │ │ ├── delegatecall_call │ │ │ ├── A.sol │ │ │ ├── B.sol │ │ │ ├── C.sol │ │ │ └── test.json │ │ ├── delegatecall_delegatecall │ │ │ ├── A.sol │ │ │ ├── B.sol │ │ │ ├── C.sol │ │ │ └── test.json │ │ ├── staticcall_call │ │ │ ├── A.sol │ │ │ ├── B.sol │ │ │ ├── C.sol │ │ │ └── test.json │ │ └── staticcall_staticcall │ │ │ ├── A.sol │ │ │ ├── B.sol │ │ │ ├── C.sol │ │ │ └── test.json │ ├── parser │ │ └── svg │ │ │ ├── PRBMath.sol │ │ │ ├── PRBMathUD60x18.sol │ │ │ ├── Strings.sol │ │ │ ├── base64.sol │ │ │ ├── main.sol │ │ │ ├── test_eravm.json │ │ │ └── test_evm.json │ ├── solidity_by_example │ │ ├── applications │ │ │ └── iterable_mapping │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ ├── hacks │ │ │ ├── delegate_call │ │ │ │ ├── default.sol │ │ │ │ └── test.json │ │ │ ├── delegate_call_second │ │ │ │ ├── default.sol │ │ │ │ └── test.json │ │ │ └── hiding_malicious_code_with_external_contract │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ └── simple │ │ │ ├── constructor_multiple_inheritance_empty │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── constructor_multiple_inheritance_order │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── constructor_multiple_inheritance_with_arguments │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── enum │ │ │ ├── EnumDeclaration.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── hashing_with_keccak256 │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── import │ │ │ ├── Foo.sol │ │ │ ├── Import.sol │ │ │ └── test.json │ │ │ ├── inheritance │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── interface │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── library │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── structs │ │ │ ├── StructDeclaration.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── try_catch │ │ │ ├── test.json │ │ │ └── try_catch.sol │ │ │ └── visibility │ │ │ ├── main.sol │ │ │ └── test.json │ ├── storage │ │ ├── main.sol │ │ ├── storage.sol │ │ └── test.json │ ├── sum_of_squares │ │ ├── main.sol │ │ ├── square.sol │ │ └── test.json │ ├── try_catch │ │ ├── call │ │ │ ├── complex │ │ │ │ ├── callable.sol │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ │ ├── custom_error │ │ │ │ ├── callable.sol │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ │ ├── error │ │ │ │ ├── callable.sol │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ │ ├── panic │ │ │ │ ├── callable.sol │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ │ └── simple │ │ │ │ ├── main.sol │ │ │ │ └── test.json │ │ └── create │ │ │ ├── complex │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── custom_error │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ ├── error │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ │ │ └── panic │ │ │ ├── callable.sol │ │ │ ├── main.sol │ │ │ └── test.json │ ├── value │ │ ├── delegatecall │ │ │ ├── Main.sol │ │ │ ├── TestContract.sol │ │ │ └── test.json │ │ ├── delegatecall_call │ │ │ ├── First.sol │ │ │ ├── Second.sol │ │ │ ├── Third.sol │ │ │ └── test.json │ │ └── delegatecall_delegatecall │ │ │ ├── First.sol │ │ │ ├── Second.sol │ │ │ ├── Third.sol │ │ │ └── test.json │ ├── voting │ │ ├── ballot.sol │ │ └── test.json │ └── yul_instructions │ │ ├── balance │ │ ├── main.sol │ │ ├── other.sol │ │ └── test.json │ │ ├── call │ │ ├── address_test.sol │ │ ├── caller_test.sol │ │ ├── callvalue_test.sol │ │ ├── codesize_test.sol │ │ ├── failure_test.sol │ │ ├── gas_test.sol │ │ ├── input_test.sol │ │ ├── input_test_with_value.sol │ │ ├── log_test.sol │ │ ├── main.sol │ │ ├── output_test.sol │ │ ├── output_test_with_value.sol │ │ ├── selfbalance_test.sol │ │ ├── sload_test.sol │ │ ├── sstore_test.sol │ │ ├── test.json │ │ └── value_test.sol │ │ ├── calldatacopy │ │ ├── deploy.sol │ │ ├── main.sol │ │ └── test.json │ │ ├── calldataload │ │ ├── deploy.sol │ │ ├── main.sol │ │ └── test.json │ │ ├── calldatasize │ │ ├── deploy.sol │ │ ├── main.sol │ │ ├── test_eravm.json │ │ └── test_evm.json │ │ ├── codecopy │ │ ├── main.sol │ │ ├── other.sol │ │ └── test.json │ │ ├── create │ │ ├── failure_test.sol │ │ ├── input_test.sol │ │ ├── input_test_with_value.sol │ │ ├── main.sol │ │ ├── test.json │ │ └── value_test.sol │ │ ├── create2 │ │ ├── failure_test.sol │ │ ├── input_test.sol │ │ ├── input_test_with_value.sol │ │ ├── main.sol │ │ ├── salt_test.sol │ │ ├── test.json │ │ └── value_test.sol │ │ ├── delegatecall │ │ ├── address_test.sol │ │ ├── caller_test.sol │ │ ├── callvalue_test.sol │ │ ├── codesize_test.sol │ │ ├── failure_test.sol │ │ ├── gas_test.sol │ │ ├── input_test.sol │ │ ├── input_test_with_value.sol │ │ ├── log_test.sol │ │ ├── main.sol │ │ ├── output_test.sol │ │ ├── output_test_with_value.sol │ │ ├── selfbalance_test.sol │ │ ├── sload_test.sol │ │ ├── sstore_test.sol │ │ └── test.json │ │ ├── extcodehash │ │ ├── main.sol │ │ ├── other.sol │ │ └── test.json │ │ ├── extcodesize │ │ ├── main.sol │ │ ├── other.sol │ │ └── test.json │ │ └── staticcall │ │ ├── address_test.sol │ │ ├── caller_test.sol │ │ ├── callvalue_test.sol │ │ ├── codesize_test.sol │ │ ├── failure_test.sol │ │ ├── gas_test.sol │ │ ├── input_test.sol │ │ ├── input_test_with_value.sol │ │ ├── log_test.sol │ │ ├── main.sol │ │ ├── output_test.sol │ │ ├── output_test_with_value.sol │ │ ├── selfbalance_test.sol │ │ ├── sload_test.sol │ │ ├── sstore_test.sol │ │ └── test.json ├── ethereum │ ├── abiEncodeDecode │ │ ├── abi_decode_calldata.sol │ │ ├── abi_decode_simple.sol │ │ ├── abi_decode_simple_storage.sol │ │ ├── abi_encode_call.sol │ │ ├── abi_encode_call_declaration.sol │ │ ├── abi_encode_call_is_consistent.sol │ │ ├── abi_encode_call_memory.sol │ │ ├── abi_encode_call_special_args.sol │ │ ├── abi_encode_call_uint_bytes.sol │ │ ├── abi_encode_empty_string_v1.sol │ │ ├── abi_encode_with_selector.sol │ │ ├── abi_encode_with_selectorv2.sol │ │ ├── abi_encode_with_signature.sol │ │ ├── abi_encode_with_signaturev2.sol │ │ ├── contract_array.sol │ │ ├── contract_array_v2.sol │ │ ├── offset_overflow_in_array_decoding.sol │ │ ├── offset_overflow_in_array_decoding_2.sol │ │ └── offset_overflow_in_array_decoding_3.sol │ ├── abiEncoderV1 │ │ ├── abi_decode_dynamic_array.sol │ │ ├── abi_decode_fixed_arrays.sol │ │ ├── abi_decode_static_array.sol │ │ ├── abi_decode_static_array_v2.sol │ │ ├── abi_decode_trivial.sol │ │ ├── abi_decode_v2.sol │ │ ├── abi_decode_v2_calldata.sol │ │ ├── abi_decode_v2_storage.sol │ │ ├── abi_encode.sol │ │ ├── abi_encode_call.sol │ │ ├── abi_encode_calldata_slice.sol │ │ ├── abi_encode_decode_simple.sol │ │ ├── abi_encode_empty_string.sol │ │ ├── abi_encode_rational.sol │ │ ├── bool_out_of_bounds.sol │ │ ├── byte_arrays.sol │ │ ├── calldata_arrays_too_large.sol │ │ ├── calldata_bytes_bytes32_arrays.sol │ │ ├── cleanup │ │ │ └── cleanup.sol │ │ ├── decode_slice.sol │ │ ├── dynamic_arrays.sol │ │ ├── dynamic_memory_copy.sol │ │ ├── enums.sol │ │ ├── memory_dynamic_array_and_calldata_bytes.sol │ │ ├── memory_params_in_external_function.sol │ │ ├── return_dynamic_types_cross_call_advanced.sol │ │ ├── return_dynamic_types_cross_call_out_of_range_1.sol │ │ ├── return_dynamic_types_cross_call_out_of_range_2.sol │ │ ├── return_dynamic_types_cross_call_simple.sol │ │ └── struct │ │ │ └── struct_storage_ptr.sol │ ├── abiEncoderV2 │ │ ├── abi_encode_calldata_slice.sol │ │ ├── abi_encode_empty_string_v2.sol │ │ ├── abi_encode_rational_v2.sol │ │ ├── abi_encode_v2.sol │ │ ├── abi_encode_v2_in_function_inherited_in_v1_contract.sol │ │ ├── abi_encode_v2_in_modifier_used_in_v1_contract.sol │ │ ├── abi_encoder_v2_head_overflow_with_static_array_cleanup_bug.sol │ │ ├── bool_out_of_bounds.sol │ │ ├── byte_arrays.sol │ │ ├── calldata_array.sol │ │ ├── calldata_array_dynamic.sol │ │ ├── calldata_array_dynamic_index_access.sol │ │ ├── calldata_array_dynamic_static_dynamic.sol │ │ ├── calldata_array_dynamic_static_in_library.sol │ │ ├── calldata_array_dynamic_static_short_decode.sol │ │ ├── calldata_array_dynamic_static_short_reencode.sol │ │ ├── calldata_array_function_types.sol │ │ ├── calldata_array_multi_dynamic.sol │ │ ├── calldata_array_short.sol │ │ ├── calldata_array_short_no_revert_string.sol │ │ ├── calldata_array_static.sol │ │ ├── calldata_array_static_dynamic_static.sol │ │ ├── calldata_array_static_index_access.sol │ │ ├── calldata_array_struct_dynamic.sol │ │ ├── calldata_array_two_dynamic.sol │ │ ├── calldata_array_two_static.sol │ │ ├── calldata_dynamic_array_to_memory.sol │ │ ├── calldata_nested_array_reencode.sol │ │ ├── calldata_nested_array_static_reencode.sol │ │ ├── calldata_overlapped_dynamic_arrays.sol │ │ ├── calldata_overlapped_nested_dynamic_arrays.sol │ │ ├── calldata_struct_array_reencode.sol │ │ ├── calldata_struct_dynamic.sol │ │ ├── calldata_struct_member_offset.sol │ │ ├── calldata_struct_simple.sol │ │ ├── calldata_three_dimensional_dynamic_array_index_access.sol │ │ ├── calldata_with_garbage.sol │ │ ├── cleanup │ │ │ ├── address.sol │ │ │ ├── bool.sol │ │ │ ├── bytesx.sol │ │ │ ├── cleanup.sol │ │ │ ├── dynamic_array.sol │ │ │ ├── function.sol │ │ │ ├── intx.sol │ │ │ ├── reencoded_calldata_string.sol │ │ │ ├── simple_struct.sol │ │ │ ├── static_array.sol │ │ │ └── uintx.sol │ │ ├── dynamic_arrays.sol │ │ ├── dynamic_nested_arrays.sol │ │ ├── enums.sol │ │ ├── memory_dynamic_array_and_calldata_bytes.sol │ │ ├── memory_dynamic_array_and_calldata_static_array.sol │ │ ├── memory_params_in_external_function.sol │ │ ├── storage_array_encoding.sol │ │ └── struct │ │ │ ├── mediocre2_struct.sol │ │ │ ├── mediocre_struct.sol │ │ │ ├── struct_function.sol │ │ │ ├── struct_short.sol │ │ │ ├── struct_simple.sol │ │ │ ├── struct_validation.sol │ │ │ └── validation_function_type_inside_struct.sol │ ├── accessor │ │ ├── accessor_for_const_state_variable.sol │ │ └── accessor_for_state_variable.sol │ ├── arithmetics │ │ ├── addmod_mulmod.sol │ │ ├── addmod_mulmod_zero.sol │ │ ├── block_inside_unchecked.sol │ │ ├── check_var_init.sol │ │ ├── checked_add_v1.sol │ │ ├── checked_add_v2.sol │ │ ├── checked_called_by_unchecked.sol │ │ ├── checked_modifier_called_by_unchecked.sol │ │ ├── divisiod_by_zero.sol │ │ ├── exp_associativity.sol │ │ ├── signed_mod.sol │ │ ├── unchecked_called_by_checked.sol │ │ └── unchecked_div_by_zero.sol │ ├── array │ │ ├── arrayMemoryAllocation │ │ │ ├── array_2d_zeroed_memory_index_access.sol │ │ │ ├── array_array_static.sol │ │ │ ├── array_static_return_param_zeroed_memory_index_access.sol │ │ │ ├── array_static_zeroed_memory_index_access.sol │ │ │ └── array_zeroed_memory_index_access.sol │ │ ├── array_2d_assignment.sol │ │ ├── array_2d_new.sol │ │ ├── array_3d_assignment.sol │ │ ├── array_3d_new.sol │ │ ├── array_function_pointers.sol │ │ ├── array_memory_as_parameter.sol │ │ ├── array_memory_create.sol │ │ ├── array_memory_index_access.sol │ │ ├── array_push_return_reference.sol │ │ ├── array_push_with_arg.sol │ │ ├── array_storage_index_access.sol │ │ ├── array_storage_index_boundary_test.sol │ │ ├── array_storage_index_zeroed_test.sol │ │ ├── array_storage_length_access.sol │ │ ├── array_storage_pop_zero_length.sol │ │ ├── array_storage_push_empty.sol │ │ ├── array_storage_push_empty_length_address.sol │ │ ├── array_storage_push_pop.sol │ │ ├── arrays_complex_from_and_to_storage.sol │ │ ├── byte_array_storage_layout.sol │ │ ├── byte_array_transitional_2.sol │ │ ├── bytes_length_member.sol │ │ ├── bytes_to_fixed_bytes_cleanup.sol │ │ ├── bytes_to_fixed_bytes_simple.sol │ │ ├── bytes_to_fixed_bytes_too_long.sol │ │ ├── calldata_array.sol │ │ ├── calldata_array_as_argument_internal_function.sol │ │ ├── calldata_array_dynamic_invalid.sol │ │ ├── calldata_array_dynamic_invalid_static_middle.sol │ │ ├── calldata_array_of_struct.sol │ │ ├── calldata_array_two_dimensional.sol │ │ ├── calldata_array_two_dimensional_1.sol │ │ ├── calldata_bytes_array_bounds.sol │ │ ├── calldata_slice_access.sol │ │ ├── concat │ │ │ ├── bytes_concat_2_args.sol │ │ │ ├── bytes_concat_3_args.sol │ │ │ ├── bytes_concat_as_argument.sol │ │ │ ├── bytes_concat_different_types.sol │ │ │ ├── bytes_concat_empty_argument_list.sol │ │ │ ├── bytes_concat_empty_strings.sol │ │ │ └── bytes_concat_nested.sol │ │ ├── constant_var_as_array_length.sol │ │ ├── copying │ │ │ ├── array_copy_calldata_storage.sol │ │ │ ├── array_copy_cleanup_uint128.sol │ │ │ ├── array_copy_cleanup_uint40.sol │ │ │ ├── array_copy_clear_storage.sol │ │ │ ├── array_copy_clear_storage_packed.sol │ │ │ ├── array_copy_different_packing.sol │ │ │ ├── array_copy_including_array.sol │ │ │ ├── array_copy_memory_to_storage.sol │ │ │ ├── array_copy_nested_array.sol │ │ │ ├── array_copy_storage_abi_signed.sol │ │ │ ├── array_copy_storage_storage_different_base.sol │ │ │ ├── array_copy_storage_storage_different_base_nested.sol │ │ │ ├── array_copy_storage_storage_dyn_dyn.sol │ │ │ ├── array_copy_storage_storage_dynamic_dynamic.sol │ │ │ ├── array_copy_storage_storage_static_dynamic.sol │ │ │ ├── array_copy_storage_storage_static_simple.sol │ │ │ ├── array_copy_storage_storage_static_static.sol │ │ │ ├── array_copy_storage_storage_struct.sol │ │ │ ├── array_copy_storage_to_memory.sol │ │ │ ├── array_copy_storage_to_memory_nested.sol │ │ │ ├── array_copy_target_leftover.sol │ │ │ ├── array_copy_target_leftover2.sol │ │ │ ├── array_copy_target_simple.sol │ │ │ ├── array_copy_target_simple_2.sol │ │ │ ├── array_elements_to_mapping.sol │ │ │ ├── array_nested_calldata_to_memory.sol │ │ │ ├── array_nested_calldata_to_storage.sol │ │ │ ├── array_nested_memory_to_storage.sol │ │ │ ├── array_nested_storage_to_memory.sol │ │ │ ├── array_of_function_external_storage_to_storage_dynamic.sol │ │ │ ├── array_of_function_external_storage_to_storage_dynamic_different_mutability.sol │ │ │ ├── array_of_struct_calldata_to_memory.sol │ │ │ ├── array_of_struct_calldata_to_storage.sol │ │ │ ├── array_of_struct_memory_to_storage.sol │ │ │ ├── array_of_structs_containing_arrays_calldata_to_memory.sol │ │ │ ├── array_of_structs_containing_arrays_calldata_to_storage.sol │ │ │ ├── array_of_structs_containing_arrays_memory_to_storage.sol │ │ │ ├── array_storage_multi_items_per_slot.sol │ │ │ ├── array_to_mapping.sol │ │ │ ├── arrays_from_and_to_storage.sol │ │ │ ├── bytes_calldata_to_string_calldata.sol │ │ │ ├── bytes_inside_mappings.sol │ │ │ ├── bytes_memory_to_storage.sol │ │ │ ├── bytes_storage_to_memory.sol │ │ │ ├── bytes_storage_to_storage.sol │ │ │ ├── calldata_1d_array_into_2d_memory_array_element.sol │ │ │ ├── calldata_2d_bytes_to_memory.sol │ │ │ ├── calldata_2d_bytes_to_memory_2.sol │ │ │ ├── calldata_array_dynamic_to_storage.sol │ │ │ ├── calldata_array_of_struct_to_memory.sol │ │ │ ├── calldata_array_static_to_memory.sol │ │ │ ├── calldata_array_to_mapping.sol │ │ │ ├── calldata_bytes_array_to_memory.sol │ │ │ ├── calldata_bytes_to_storage.sol │ │ │ ├── calldata_dyn_2d_bytes_to_memory.sol │ │ │ ├── calldata_dynamic_array_to_memory.sol │ │ │ ├── calldata_nested_array_copy_to_memory.sol │ │ │ ├── calldata_to_storage_different_base.sol │ │ │ ├── cleanup_during_multi_element_per_slot_copy.sol │ │ │ ├── copy_byte_array_in_struct_to_storage.sol │ │ │ ├── copy_byte_array_to_storage.sol │ │ │ ├── copy_function_internal_storage_array.sol │ │ │ ├── copy_internal_function_array_to_storage.sol │ │ │ ├── copy_removes_bytes_data.sol │ │ │ ├── copying_bytes_multiassign.sol │ │ │ ├── dirty_memory_bytes_to_storage_copy.sol │ │ │ ├── dirty_memory_bytes_to_storage_copy_ir.sol │ │ │ ├── elements_of_nested_array_of_structs_calldata_to_storage.sol │ │ │ ├── elements_of_nested_array_of_structs_memory_to_storage.sol │ │ │ ├── empty_bytes_copy.sol │ │ │ ├── function_type_array_to_storage.sol │ │ │ ├── memory_dyn_2d_bytes_to_storage.sol │ │ │ ├── memory_to_storage_different_base.sol │ │ │ ├── nested_array_element_calldata_to_memory.sol │ │ │ ├── nested_array_element_calldata_to_storage.sol │ │ │ ├── nested_array_element_memory_to_memory.sol │ │ │ ├── nested_array_element_memory_to_storage.sol │ │ │ ├── nested_array_element_storage_to_memory.sol │ │ │ ├── nested_array_element_storage_to_storage.sol │ │ │ ├── nested_array_of_structs_calldata_to_memory.sol │ │ │ ├── nested_array_of_structs_calldata_to_storage.sol │ │ │ ├── nested_array_of_structs_memory_to_memory.sol │ │ │ ├── nested_array_of_structs_memory_to_storage.sol │ │ │ ├── nested_array_of_structs_storage_to_storage.sol │ │ │ ├── nested_array_of_structs_with_nested_array_from_storage_to_memory.sol │ │ │ ├── nested_dynamic_array_element_calldata_to_storage.sol │ │ │ ├── storage_memory_nested.sol │ │ │ ├── storage_memory_nested_bytes.sol │ │ │ ├── storage_memory_nested_from_pointer.sol │ │ │ ├── storage_memory_nested_struct.sol │ │ │ ├── storage_memory_packed.sol │ │ │ ├── storage_memory_packed_dyn.sol │ │ │ └── string_calldata_to_bytes_calldata.sol │ │ ├── create_dynamic_array_with_zero_length.sol │ │ ├── create_memory_array.sol │ │ ├── create_memory_array_too_large.sol │ │ ├── create_memory_byte_array.sol │ │ ├── create_multiple_dynamic_arrays.sol │ │ ├── delete │ │ │ ├── bytes_delete_element.sol │ │ │ ├── delete_bytes_array.sol │ │ │ ├── delete_memory_array.sol │ │ │ ├── delete_on_array_of_structs.sol │ │ │ ├── delete_removes_bytes_data.sol │ │ │ ├── delete_storage_array.sol │ │ │ ├── delete_storage_array_packed.sol │ │ │ └── memory_arrays_delete.sol │ │ ├── dynamic_array_cleanup.sol │ │ ├── dynamic_arrays_in_storage.sol │ │ ├── dynamic_multi_array_cleanup.sol │ │ ├── dynamic_out_of_bounds_array_access.sol │ │ ├── evm_exceptions_out_of_band_access.sol │ │ ├── external_array_args.sol │ │ ├── fixed_array_cleanup.sol │ │ ├── fixed_arrays_as_return_type.sol │ │ ├── fixed_arrays_in_constructors.sol │ │ ├── fixed_arrays_in_storage.sol │ │ ├── fixed_bytes_length_access.sol │ │ ├── fixed_out_of_bounds_array_access.sol │ │ ├── function_array_cross_calls.sol │ │ ├── function_memory_array.sol │ │ ├── indexAccess │ │ │ ├── arrays_complex_memory_index_access.sol │ │ │ ├── bytes_index_access.sol │ │ │ ├── bytes_index_access_memory.sol │ │ │ ├── bytes_memory_index_access.sol │ │ │ ├── fixed_bytes_index_access.sol │ │ │ ├── index_access.sol │ │ │ ├── inline_array_index_access_ints.sol │ │ │ ├── inline_array_index_access_strings.sol │ │ │ ├── memory_arrays_dynamic_index_access_write.sol │ │ │ └── memory_arrays_index_access_write.sol │ │ ├── inline_array_return.sol │ │ ├── inline_array_singleton.sol │ │ ├── inline_array_storage_to_memory_conversion_ints.sol │ │ ├── inline_array_storage_to_memory_conversion_strings.sol │ │ ├── inline_array_strings_from_document.sol │ │ ├── invalid_encoding_for_storage_byte_array.sol │ │ ├── memory.sol │ │ ├── memory_arrays_of_various_sizes.sol │ │ ├── nested_calldata_storage.sol │ │ ├── nested_calldata_storage2.sol │ │ ├── pop │ │ │ ├── array_pop.sol │ │ │ ├── array_pop_array_transition.sol │ │ │ ├── array_pop_empty_exception.sol │ │ │ ├── array_pop_isolated.sol │ │ │ ├── array_pop_storage_empty.sol │ │ │ ├── array_pop_uint16_transition.sol │ │ │ ├── array_pop_uint24_transition.sol │ │ │ ├── byte_array_pop.sol │ │ │ ├── byte_array_pop_copy_long.sol │ │ │ ├── byte_array_pop_empty_exception.sol │ │ │ ├── byte_array_pop_isolated.sol │ │ │ ├── byte_array_pop_long_storage_empty.sol │ │ │ ├── byte_array_pop_long_storage_empty_garbage_ref.sol │ │ │ ├── byte_array_pop_masking_long.sol │ │ │ ├── byte_array_pop_storage_empty.sol │ │ │ └── parenthesized.sol │ │ ├── push │ │ │ ├── array_push.sol │ │ │ ├── array_push_nested.sol │ │ │ ├── array_push_nested_from_calldata.sol │ │ │ ├── array_push_nested_from_memory.sol │ │ │ ├── array_push_packed_array.sol │ │ │ ├── array_push_struct.sol │ │ │ ├── array_push_struct_from_calldata.sol │ │ │ ├── byte_array_push.sol │ │ │ ├── byte_array_push_transition.sol │ │ │ ├── nested_bytes_push.sol │ │ │ ├── push_no_args_1d.sol │ │ │ ├── push_no_args_2d.sol │ │ │ ├── push_no_args_bytes.sol │ │ │ └── push_no_args_struct.sol │ │ ├── reusing_memory.sol │ │ ├── short_fixed_array_cleanup.sol │ │ ├── slices │ │ │ ├── array_calldata_assignment.sol │ │ │ ├── array_slice_calldata_as_argument_of_external_calls.sol │ │ │ ├── array_slice_calldata_to_calldata.sol │ │ │ ├── array_slice_calldata_to_memory.sol │ │ │ └── array_slice_calldata_to_storage.sol │ │ ├── storage_array_ref.sol │ │ ├── string_allocation_bug.sol │ │ ├── string_bytes_conversion.sol │ │ ├── string_literal_assign_to_storage_bytes.sol │ │ └── strings_in_struct.sol │ ├── builtinFunctions │ │ ├── assignment_to_const_var_involving_keccak.sol │ │ ├── blobhash.sol │ │ ├── blobhash_shadow_resolution.sol │ │ ├── blockhash.sol │ │ ├── blockhash_shadow_resolution.sol │ │ ├── function_types_sig.sol │ │ ├── iterated_keccak256_with_bytes.sol │ │ ├── keccak256.sol │ │ ├── keccak256_empty.sol │ │ ├── keccak256_multiple_arguments.sol │ │ ├── keccak256_multiple_arguments_with_numeric_literals.sol │ │ ├── keccak256_multiple_arguments_with_string_literals.sol │ │ ├── keccak256_packed.sol │ │ ├── keccak256_packed_complex_types.sol │ │ ├── keccak256_with_bytes.sol │ │ ├── msg_sig.sol │ │ ├── msg_sig_after_internal_call_is_same.sol │ │ ├── ripemd160.sol │ │ ├── ripemd160_empty.sol │ │ ├── ripemd160_packed.sol │ │ ├── sha256.sol │ │ ├── sha256_empty.sol │ │ └── sha256_packed.sol │ ├── calldata │ │ ├── calldata_array_access.sol │ │ ├── calldata_array_dynamic_bytes.sol │ │ ├── calldata_array_index_range_access.sol │ │ ├── calldata_array_length.sol │ │ ├── calldata_array_three_dimensional.sol │ │ ├── calldata_attached_to_bytes.sol │ │ ├── calldata_attached_to_dynamic_array_or_slice.sol │ │ ├── calldata_attached_to_static_array.sol │ │ ├── calldata_attached_to_struct.sol │ │ ├── calldata_bytes_array_bounds.sol │ │ ├── calldata_bytes_external.sol │ │ ├── calldata_bytes_internal.sol │ │ ├── calldata_bytes_to_memory.sol │ │ ├── calldata_bytes_to_memory_encode.sol │ │ ├── calldata_internal_function_pointer.sol │ │ ├── calldata_internal_library.sol │ │ ├── calldata_internal_multi_array.sol │ │ ├── calldata_internal_multi_fixed_array.sol │ │ ├── calldata_memory_mixed.sol │ │ ├── calldata_string_array.sol │ │ ├── calldata_struct.sol │ │ ├── calldata_struct_cleaning.sol │ │ ├── calldata_struct_internal.sol │ │ └── copy_from_calldata_removes_bytes_data.sol │ ├── cleanup │ │ ├── bool_conversion_v1.sol │ │ ├── bool_conversion_v2.sol │ │ ├── byte_array_to_storage_cleanup.sol │ │ ├── cleanup_address_types_shortening.sol │ │ ├── cleanup_address_types_v1.sol │ │ ├── cleanup_address_types_v2.sol │ │ ├── cleanup_bytes_types_shortening_OldCodeGen.sol │ │ ├── cleanup_bytes_types_shortening_newCodeGen.sol │ │ ├── cleanup_bytes_types_v1.sol │ │ ├── cleanup_bytes_types_v2.sol │ │ ├── cleanup_in_compound_assign.sol │ │ ├── dirty_calldata_bytes.sol │ │ ├── dirty_calldata_dynamic_array.sol │ │ ├── exp_cleanup.sol │ │ ├── exp_cleanup_direct.sol │ │ ├── exp_cleanup_nonzero_base.sol │ │ ├── exp_cleanup_smaller_base.sol │ │ ├── indexed_log_topic_during_explicit_downcast.sol │ │ └── indexed_log_topic_during_explicit_downcast_during_emissions.sol │ ├── constantEvaluator │ │ ├── negative_fractional_mod.sol │ │ └── rounding.sol │ ├── constants │ │ ├── asm_address_constant_regression.sol │ │ ├── asm_constant_file_level.sol │ │ ├── constant_string.sol │ │ ├── constant_string_at_file_level.sol │ │ ├── constant_variables.sol │ │ ├── constants_at_file_level_referencing.sol │ │ ├── consteval_array_length.sol │ │ ├── function_unreferenced.sol │ │ ├── same_constants_different_files.sol │ │ └── simple_constant_variables_test.sol │ ├── constructor │ ├── conversions │ │ ├── function_type_array_to_storage.sol │ │ └── string_to_bytes.sol │ ├── deployedCodeExclusion │ │ ├── bound_function.sol │ │ ├── library_function.sol │ │ ├── library_function_deployed.sol │ │ ├── module_function.sol │ │ ├── module_function_deployed.sol │ │ ├── static_base_function.sol │ │ ├── static_base_function_deployed.sol │ │ ├── subassembly_deduplication.sol │ │ ├── super_function.sol │ │ ├── super_function_deployed.sol │ │ ├── virtual_function.sol │ │ └── virtual_function_deployed.sol │ ├── ecrecover │ │ ├── ecrecover.sol │ │ ├── ecrecover_abiV2.sol │ │ ├── failing_ecrecover_invalid_input.sol │ │ ├── failing_ecrecover_invalid_input_asm.sol │ │ └── failing_ecrecover_invalid_input_proper.sol │ ├── enums │ │ ├── constructing_enums_from_ints.sol │ │ ├── enum_explicit_overflow.sol │ │ ├── enum_explicit_overflow_homestead.sol │ │ ├── enum_referencing.sol │ │ ├── enum_with_256_members.sol │ │ ├── invalid_enum_logged.sol │ │ ├── minmax.sol │ │ ├── using_contract_enums_with_explicit_contract_name.sol │ │ ├── using_enums.sol │ │ ├── using_inherited_enum.sol │ │ └── using_inherited_enum_excplicitly.sol │ ├── errors │ │ ├── error_in_library_and_interface.sol │ │ ├── error_selector.sol │ │ ├── error_static_calldata_uint_array_and_dynamic_array.sol │ │ ├── errors_by_parameter_type.sol │ │ ├── named_error_args.sol │ │ ├── named_parameters_shadowing_types.sol │ │ ├── panic_via_import.sol │ │ ├── require_different_errors_same_parameters.sol │ │ ├── require_error_condition_evaluated_only_once.sol │ │ ├── require_error_evaluation_order_1.sol │ │ ├── require_error_evaluation_order_2.sol │ │ ├── require_error_evaluation_order_3.sol │ │ ├── require_error_function_join_control_flow.sol │ │ ├── require_error_function_pointer_parameter.sol │ │ ├── require_error_multiple_arguments.sol │ │ ├── require_error_stack_check.sol │ │ ├── require_error_string_literal.sol │ │ ├── require_error_string_memory.sol │ │ ├── require_error_uint256.sol │ │ ├── require_inherited_error.sol │ │ ├── revert_conversion.sol │ │ ├── simple.sol │ │ ├── small_error_optimization.sol │ │ ├── using_structs.sol │ │ ├── via_contract_type.sol │ │ ├── via_import.sol │ │ └── weird_name.sol │ ├── events │ │ ├── emit_three_identical_events.sol │ │ ├── emit_two_identical_events.sol │ │ ├── event.sol │ │ ├── event_access_through_base_name_emit.sol │ │ ├── event_anonymous.sol │ │ ├── event_anonymous_with_signature_collision.sol │ │ ├── event_anonymous_with_signature_collision2.sol │ │ ├── event_anonymous_with_topics.sol │ │ ├── event_constructor.sol │ │ ├── event_dynamic_array_memory.sol │ │ ├── event_dynamic_array_memory_v2.sol │ │ ├── event_dynamic_array_storage.sol │ │ ├── event_dynamic_array_storage_v2.sol │ │ ├── event_dynamic_nested_array_memory_v2.sol │ │ ├── event_dynamic_nested_array_storage_v2.sol │ │ ├── event_emit.sol │ │ ├── event_emit_file_level.sol │ │ ├── event_emit_from_a_foreign_contract.sol │ │ ├── event_emit_from_a_foreign_contract_same_name.sol │ │ ├── event_emit_from_other_contract.sol │ │ ├── event_emit_interface_event_via_library.sol │ │ ├── event_emit_via_interface.sol │ │ ├── event_indexed_function.sol │ │ ├── event_indexed_function2.sol │ │ ├── event_indexed_mixed.sol │ │ ├── event_indexed_string.sol │ │ ├── event_lots_of_data.sol │ │ ├── event_no_arguments.sol │ │ ├── event_really_lots_of_data.sol │ │ ├── event_really_lots_of_data_from_storage.sol │ │ ├── event_really_really_lots_of_data_from_storage.sol │ │ ├── event_selector.sol │ │ ├── event_selector_file_level.sol │ │ ├── event_shadowing_file_level.sol │ │ ├── event_signature_in_library.sol │ │ ├── event_static_calldata_uint_array_and_dynamic_array.sol │ │ ├── event_string.sol │ │ ├── event_struct_memory_v2.sol │ │ ├── event_struct_storage_v2.sol │ │ ├── events_with_same_name.sol │ │ ├── events_with_same_name_file_level.sol │ │ ├── events_with_same_name_inherited_emit.sol │ │ └── simple.sol │ ├── experimental │ │ ├── stub.sol │ │ └── type_class.sol │ ├── exponentiation │ │ ├── literal_base.sol │ │ ├── signed_base.sol │ │ └── small_exp.sol │ ├── expressions │ │ ├── bit_operators.sol │ │ ├── bytes_comparison.sol │ │ ├── conditional_expression_different_types.sol │ │ ├── conditional_expression_false_literal.sol │ │ ├── conditional_expression_functions.sol │ │ ├── conditional_expression_multiple.sol │ │ ├── conditional_expression_storage_memory_1.sol │ │ ├── conditional_expression_storage_memory_2.sol │ │ ├── conditional_expression_true_literal.sol │ │ ├── conditional_expression_tuples.sol │ │ ├── conditional_expression_with_return_values.sol │ │ ├── exp_operator_const.sol │ │ ├── exp_operator_const_signed.sol │ │ ├── exp_zero_literal.sol │ │ ├── inc_dec_operators.sol │ │ ├── module_from_ternary_expression.sol │ │ ├── tuple_from_ternary_expression.sol │ │ ├── unary_too_long_literal.sol │ │ └── uncalled_address_transfer_send.sol │ ├── externalContracts │ │ ├── FixedFeeRegistrar.sol │ │ ├── _base64 │ │ │ ├── base64_inline_asm.sol │ │ │ └── base64_no_inline_asm.sol │ │ ├── _prbmath │ │ │ ├── LICENSE.md │ │ │ ├── PRBMathCommon.sol │ │ │ ├── PRBMathSD59x18.sol │ │ │ ├── PRBMathUD60x18.sol │ │ │ └── README.md │ │ ├── _stringutils │ │ │ ├── LICENSE │ │ │ ├── README.md │ │ │ └── stringutils.sol │ │ ├── base64.sol │ │ ├── deposit_contract.sol │ │ ├── prbmath_signed.sol │ │ ├── prbmath_unsigned.sol │ │ ├── ramanujan_pi.sol │ │ ├── snark.sol │ │ └── strings.sol │ ├── externalSource │ │ ├── _external │ │ │ ├── external.sol │ │ │ ├── external.sol=sol │ │ │ ├── import.sol │ │ │ ├── import_with_subdir.sol │ │ │ ├── other_external.sol │ │ │ └── subdir │ │ │ │ ├── import.sol │ │ │ │ └── sub_external.sol │ │ ├── _nonNormalizedPaths │ │ │ ├── a.sol │ │ │ ├── c.sol │ │ │ └── d.sol │ │ ├── _relativeImports │ │ │ ├── D │ │ │ │ └── d.sol │ │ │ ├── c.sol │ │ │ ├── dir │ │ │ │ ├── B │ │ │ │ │ └── b.sol │ │ │ │ ├── G │ │ │ │ │ └── g.sol │ │ │ │ ├── a.sol │ │ │ │ └── contract.sol │ │ │ └── h.sol │ │ ├── _sourceNameStartingWithDots │ │ │ ├── b.sol │ │ │ ├── dir │ │ │ │ ├── a.sol │ │ │ │ └── contract.sol │ │ │ ├── dot_a.sol │ │ │ └── dot_dot_b.sol │ │ ├── multiple_equals_signs.sol │ │ ├── multiple_external_source.sol │ │ ├── multisource.sol │ │ ├── non_normalized_paths.sol │ │ ├── relative_imports.sol │ │ ├── source.sol │ │ ├── source_import.sol │ │ ├── source_import_subdir.sol │ │ ├── source_name_starting_with_dots.sol │ │ └── source_remapping.sol │ ├── fallback │ │ ├── call_forward_bytes.sol │ │ ├── falback_return.sol │ │ ├── fallback_argument.sol │ │ ├── fallback_argument_to_storage.sol │ │ ├── fallback_or_receive.sol │ │ ├── fallback_override.sol │ │ ├── fallback_override2.sol │ │ ├── fallback_override_multi.sol │ │ ├── fallback_return_data.sol │ │ ├── inherited.sol │ │ └── short_data_calls_fallback.sol │ ├── freeFunctions │ │ ├── easy.sol │ │ ├── free_namesake_contract_function.sol │ │ ├── free_runtimecode.sol │ │ ├── import.sol │ │ ├── libraries_from_free.sol │ │ ├── new_operator.sol │ │ ├── overloads.sol │ │ ├── recursion.sol │ │ └── storage_calldata_refs.sol │ ├── functionCall │ │ ├── array_multiple_local_vars.sol │ │ ├── bare_call_no_returndatacopy.sol │ │ ├── call_attached_library_function_on_function.sol │ │ ├── call_attached_library_function_on_storage_variable.sol │ │ ├── call_attached_library_function_on_string.sol │ │ ├── call_function_returning_function.sol │ │ ├── call_function_returning_nothing_via_pointer.sol │ │ ├── call_internal_function_via_expression.sol │ │ ├── call_internal_function_with_multislot_arguments_via_pointer.sol │ │ ├── call_options_overload.sol │ │ ├── calling_nonexisting_contract_throws.sol │ │ ├── calling_other_functions.sol │ │ ├── calling_uninitialized_function.sol │ │ ├── calling_uninitialized_function_in_detail.sol │ │ ├── calling_uninitialized_function_through_array.sol │ │ ├── conditional_with_arguments.sol │ │ ├── creation_function_call_no_args.sol │ │ ├── creation_function_call_with_args.sol │ │ ├── creation_function_call_with_salt.sol │ │ ├── delegatecall_return_value.sol │ │ ├── delegatecall_return_value_pre_byzantium.sol │ │ ├── disordered_named_args.sol │ │ ├── eof │ │ │ ├── call_options_overload.sol │ │ │ ├── calling_nonexisting_contract.sol │ │ │ ├── external_call_at_construction_time.sol │ │ │ └── external_call_to_nonexisting.sol │ │ ├── external_call.sol │ │ ├── external_call_at_construction_time.sol │ │ ├── external_call_dynamic_returndata.sol │ │ ├── external_call_to_nonexisting.sol │ │ ├── external_call_to_nonexisting_debugstrings.sol │ │ ├── external_call_value.sol │ │ ├── external_function.sol │ │ ├── external_public_override.sol │ │ ├── failed_create.sol │ │ ├── file_level_call_via_module.sol │ │ ├── gas_and_value_basic.sol │ │ ├── inheritance │ │ │ ├── base_base_overload.sol │ │ │ ├── base_overload.sol │ │ │ ├── call_base.sol │ │ │ ├── call_base_base.sol │ │ │ ├── call_base_base_explicit.sol │ │ │ ├── call_base_explicit.sol │ │ │ ├── call_unimplemented_base.sol │ │ │ ├── super_skip_unimplemented_in_abstract_contract.sol │ │ │ └── super_skip_unimplemented_in_interface.sol │ │ ├── mapping_array_internal_argument.sol │ │ ├── mapping_internal_argument.sol │ │ ├── mapping_internal_return.sol │ │ ├── member_accessors.sol │ │ ├── multiple_functions.sol │ │ ├── multiple_return_values.sol │ │ ├── named_args.sol │ │ ├── named_args_overload.sol │ │ ├── precompile_extcodesize_check.sol │ │ ├── return_size_bigger_than_expected.sol │ │ ├── return_size_shorter_than_expected.sol │ │ ├── return_size_shorter_than_expected_evm_version_after_homestead.sol │ │ ├── send_zero_ether.sol │ │ ├── transaction_status.sol │ │ └── value_test.sol │ ├── functionSelector │ │ └── function_selector_via_contract_name.sol │ ├── functionTypes │ │ ├── address_member.sol │ │ ├── call_to_zero_initialized_function_type_ir.sol │ │ ├── call_to_zero_initialized_function_type_legacy.sol │ │ ├── comparison_operator_for_external_function_cleans_dirty_bits.sol │ │ ├── comparison_operators_for_external_functions.sol │ │ ├── duplicated_function_definition_with_same_id_in_internal_dispatcher.sol │ │ ├── external_functions_with_calldata_args_assigned_to_function_pointers_with_memory_type.sol │ │ ├── function_delete_stack.sol │ │ ├── function_delete_storage.sol │ │ ├── function_external_delete_storage.sol │ │ ├── function_type_library_internal.sol │ │ ├── inline_array_with_value_call_option.sol │ │ ├── mapping_of_functions.sol │ │ ├── pass_function_types_externally.sol │ │ ├── pass_function_types_internally.sol │ │ ├── same_function_in_construction_and_runtime.sol │ │ ├── same_function_in_construction_and_runtime_equality_check.sol │ │ ├── selector_1.sol │ │ ├── selector_2.sol │ │ ├── selector_assignment_expression.sol │ │ ├── selector_expression_side_effect.sol │ │ ├── selector_ternary.sol │ │ ├── selector_ternary_function_pointer_from_function_call.sol │ │ ├── stack_height_check_on_adding_gas_variable_to_function.sol │ │ ├── store_function.sol │ │ ├── struct_with_external_function.sol │ │ ├── struct_with_functions.sol │ │ ├── ternary_contract_internal_function.sol │ │ ├── ternary_contract_library_internal_function.sol │ │ ├── ternary_contract_public_function.sol │ │ └── uninitialized_internal_storage_function_call.sol │ ├── getters │ │ ├── array_mapping_struct.sol │ │ ├── arrays.sol │ │ ├── bytes.sol │ │ ├── mapping.sol │ │ ├── mapping_array_struct.sol │ │ ├── mapping_of_string.sol │ │ ├── mapping_to_struct.sol │ │ ├── mapping_with_names.sol │ │ ├── string_and_bytes.sol │ │ ├── struct_with_bytes.sol │ │ ├── struct_with_bytes_simple.sol │ │ ├── transient_value_types.sol │ │ ├── transient_value_types_multi_frame_call.sol │ │ └── value_types.sol │ ├── immutable │ │ ├── assign_at_declaration.sol │ │ ├── assign_from_immutables.sol │ │ ├── delete.sol │ │ ├── fun_read_in_ctor.sol │ │ ├── getter.sol │ │ ├── getter_call_in_constructor.sol │ │ ├── immutable_signed.sol │ │ ├── immutable_tag_too_large_bug.sol │ │ ├── increment_decrement.sol │ │ ├── inheritance.sol │ │ ├── internal_function_pointer.sol │ │ ├── multi_creation.sol │ │ ├── multiple_initializations.sol │ │ ├── read_in_ctor.sol │ │ ├── small_types_in_reverse.sol │ │ ├── stub.sol │ │ ├── uninitialized.sol │ │ └── use_scratch.sol │ ├── index.yaml │ ├── inheritance │ │ ├── access_base_storage.sol │ │ ├── address_overload_resolution.sol │ │ ├── base_access_to_function_type_variables.sol │ │ ├── constructor_inheritance_init_order.sol │ │ ├── constructor_inheritance_init_order_2.sol │ │ ├── constructor_inheritance_init_order_3_legacy.sol │ │ ├── constructor_inheritance_init_order_3_viaIR.sol │ │ ├── constructor_with_params.sol │ │ ├── constructor_with_params_diamond_inheritance.sol │ │ ├── constructor_with_params_inheritance.sol │ │ ├── constructor_with_params_inheritance_2.sol │ │ ├── dataLocation │ │ │ └── external_public_calldata.sol │ │ ├── derived_overload_base_function_direct.sol │ │ ├── derived_overload_base_function_indirect.sol │ │ ├── explicit_base_class.sol │ │ ├── inherited_constant_state_var.sol │ │ ├── inherited_function.sol │ │ ├── inherited_function_calldata_calldata_interface.sol │ │ ├── inherited_function_calldata_memory.sol │ │ ├── inherited_function_calldata_memory_interface.sol │ │ ├── inherited_function_from_a_library.sol │ │ ├── inherited_function_through_dispatch.sol │ │ ├── interface_inheritance_conversions.sol │ │ ├── member_notation_ctor.sol │ │ ├── overloaded_function_call_resolve_to_first.sol │ │ ├── overloaded_function_call_resolve_to_second.sol │ │ ├── overloaded_function_call_with_if_else.sol │ │ ├── pass_dynamic_arguments_to_the_base.sol │ │ ├── pass_dynamic_arguments_to_the_base_base.sol │ │ ├── pass_dynamic_arguments_to_the_base_base_with_gap.sol │ │ ├── state_variables_init_order.sol │ │ ├── state_variables_init_order_2.sol │ │ ├── state_variables_init_order_3.sol │ │ ├── super_in_constructor.sol │ │ ├── super_in_constructor_assignment.sol │ │ ├── super_overload.sol │ │ ├── transient_storage_state_variable.sol │ │ ├── transient_storage_state_variable_abstract_contract.sol │ │ └── value_for_constructor.sol │ ├── inlineAssembly │ │ ├── basefee_berlin_function.sol │ │ ├── blobbasefee_shanghai_function.sol │ │ ├── blobhash.sol │ │ ├── blobhash_index_exceeding_blob_count.sol │ │ ├── blobhash_pre_cancun.sol │ │ ├── calldata_array_assign_dynamic.sol │ │ ├── calldata_array_assign_static.sol │ │ ├── calldata_array_read.sol │ │ ├── calldata_assign.sol │ │ ├── calldata_assign_from_nowhere.sol │ │ ├── calldata_length_read.sol │ │ ├── calldata_offset_read.sol │ │ ├── calldata_offset_read_write.sol │ │ ├── calldata_struct_assign.sol │ │ ├── calldata_struct_assign_and_return.sol │ │ ├── chainid.sol │ │ ├── constant_access.sol │ │ ├── constant_access_referencing.sol │ │ ├── difficulty.sol │ │ ├── external_function_pointer_address.sol │ │ ├── external_function_pointer_address_assignment.sol │ │ ├── external_function_pointer_selector.sol │ │ ├── external_function_pointer_selector_assignment.sol │ │ ├── external_identifier_access_shadowing.sol │ │ ├── for_loop_break.sol │ │ ├── for_loop_continue.sol │ │ ├── for_loop_nested.sol │ │ ├── function_name_clash.sol │ │ ├── inline_assembly_embedded_function_call.sol │ │ ├── inline_assembly_for.sol │ │ ├── inline_assembly_for2.sol │ │ ├── inline_assembly_function_call.sol │ │ ├── inline_assembly_function_call2.sol │ │ ├── inline_assembly_function_call_assignment.sol │ │ ├── inline_assembly_if.sol │ │ ├── inline_assembly_in_modifiers.sol │ │ ├── inline_assembly_memory_access.sol │ │ ├── inline_assembly_read_and_write_stack.sol │ │ ├── inline_assembly_recursion.sol │ │ ├── inline_assembly_storage_access.sol │ │ ├── inline_assembly_storage_access_inside_function.sol │ │ ├── inline_assembly_storage_access_local_var.sol │ │ ├── inline_assembly_storage_access_via_pointer.sol │ │ ├── inline_assembly_switch.sol │ │ ├── inline_assembly_transient_storage_access_inside_function.sol │ │ ├── inline_assembly_write_to_stack.sol │ │ ├── inlineasm_empty_let.sol │ │ ├── keccak256_assembly.sol │ │ ├── keccak256_optimization.sol │ │ ├── keccak256_optimizer_bug_different_memory_location.sol │ │ ├── keccak256_optimizer_cache_bug.sol │ │ ├── keccak_optimization_bug_string.sol │ │ ├── keccak_yul_optimization.sol │ │ ├── leave.sol │ │ ├── mcopy.sol │ │ ├── mcopy_as_identifier_pre_cancun.sol │ │ ├── mcopy_empty.sol │ │ ├── mcopy_overlap.sol │ │ ├── optimize_memory_store_multi_block.sol │ │ ├── optimize_memory_store_multi_block_bugreport.sol │ │ ├── prevrandao.sol │ │ ├── selfbalance.sol │ │ ├── shadowing_local_function_opcode.sol │ │ ├── slot_access.sol │ │ ├── slot_access_via_mapping_pointer.sol │ │ ├── tload_tstore_not_reserved_before_cancun.sol │ │ ├── transient_storage_creation.sol │ │ ├── transient_storage_low_level_calls.sol │ │ ├── transient_storage_multiple_calls_different_transactions.sol │ │ ├── transient_storage_multiple_transactions.sol │ │ ├── transient_storage_reset_between_creation_runtime.sol │ │ ├── transient_storage_sanity_checks.sol │ │ ├── transient_storage_selfdestruct.sol │ │ ├── transient_storage_simple_reentrancy_lock.sol │ │ ├── truefalse.sol │ │ └── tstore_hidden_staticcall.sol │ ├── integer │ │ ├── basic.sol │ │ ├── int.sol │ │ ├── many_local_variables.sol │ │ ├── small_signed_types.sol │ │ └── uint.sol │ ├── interfaceID │ │ ├── homer.sol │ │ ├── homer_interfaceId.sol │ │ ├── interfaceId_events.sol │ │ ├── interfaces.sol │ │ ├── lisa.sol │ │ └── lisa_interfaceId.sol │ ├── isoltestTesting │ │ ├── account.sol │ │ ├── balance_other_contract.sol │ │ ├── balance_with_balance.sol │ │ ├── balance_with_balance2.sol │ │ ├── balance_without_balance.sol │ │ ├── builtins.sol │ │ ├── effects.sol │ │ ├── empty_contract.sol │ │ ├── format_raw_string_with_control_chars.sol │ │ ├── isoltestFormatting.sol │ │ ├── precompiles_ignoring_trailing_input.sol │ │ └── storage │ │ │ ├── storage_empty.sol │ │ │ └── storage_nonempty.sol │ ├── libraries │ │ ├── attached_internal_library_function_accepting_calldata.sol │ │ ├── attached_internal_library_function_returning_calldata.sol │ │ ├── attached_public_library_function_accepting_calldata.sol.sol │ │ ├── attached_public_library_function_returning_calldata.sol │ │ ├── external_call_with_function_pointer_parameter.sol │ │ ├── external_call_with_storage_array_parameter.sol │ │ ├── external_call_with_storage_mapping_parameter.sol │ │ ├── internal_call_attached_with_parentheses.sol │ │ ├── internal_call_unattached_with_parentheses.sol │ │ ├── internal_library_function.sol │ │ ├── internal_library_function_attached_to_address.sol │ │ ├── internal_library_function_attached_to_address_named_send_transfer.sol │ │ ├── internal_library_function_attached_to_array_named_pop_push.sol │ │ ├── internal_library_function_attached_to_bool.sol │ │ ├── internal_library_function_attached_to_contract.sol │ │ ├── internal_library_function_attached_to_dynamic_array.sol │ │ ├── internal_library_function_attached_to_enum.sol │ │ ├── internal_library_function_attached_to_external_function_type.sol │ │ ├── internal_library_function_attached_to_fixed_array.sol │ │ ├── internal_library_function_attached_to_fixed_bytes.sol │ │ ├── internal_library_function_attached_to_integer.sol │ │ ├── internal_library_function_attached_to_interface.sol │ │ ├── internal_library_function_attached_to_internal_function_type.sol │ │ ├── internal_library_function_attached_to_internal_function_type_named_selector.sol │ │ ├── internal_library_function_attached_to_literal.sol │ │ ├── internal_library_function_attached_to_mapping.sol │ │ ├── internal_library_function_attached_to_string_accepting_memory.sol │ │ ├── internal_library_function_attached_to_string_accepting_storage.sol │ │ ├── internal_library_function_attached_to_struct.sol │ │ ├── internal_library_function_calling_private.sol │ │ ├── internal_library_function_pointer.sol │ │ ├── internal_library_function_return_var_size.sol │ │ ├── internal_types_in_library.sol │ │ ├── library_address.sol │ │ ├── library_address_homestead.sol │ │ ├── library_address_via_module.sol │ │ ├── library_call_in_homestead.sol │ │ ├── library_delegatecall_guard_pure.sol │ │ ├── library_delegatecall_guard_view_needed.sol │ │ ├── library_delegatecall_guard_view_not_needed.sol │ │ ├── library_delegatecall_guard_view_staticcall.sol │ │ ├── library_enum_as_an_expression.sol │ │ ├── library_function_selectors.sol │ │ ├── library_function_selectors_struct.sol │ │ ├── library_references_preserve.sol │ │ ├── library_return_struct_with_mapping.sol │ │ ├── library_staticcall_delegatecall.sol │ │ ├── library_stray_values.sol │ │ ├── library_struct_as_an_expression.sol │ │ ├── mapping_arguments_in_library.sol │ │ ├── mapping_returns_in_library.sol │ │ ├── mapping_returns_in_library_named.sol │ │ ├── payable_function_calls_library.sol │ │ ├── stub.sol │ │ ├── stub_internal.sol │ │ ├── using_for_by_name.sol │ │ ├── using_for_function_on_int.sol │ │ ├── using_for_overload.sol │ │ ├── using_for_storage_structs.sol │ │ ├── using_library_mappings_public.sol │ │ ├── using_library_mappings_return.sol │ │ └── using_library_structs.sol │ ├── literals │ │ ├── denominations.sol │ │ ├── denominations_in_array_sizes.sol │ │ ├── escape.sol │ │ ├── ether.sol │ │ ├── fractional_denominations.sol │ │ ├── gwei.sol │ │ ├── hex_string_with_non_printable_characters.sol │ │ ├── hex_string_with_underscore.sol │ │ ├── scientific_notation.sol │ │ ├── ternary_operator_with_literal_types_overflow.sol │ │ └── wei.sol │ ├── memoryManagement │ │ ├── assembly_access.sol │ │ ├── memory_types_initialisation.sol │ │ ├── return_variable.sol │ │ ├── static_memory_array_allocation.sol │ │ └── struct_allocation.sol │ ├── metaTypes │ │ └── name_other_contract.sol │ ├── modifiers │ │ ├── access_through_contract_name.sol │ │ ├── access_through_module_name.sol │ │ ├── break_in_modifier.sol │ │ ├── continue_in_modifier.sol │ │ ├── evaluation_order.sol │ │ ├── function_modifier.sol │ │ ├── function_modifier_calling_functions_in_creation_context.sol │ │ ├── function_modifier_empty.sol │ │ ├── function_modifier_for_constructor.sol │ │ ├── function_modifier_library.sol │ │ ├── function_modifier_library_inheritance.sol │ │ ├── function_modifier_local_variables.sol │ │ ├── function_modifier_loop.sol │ │ ├── function_modifier_loop_viair.sol │ │ ├── function_modifier_multi_invocation.sol │ │ ├── function_modifier_multi_invocation_viair.sol │ │ ├── function_modifier_multi_with_return.sol │ │ ├── function_modifier_multiple_times.sol │ │ ├── function_modifier_multiple_times_local_vars.sol │ │ ├── function_modifier_overriding.sol │ │ ├── function_modifier_return_reference.sol │ │ ├── function_return_parameter.sol │ │ ├── function_return_parameter_complex.sol │ │ ├── modifer_recursive.sol │ │ ├── modifier_in_constructor_ice.sol │ │ ├── modifier_init_return.sol │ │ ├── modifiers_in_construction_context.sol │ │ ├── return_does_not_skip_modifier.sol │ │ ├── return_in_modifier.sol │ │ ├── stacked_return_with_modifiers.sol │ │ └── transient_state_variable_value_type.sol │ ├── multiSource │ │ ├── circular_import.sol │ │ ├── circular_import_2.sol │ │ ├── circular_reimport.sol │ │ ├── circular_reimport_2.sol │ │ ├── free_different_interger_types.sol │ │ ├── free_function_resolution_base_contract.sol │ │ ├── free_function_resolution_override_virtual.sol │ │ ├── free_function_resolution_override_virtual_super.sol │ │ ├── free_function_resolution_override_virtual_transitive.sol │ │ ├── free_function_transitive_import.sol │ │ ├── import.sol │ │ ├── import_overloaded_function.sol │ │ ├── imported_free_function_via_alias.sol │ │ ├── imported_free_function_via_alias_direct_call.sol │ │ └── reimport_imported_function.sol │ ├── operators │ │ ├── compound_assign.sol │ │ ├── compound_assign_transient_storage.sol │ │ ├── shifts │ │ │ ├── bitwise_shifting_constantinople.sol │ │ │ ├── bitwise_shifting_constantinople_combined.sol │ │ │ ├── bitwise_shifting_constants_constantinople.sol │ │ │ ├── shift_bytes_cleanup.sol │ │ │ ├── shift_bytes_cleanup_viaYul.sol │ │ │ ├── shift_cleanup.sol │ │ │ ├── shift_cleanup_garbled.sol │ │ │ ├── shift_constant_left.sol │ │ │ ├── shift_constant_left_assignment.sol │ │ │ ├── shift_constant_right.sol │ │ │ ├── shift_constant_right_assignment.sol │ │ │ ├── shift_left.sol │ │ │ ├── shift_left_assignment.sol │ │ │ ├── shift_left_assignment_different_type.sol │ │ │ ├── shift_left_larger_type.sol │ │ │ ├── shift_left_uint32.sol │ │ │ ├── shift_left_uint8.sol │ │ │ ├── shift_negative_constant_left.sol │ │ │ ├── shift_negative_constant_right.sol │ │ │ ├── shift_overflow.sol │ │ │ ├── shift_right.sol │ │ │ ├── shift_right_assignment.sol │ │ │ ├── shift_right_garbled_signed_v1.sol │ │ │ ├── shift_right_garbled_signed_v2.sol │ │ │ ├── shift_right_garbled_v1.sol │ │ │ ├── shift_right_garbled_v2.sol │ │ │ ├── shift_right_negative_literal.sol │ │ │ ├── shift_right_negative_lvalue.sol │ │ │ ├── shift_right_negative_lvalue_assignment.sol │ │ │ ├── shift_right_negative_lvalue_int16.sol │ │ │ ├── shift_right_negative_lvalue_int32.sol │ │ │ ├── shift_right_negative_lvalue_int8.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int16_v1.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int16_v2.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int32_v1.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int32_v2.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int8_v1.sol │ │ │ ├── shift_right_negative_lvalue_signextend_int8_v2.sol │ │ │ ├── shift_right_uint32.sol │ │ │ ├── shift_right_uint8.sol │ │ │ ├── shift_underflow_negative_rvalue.sol │ │ │ └── shifts.sol │ │ ├── transient_storage_variable_increment_decrement.sol │ │ └── userDefined │ │ │ ├── all_possible_operators.sol │ │ │ ├── all_possible_user_defined_value_types_with_operators.sol │ │ │ ├── attaching_and_defining_operator_with_same_function.sol │ │ │ ├── checked_operators.sol │ │ │ ├── consecutive_operator_invocations.sol │ │ │ ├── fixed_point_udvt_with_operators.sol │ │ │ ├── multiple_operator_definitions_different_types_different_functions_separate_directives.sol │ │ │ ├── multiple_operator_definitions_same_type_same_function_same_directive.sol │ │ │ ├── operator_definition_shadowing_builtin_keccak256.sol │ │ │ ├── operator_evaluation_order.sol │ │ │ ├── operator_making_pure_external_call.sol │ │ │ ├── operator_making_view_external_call.sol │ │ │ ├── operator_parameter_and_return_cleanup_between_calls.sol │ │ │ ├── operator_parameter_cleanup.sol │ │ │ ├── operator_precendence.sol │ │ │ ├── operator_return_parameter_cleanup.sol │ │ │ ├── recursive_operator.sol │ │ │ └── unchecked_operators.sol │ ├── optimizer │ │ ├── shift_bytes.sol │ │ └── unused_store_storage_removal_bug.sol │ ├── payable │ │ └── no_nonpayable_circumvention_by_modifier.sol │ ├── receive │ │ ├── empty_calldata_calls_receive.sol │ │ ├── ether_and_data.sol │ │ └── inherited.sol │ ├── revertStrings │ │ ├── array_slices.sol │ │ ├── bubble.sol │ │ ├── calldata_array_dynamic_invalid.sol │ │ ├── calldata_array_dynamic_static_short_decode.sol │ │ ├── calldata_array_dynamic_static_short_reencode.sol │ │ ├── calldata_array_invalid_length.sol │ │ ├── calldata_arrays_too_large.sol │ │ ├── calldata_tail_short.sol │ │ ├── calldata_too_short_v1.sol │ │ ├── called_contract_has_code.sol │ │ ├── empty_v1.sol │ │ ├── empty_v2.sol │ │ ├── enum_v1.sol │ │ ├── enum_v2.sol │ │ ├── ether_non_payable_function.sol │ │ ├── function_entry_checks_v1.sol │ │ ├── function_entry_checks_v2.sol │ │ ├── invalid_abi_decoding_calldata_v1.sol │ │ ├── invalid_abi_decoding_memory_v1.sol │ │ ├── library_non_view_call.sol │ │ ├── short_input_array.sol │ │ ├── short_input_bytes.sol │ │ ├── transfer.sol │ │ └── unknown_sig_no_fallback.sol │ ├── reverts │ │ ├── assert_require.sol │ │ ├── eof │ │ │ └── revert_return_area.sol │ │ ├── error_struct.sol │ │ ├── invalid_enum_as_external_arg.sol │ │ ├── invalid_enum_as_external_ret.sol │ │ ├── invalid_enum_compared.sol │ │ ├── invalid_enum_stored.sol │ │ ├── invalid_instruction.sol │ │ ├── revert.sol │ │ ├── revert_return_area.sol │ │ └── simple_throw.sol │ ├── saltedCreate │ │ ├── eof │ │ │ └── salted_create_with_value.sol │ │ ├── prediction_example.sol │ │ ├── salted_create.sol │ │ └── salted_create_with_value.sol │ ├── scoping │ │ └── c99_scoping_activation.sol │ ├── shanghai │ │ ├── evmone_support.sol │ │ └── push0.sol │ ├── smoke │ │ ├── alignment.sol │ │ ├── arrays.sol │ │ ├── basic.sol │ │ ├── bytes_and_strings.sol │ │ ├── constructor.sol │ │ ├── failure.sol │ │ ├── fallback.sol │ │ ├── multiline.sol │ │ ├── multiline_comments.sol │ │ └── structs.sol │ ├── specialFunctions │ │ ├── abi_encode_with_signature_from_string.sol │ │ ├── abi_functions_member_access.sol │ │ └── keccak256_optimized.sol │ ├── state │ │ ├── blobhash.sol │ │ ├── block_basefee.sol │ │ ├── block_blobbasefee.sol │ │ ├── block_chainid.sol │ │ ├── block_coinbase.sol │ │ ├── block_difficulty.sol │ │ ├── block_difficulty_post_paris.sol │ │ ├── block_gaslimit.sol │ │ ├── block_number.sol │ │ ├── block_prevrandao.sol │ │ ├── block_prevrandao_pre_paris.sol │ │ ├── block_timestamp.sol │ │ ├── blockhash_basic.sol │ │ ├── gasleft.sol │ │ ├── msg_data.sol │ │ ├── msg_sender.sol │ │ ├── msg_sig.sol │ │ ├── msg_value.sol │ │ ├── tx_gasprice.sol │ │ ├── tx_origin.sol │ │ ├── uncalled_blobhash.sol │ │ └── uncalled_blockhash.sol │ ├── statements │ │ ├── do_while_loop_continue.sol │ │ └── empty_for_loop.sol │ ├── storage │ │ ├── accessors_mapping_for_array.sol │ │ ├── array_accessor.sol │ │ ├── chop_sign_bits.sol │ │ ├── complex_accessors.sol │ │ ├── empty_nonempty_empty.sol │ │ ├── mapping_state.sol │ │ ├── mapping_string_key.sol │ │ ├── mappings_array2d_pop_delete.sol │ │ ├── mappings_array_pop_delete.sol │ │ ├── packed_functions.sol │ │ ├── packed_storage_overflow.sol │ │ ├── packed_storage_signed.sol │ │ ├── packed_storage_structs_bytes.sol │ │ ├── packed_storage_structs_enum.sol │ │ ├── packed_storage_structs_uint.sol │ │ ├── simple_accessor.sol │ │ ├── state_smoke_test.sol │ │ └── struct_accessor.sol │ ├── storageLayoutSpecifier │ │ ├── base_slot_max_value.sol │ │ ├── constructor.sol │ │ ├── delete.sol │ │ ├── delete_transient_storage.sol │ │ ├── dynamic_array_storage_end.sol │ │ ├── function_from_base_contract.sol │ │ ├── getters.sol │ │ ├── inheritance_from_abstract_contract.sol │ │ ├── inheritance_from_interface.sol │ │ ├── inheritance_from_same_base_state_var_slots.sol │ │ ├── inheritance_simple.sol │ │ ├── inheritance_state_variable_slot_offset.sol │ │ ├── inline_assembly_direct_load.sol │ │ ├── inline_assembly_direct_store.sol │ │ ├── last_allowed_storage_slot.sol │ │ ├── mapping_storage_end.sol │ │ ├── multiple_inheritance.sol │ │ ├── multiple_inheritance_state_var_slots.sol │ │ ├── state_variable_arithmetic_expression.sol │ │ ├── state_variable_constant_and_immutable.sol │ │ ├── state_variable_dynamic_array.sol │ │ ├── state_variable_enum.sol │ │ ├── state_variable_mapping.sol │ │ ├── state_variable_reference_types_slot_offset.sol │ │ ├── state_variable_slot_offset.sol │ │ ├── state_variable_struct.sol │ │ ├── state_variables_transient.sol │ │ ├── storage_reference_array.sol │ │ ├── storage_reference_inheritance.sol │ │ ├── storage_reference_library_function.sol │ │ ├── transient_state_variable_slot_offset.sol │ │ ├── variable_cleanup.sol │ │ ├── variable_cleanup_sstore.sol │ │ └── virtual_functions.sol │ ├── strings │ │ ├── concat │ │ │ ├── string_concat_2_args.sol │ │ │ ├── string_concat_different_types.sol │ │ │ ├── string_concat_empty_argument_list.sol │ │ │ ├── string_concat_empty_strings.sol │ │ │ └── string_concat_nested.sol │ │ ├── constant_string_literal.sol │ │ ├── empty_storage_string.sol │ │ ├── empty_string.sol │ │ ├── empty_string_input.sol │ │ ├── return_string.sol │ │ ├── string_escapes.sol │ │ ├── unicode_escapes.sol │ │ └── unicode_string.sol │ ├── structs │ │ ├── array_of_recursive_struct.sol │ │ ├── calldata │ │ │ ├── calldata_nested_structs.sol │ │ │ ├── calldata_struct.sol │ │ │ ├── calldata_struct_and_ints.sol │ │ │ ├── calldata_struct_array_member.sol │ │ │ ├── calldata_struct_array_member_dynamic.sol │ │ │ ├── calldata_struct_as_argument_of_lib_function.sol │ │ │ ├── calldata_struct_as_memory_argument.sol │ │ │ ├── calldata_struct_struct_member.sol │ │ │ ├── calldata_struct_struct_member_dynamic.sol │ │ │ ├── calldata_struct_to_memory.sol │ │ │ ├── calldata_struct_to_memory_tuple_assignment.sol │ │ │ ├── calldata_struct_to_storage.sol │ │ │ ├── calldata_struct_with_array_to_memory.sol │ │ │ ├── calldata_struct_with_bytes_to_memory.sol │ │ │ ├── calldata_struct_with_nested_array_to_memory.sol │ │ │ ├── calldata_struct_with_nested_array_to_storage.sol │ │ │ ├── calldata_structs.sol │ │ │ ├── dynamic_nested.sol │ │ │ └── dynamically_encoded.sol │ │ ├── conversion │ │ │ ├── recursive_storage_memory.sol │ │ │ └── recursive_storage_memory_complex.sol │ │ ├── copy_from_mapping.sol │ │ ├── copy_from_storage.sol │ │ ├── copy_struct_array_from_storage.sol │ │ ├── copy_struct_with_nested_array_from_calldata_to_memory.sol │ │ ├── copy_struct_with_nested_array_from_calldata_to_storage.sol │ │ ├── copy_struct_with_nested_array_from_memory_to_memory.sol │ │ ├── copy_struct_with_nested_array_from_storage_to_storage.sol │ │ ├── copy_substructures_from_mapping.sol │ │ ├── copy_substructures_to_mapping.sol │ │ ├── copy_to_mapping.sol │ │ ├── delete_struct.sol │ │ ├── event.sol │ │ ├── function_type_copy.sol │ │ ├── global.sol │ │ ├── lone_struct_array_type.sol │ │ ├── memory_struct_named_constructor.sol │ │ ├── memory_structs_as_function_args.sol │ │ ├── memory_structs_nested.sol │ │ ├── memory_structs_nested_load.sol │ │ ├── memory_structs_read_write.sol │ │ ├── msg_data_to_struct_member_copy.sol │ │ ├── multislot_struct_allocation.sol │ │ ├── nested_struct_allocation.sol │ │ ├── packed_storage_structs_delete.sol │ │ ├── recursive_struct_2.sol │ │ ├── recursive_structs.sol │ │ ├── simple_struct_allocation.sol │ │ ├── struct_assign_reference_to_struct.sol │ │ ├── struct_constructor_nested.sol │ │ ├── struct_containing_bytes_copy_and_delete.sol │ │ ├── struct_copy.sol │ │ ├── struct_copy_via_local.sol │ │ ├── struct_delete_member.sol │ │ ├── struct_delete_storage.sol │ │ ├── struct_delete_storage_nested_small.sol │ │ ├── struct_delete_storage_small.sol │ │ ├── struct_delete_storage_with_array.sol │ │ ├── struct_delete_storage_with_arrays_small.sol │ │ ├── struct_delete_struct_in_mapping.sol │ │ ├── struct_memory_to_storage.sol │ │ ├── struct_memory_to_storage_function_ptr.sol │ │ ├── struct_named_constructor.sol │ │ ├── struct_reference.sol │ │ ├── struct_referencing.sol │ │ ├── struct_storage_push_zero_value.sol │ │ ├── struct_storage_to_mapping.sol │ │ ├── struct_storage_to_memory.sol │ │ ├── struct_storage_to_memory_function_ptr.sol │ │ ├── structs.sol │ │ └── using_for_function_on_struct.sol │ ├── tryCatch │ │ ├── assert.sol │ │ ├── assert_pre_byzantium.sol │ │ ├── create.sol │ │ ├── invalid_error_encoding.sol │ │ ├── lowLevel.sol │ │ ├── malformed_error.sol │ │ ├── malformed_panic.sol │ │ ├── malformed_panic_2.sol │ │ ├── malformed_panic_3.sol │ │ ├── malformed_panic_4.sol │ │ ├── nested.sol │ │ ├── panic.sol │ │ ├── require.sol │ │ ├── require_pre_byzantium.sol │ │ ├── return_function.sol │ │ ├── simple.sol │ │ ├── simple_notuple.sol │ │ ├── structured.sol │ │ ├── structuredAndLowLevel.sol │ │ └── try_catch_library_call.sol │ ├── types │ │ ├── array_mapping_abstract_constructor_param.sol │ │ ├── assign_calldata_value_type.sol │ │ ├── convert_fixed_bytes_to_fixed_bytes_greater_size.sol │ │ ├── convert_fixed_bytes_to_fixed_bytes_same_size.sol │ │ ├── convert_fixed_bytes_to_fixed_bytes_smaller_size.sol │ │ ├── convert_fixed_bytes_to_uint_greater_size.sol │ │ ├── convert_fixed_bytes_to_uint_same_min_size.sol │ │ ├── convert_fixed_bytes_to_uint_same_type.sol │ │ ├── convert_fixed_bytes_to_uint_smaller_size.sol │ │ ├── convert_uint_to_fixed_bytes_greater_size.sol │ │ ├── convert_uint_to_fixed_bytes_same_min_size.sol │ │ ├── convert_uint_to_fixed_bytes_same_size.sol │ │ ├── convert_uint_to_fixed_bytes_smaller_size.sol │ │ ├── external_function_to_address.sol │ │ ├── mapping │ │ │ ├── copy_from_mapping_to_mapping.sol │ │ │ ├── copy_struct_to_array_stored_in_mapping.sol │ │ │ └── user_defined_types_mapping_storage.sol │ │ ├── mapping_abstract_constructor_param.sol │ │ ├── mapping_contract_key.sol │ │ ├── mapping_contract_key_getter.sol │ │ ├── mapping_contract_key_library.sol │ │ ├── mapping_enum_key_getter_v1.sol │ │ ├── mapping_enum_key_getter_v2.sol │ │ ├── mapping_enum_key_library_v1.sol │ │ ├── mapping_enum_key_library_v2.sol │ │ ├── mapping_enum_key_v1.sol │ │ ├── mapping_enum_key_v2.sol │ │ ├── mapping_simple.sol │ │ ├── nested_tuples.sol │ │ ├── packing_signed_types.sol │ │ ├── packing_unpacking_types.sol │ │ ├── strings.sol │ │ ├── struct_mapping_abstract_constructor_param.sol │ │ ├── tuple_assign_multi_slot_grow.sol │ │ └── type_conversion_cleanup.sol │ ├── underscore │ │ └── as_function.sol │ ├── uninitializedFunctionPointer │ │ ├── invalidInConstructor.sol │ │ ├── invalidStoredInConstructor.sol │ │ ├── store2.sol │ │ ├── storeInConstructor.sol │ │ ├── uninitialized_internal_storage_function_legacy.sol │ │ └── uninitialized_internal_storage_function_via_yul.sol │ ├── userDefinedValueType │ │ ├── abicodec.sol │ │ ├── assembly_access_bytes2_abicoder_v1.sol │ │ ├── assembly_access_bytes2_abicoder_v2.sol │ │ ├── calldata.sol │ │ ├── calldata_to_storage.sol │ │ ├── cleanup.sol │ │ ├── cleanup_abicoderv1.sol │ │ ├── constant.sol │ │ ├── conversion.sol │ │ ├── conversion_abicoderv1.sol │ │ ├── dirty_slot.sol │ │ ├── dirty_uint8_read.sol │ │ ├── erc20.sol │ │ ├── fixedpoint.sol │ │ ├── immutable_signed.sol │ │ ├── in_parenthesis.sol │ │ ├── mapping_key.sol │ │ ├── memory_to_storage.sol │ │ ├── multisource.sol │ │ ├── multisource_module.sol │ │ ├── ownable.sol │ │ ├── parameter.sol │ │ ├── simple.sol │ │ ├── storage_layout.sol │ │ ├── storage_layout_struct.sol │ │ ├── storage_signed.sol │ │ ├── wrap_unwrap.sol │ │ ├── wrap_unwrap_via_contract_name.sol │ │ ├── zero_cost_abstraction_comparison_elementary.sol │ │ └── zero_cost_abstraction_comparison_userdefined.sol │ ├── using │ │ ├── calldata_memory_copy.sol │ │ ├── free_function_braces.sol │ │ ├── free_function_multi.sol │ │ ├── free_functions_individual.sol │ │ ├── imported_functions.sol │ │ ├── library_functions_inside_contract.sol │ │ ├── library_on_interface.sol │ │ ├── library_through_module.sol │ │ ├── module_renamed.sol │ │ ├── private_library_function.sol │ │ ├── recursive_import.sol │ │ ├── using_global_all_the_types.sol │ │ ├── using_global_for_global.sol │ │ ├── using_global_invisible.sol │ │ └── using_global_library.sol │ ├── variables │ │ ├── delete_local.sol │ │ ├── delete_locals.sol │ │ ├── delete_transient_state_variable.sol │ │ ├── delete_transient_state_variable_non_zero_offset.sol │ │ ├── mapping_local_assignment.sol │ │ ├── mapping_local_compound_assignment.sol │ │ ├── mapping_local_tuple_assignment.sol │ │ ├── public_state_overridding.sol │ │ ├── public_state_overridding_dynamic_struct.sol │ │ ├── public_state_overridding_mapping_to_dynamic_struct.sol │ │ ├── storing_invalid_boolean.sol │ │ ├── transient_function_type_state_variable.sol │ │ ├── transient_state_address_variable_members.sol │ │ ├── transient_state_enum_variable.sol │ │ ├── transient_state_variable.sol │ │ ├── transient_state_variable_cleanup_assignment.sol │ │ ├── transient_state_variable_cleanup_tstore.sol │ │ ├── transient_state_variable_slot_inline_assembly.sol │ │ ├── transient_state_variable_slots_and_offsets.sol │ │ ├── transient_state_variable_tuple_assignment.sol │ │ └── transient_state_variable_udvt.sol │ ├── various │ │ ├── address_code.sol │ │ ├── address_code_complex.sol │ │ ├── assignment_to_const_var_involving_expression.sol │ │ ├── balance.sol │ │ ├── byte_optimization_bug.sol │ │ ├── code_access_content.sol │ │ ├── code_access_create.sol │ │ ├── code_access_padding.sol │ │ ├── code_access_runtime.sol │ │ ├── code_length.sol │ │ ├── code_length_contract_member.sol │ │ ├── codebalance_assembly.sol │ │ ├── codehash.sol │ │ ├── codehash_assembly.sol │ │ ├── contract_binary_dependencies.sol │ │ ├── crazy_elementary_typenames_on_stack.sol │ │ ├── create_calldata.sol │ │ ├── create_random.sol │ │ ├── cross_contract_types.sol │ │ ├── decayed_tuple.sol │ │ ├── destructuring_assignment.sol │ │ ├── different_call_type_transient.sol │ │ ├── empty_name_return_parameter.sol │ │ ├── eof │ │ │ └── create_calldata.sol │ │ ├── erc20.sol │ │ ├── external_types_in_calls.sol │ │ ├── flipping_sign_tests.sol │ │ ├── gasleft_decrease.sol │ │ ├── gasleft_shadow_resolution.sol │ │ ├── inline_member_init.sol │ │ ├── inline_member_init_inheritence.sol │ │ ├── inline_tuple_with_rational_numbers.sol │ │ ├── iszero_bnot_correct.sol │ │ ├── literal_empty_string.sol │ │ ├── many_subassemblies.sol │ │ ├── memory_overwrite.sol │ │ ├── multi_modifiers.sol │ │ ├── multi_variable_declaration.sol │ │ ├── negative_stack_height.sol │ │ ├── nested_calldata_struct.sol │ │ ├── nested_calldata_struct_to_memory.sol │ │ ├── positive_integers_to_signed.sol │ │ ├── selfdestruct.sol │ │ ├── selfdestruct_post_cancun.sol │ │ ├── selfdestruct_post_cancun_multiple_beneficiaries.sol │ │ ├── selfdestruct_post_cancun_redeploy.sol │ │ ├── selfdestruct_pre_cancun.sol │ │ ├── selfdestruct_pre_cancun_multiple_beneficiaries.sol │ │ ├── selfdestruct_pre_cancun_redeploy.sol │ │ ├── senders_balance.sol │ │ ├── single_copy_with_multiple_inheritance.sol │ │ ├── skip_dynamic_types.sol │ │ ├── skip_dynamic_types_for_static_arrays_with_dynamic_elements.sol │ │ ├── skip_dynamic_types_for_structs.sol │ │ ├── state_variable_local_variable_mixture.sol │ │ ├── state_variable_under_contract_name.sol │ │ ├── staticcall_for_view_and_pure.sol │ │ ├── staticcall_for_view_and_pure_pre_byzantium.sol │ │ ├── storage_string_as_mapping_key_without_variable.sol │ │ ├── store_bytes.sol │ │ ├── string_tuples.sol │ │ ├── super.sol │ │ ├── super_alone.sol │ │ ├── super_parentheses.sol │ │ ├── swap_in_storage_overwrite.sol │ │ ├── test_underscore_in_hex.sol │ │ ├── transient_storage_reentrancy_lock.sol │ │ ├── tuples.sol │ │ ├── typed_multi_variable_declaration.sol │ │ └── write_storage_external.sol │ ├── viaYul │ │ ├── assert.sol │ │ ├── assert_and_require.sol │ │ ├── assign_tuple_from_function_call.sol │ │ ├── cleanup │ │ │ ├── checked_arithmetic.sol │ │ │ └── comparison.sol │ │ ├── comparison.sol │ │ ├── comparison_functions.sol │ │ ├── conditional │ │ │ ├── conditional_multiple.sol │ │ │ ├── conditional_true_false_literal.sol │ │ │ ├── conditional_tuple.sol │ │ │ ├── conditional_with_assignment.sol │ │ │ └── conditional_with_variables.sol │ │ ├── conversion │ │ │ ├── explicit_cast_assignment.sol │ │ │ ├── explicit_cast_function_call.sol │ │ │ ├── explicit_cast_local_assignment.sol │ │ │ ├── explicit_string_bytes_calldata_cast.sol │ │ │ ├── function_cast.sol │ │ │ ├── implicit_cast_assignment.sol │ │ │ ├── implicit_cast_function_call.sol │ │ │ └── implicit_cast_local_assignment.sol │ │ ├── copy_struct_invalid_ir_bug.sol │ │ ├── define_tuple_from_function_call.sol │ │ ├── delete.sol │ │ ├── detect_add_overflow.sol │ │ ├── detect_add_overflow_signed.sol │ │ ├── detect_div_overflow.sol │ │ ├── detect_mod_zero.sol │ │ ├── detect_mod_zero_signed.sol │ │ ├── detect_mul_overflow.sol │ │ ├── detect_mul_overflow_signed.sol │ │ ├── detect_sub_overflow.sol │ │ ├── detect_sub_overflow_signed.sol │ │ ├── dirty_calldata_struct.sol │ │ ├── dirty_memory_dynamic_array.sol │ │ ├── dirty_memory_int32.sol │ │ ├── dirty_memory_static_array.sol │ │ ├── dirty_memory_struct.sol │ │ ├── dirty_memory_uint32.sol │ │ ├── empty_return_corrupted_free_memory_pointer.sol │ │ ├── exp.sol │ │ ├── exp_literals.sol │ │ ├── exp_literals_success.sol │ │ ├── exp_neg.sol │ │ ├── exp_neg_overflow.sol │ │ ├── exp_overflow.sol │ │ ├── exp_various.sol │ │ ├── function_address.sol │ │ ├── function_entry_checks.sol │ │ ├── function_pointers.sol │ │ ├── function_selector.sol │ │ ├── if.sol │ │ ├── keccak.sol │ │ ├── local_address_assignment.sol │ │ ├── local_assignment.sol │ │ ├── local_bool_assignment.sol │ │ ├── local_tuple_assignment.sol │ │ ├── local_variable_without_init.sol │ │ ├── loops │ │ │ ├── break.sol │ │ │ ├── continue.sol │ │ │ ├── return.sol │ │ │ └── simple.sol │ │ ├── mapping_enum_key_getter.sol │ │ ├── mapping_getters.sol │ │ ├── mapping_string_key.sol │ │ ├── memory_struct_allow.sol │ │ ├── msg_sender.sol │ │ ├── negation_bug.sol │ │ ├── require.sol │ │ ├── return.sol │ │ ├── return_and_convert.sol │ │ ├── return_storage_pointers.sol │ │ ├── short_circuit.sol │ │ ├── simple_assignment.sol │ │ ├── simple_inline_asm.sol │ │ ├── smoke_test.sol │ │ ├── storage │ │ │ ├── dirty_storage_bytes.sol │ │ │ ├── dirty_storage_bytes_long.sol │ │ │ ├── dirty_storage_dynamic_array.sol │ │ │ ├── dirty_storage_static_array.sol │ │ │ ├── dirty_storage_struct.sol │ │ │ ├── mappings.sol │ │ │ ├── packed_storage.sol │ │ │ └── simple_storage.sol │ │ ├── string_format.sol │ │ ├── string_literals.sol │ │ ├── struct_member_access.sol │ │ ├── tuple_evaluation_order.sol │ │ ├── unary_fixedbytes.sol │ │ ├── unary_operations.sol │ │ ├── various_inline_asm.sol │ │ └── virtual_functions.sol │ └── virtualFunctions │ │ ├── internal_virtual_function_calls.sol │ │ ├── internal_virtual_function_calls_through_dispatch.sol │ │ ├── virtual_function_calls.sol │ │ ├── virtual_function_usage_in_constructor_arguments.sol │ │ ├── virtual_override_changing_mutability_internal.sol │ │ └── virtual_override_changing_mutability_public.sol └── simple │ ├── aave.sol │ ├── algorithm │ ├── arrays │ │ ├── multidimensional.sol │ │ ├── standard_functions.sol │ │ └── standard_functions_high_order.sol │ ├── call_conditions.sol │ ├── cryptography │ │ ├── book_cypher.sol │ │ ├── caesar_cypher.sol │ │ └── vigenere_cypher.sol │ ├── factorial.sol │ ├── fibonacci.sol │ ├── floating_point_simulation │ │ ├── geometry │ │ │ ├── area.sol │ │ │ ├── lines.sol │ │ │ └── volume.sol │ │ └── square_equation.sol │ ├── hash.sol │ ├── long_arithmetic.sol │ ├── matrix.sol │ ├── person_balances.sol │ ├── sort │ │ ├── bubble.sol │ │ ├── merge_iterative.sol │ │ ├── merge_recursive.sol │ │ └── quick.sol │ ├── split.sol │ ├── sum_oddness.sol │ └── tree │ │ ├── treap.sol │ │ └── treap_reduced.sol │ ├── array │ ├── delete_element.sol │ ├── double_dynamic.sol │ ├── mutating_assignment.sol │ ├── mutating_nested_one_element.sol │ ├── mutating_storage_in_constructor.sol │ ├── priority1.sol │ ├── priority2.sol │ ├── priority3.sol │ ├── priority4.sol │ ├── priority5.sol │ ├── size_constant_expression.sol │ ├── store_load_constant_array_witness_index.sol │ ├── store_load_nested_constant_array_witness_index.sol │ ├── store_load_nested_witness_array_constant_index.sol │ ├── store_load_nested_witness_array_witness_index.sol │ ├── store_load_witness_array_constant_index.sol │ └── store_load_witness_array_witness_index.sol │ ├── block │ ├── expression.sol │ ├── mutating.sol │ └── pyramid.sol │ ├── call_chain │ ├── address_size1.sol │ ├── address_size2.sol │ ├── address_size3.sol │ ├── address_size4.sol │ ├── address_size_var1.sol │ ├── address_size_var2.sol │ ├── address_size_var3.sol │ ├── address_size_var4.sol │ ├── address_var1.sol │ ├── address_var2.sol │ ├── address_var3.sol │ └── address_var4.sol │ ├── call_with_dirty_address.sol │ ├── conditional │ ├── mutating_complex.sol │ ├── mutating_simple.sol │ ├── nested_condition.sol │ ├── nested_gates.sol │ ├── nested_gates_mutating.sol │ └── require.sol │ ├── constant_expressions │ ├── arithmetic.sol │ ├── big_numbers.sol │ ├── bitwise.sol │ ├── bool.sol │ ├── comparison.sol │ ├── division.sol │ ├── lulz.sol │ └── modulo.sol │ ├── constants │ └── ConstantBytes.sol │ ├── constructor │ ├── context │ ├── basefee.sol │ ├── block_hash.sol │ ├── block_number.sol │ ├── block_timestamp.sol │ ├── chain_id.sol │ ├── chain_id_assembly.sol │ ├── coinbase.sol │ ├── difficulty.sol │ ├── gas_limit.sol │ ├── gas_price.sol │ └── origin.sol │ ├── create │ └── return_data_clear.sol │ ├── default.sol │ ├── destructuring │ ├── array_tupple.sol │ ├── tuple.sol │ ├── tuple_priority1.sol │ ├── tuple_priority2.sol │ └── tuple_with_gaps.sol │ ├── error │ ├── default.sol │ ├── revert1.sol │ ├── revert2.sol │ ├── revert3.sol │ ├── revert4.sol │ └── revert5.sol │ ├── events │ ├── 0_topics.sol │ ├── 0_topics_0_bytes.sol │ ├── 0_topics_32_bytes.sol │ ├── 0_topics_64_bytes.sol │ ├── 0_topics_96_bytes.sol │ ├── 1_topic.sol │ ├── 1_topic_0_bytes.sol │ ├── 1_topic_32_bytes.sol │ ├── 1_topic_64_bytes.sol │ ├── 1_topic_96_bytes.sol │ ├── 2_topics.sol │ ├── 2_topics_0_bytes.sol │ ├── 2_topics_32_bytes.sol │ ├── 2_topics_64_bytes.sol │ ├── 2_topics_96_bytes.sol │ ├── 3_topics.sol │ ├── 3_topics_0_bytes.sol │ ├── 3_topics_32_bytes.sol │ ├── 3_topics_64_bytes.sol │ ├── 3_topics_96_bytes.sol │ ├── 4_topics.sol │ ├── 4_topics_0_bytes.sol │ ├── 4_topics_32_bytes.sol │ ├── 4_topics_64_bytes.sol │ ├── 4_topics_96_bytes.sol │ ├── anonymous.sol │ ├── default.sol │ ├── evaluation_order.sol │ ├── function_inside_event1.sol │ ├── function_inside_event2.sol │ ├── function_inside_event3.sol │ ├── function_inside_event4.sol │ └── function_inside_event5.sol │ ├── expression │ ├── complex_access.sol │ ├── complex_function_result_slice.sol │ ├── complex_operator.sol │ ├── complex_operator_minimal.sol │ ├── constant_complex.sol │ ├── constant_conditional.sol │ ├── constant_match.sol │ ├── inference_operator.sol │ ├── mixed_item_constantness.sol │ ├── mixed_literal_base.sol │ └── recursive.sol │ ├── fallback │ └── simple.sol │ ├── fat_ptr │ ├── pointers_forwarding.sol │ ├── ptr_load_overwrite.sol │ └── ptr_pack_overwrite.sol │ ├── function │ ├── function_type │ │ ├── f1.sol │ │ ├── f2.sol │ │ ├── f3.sol │ │ ├── f4.sol │ │ ├── f5.sol │ │ └── f6.sol │ ├── many_arguments_1.sol │ ├── many_arguments_1_complex.sol │ ├── many_arguments_1_complex_types.sol │ ├── many_arguments_1_types.sol │ ├── many_arguments_2.sol │ ├── many_arguments_2_complex.sol │ ├── many_arguments_3.sol │ ├── many_arguments_3_complex.sol │ ├── many_arguments_4.sol │ ├── msg_value_overflow.sol │ ├── simple.sol │ └── simple_types.sol │ ├── gas_value │ ├── gas_value_order1.sol │ ├── gas_value_order2.sol │ ├── new_gas_order.sol │ ├── value_as_function1.sol │ ├── value_as_function2.sol │ └── value_as_function3.sol │ ├── immutable_eravm │ ├── aligned │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ └── simple_operator.sol │ ├── constructor.sol │ ├── inheritance │ │ ├── immutables1.sol │ │ ├── immutables2.sol │ │ ├── immutables3.sol │ │ ├── immutables4.sol │ │ ├── immutables5.sol │ │ ├── immutables6_legacy.sol │ │ └── immutables6_yul.sol │ ├── memory_manipulation.sol │ ├── trycatch.sol │ └── unaligned │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ └── simple_operator.sol │ ├── immutable_evm │ ├── aligned │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ └── simple_operator.sol │ ├── constructor.sol │ ├── inheritance │ │ ├── immutables1.sol │ │ ├── immutables2.sol │ │ ├── immutables3.sol │ │ ├── immutables4.sol │ │ ├── immutables5.sol │ │ ├── immutables6_legacy.sol │ │ └── immutables6_yul.sol │ ├── memory_manipulation.sol │ ├── trycatch.sol │ └── unaligned │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ └── simple_operator.sol │ ├── interface │ ├── enumeration_common_namespace.sol │ ├── enumeration_constructors.sol │ ├── enumeration_immutable_method.sol │ ├── enumeration_method_chain.sol │ ├── enumeration_method_next.sol │ ├── enumeration_method_opposite.sol │ ├── enumeration_mutable_method.sol │ ├── simple_call.sol │ ├── structure_common_namespace.sol │ ├── structure_constructor.sol │ ├── structure_immutable_method.sol │ ├── structure_method_chain.sol │ └── structure_mutable_method.sol │ ├── internal_function_pointers │ ├── base_access_to_function_type_variables.sol │ ├── basic.sol │ ├── call_conditions.sol │ ├── call_to_zero_initialized_function_type_legacy.sol │ ├── call_to_zero_initialized_function_type_legacy_evm.sol │ ├── calling_uninitialized_function_in_detail.sol │ ├── calling_uninitialized_function_through_array.sol │ ├── copy_internal_function_array_to_storage.sol │ ├── data_structures.sol │ ├── function_delete_stack.sol │ ├── function_delete_storage.sol │ ├── function_memory_array.sol │ ├── hash.sol │ ├── indirect.sol │ ├── inherited_1.sol │ ├── inherited_2.sol │ ├── invalidInConstructor.sol │ ├── invalidStoredInConstructor.sol │ ├── legacy │ │ ├── basic.sol │ │ ├── inherited_1.sol │ │ ├── inherited_2.sol │ │ ├── invalidInConstructor.sol │ │ ├── invalidStoredInConstructor.sol │ │ ├── store2.sol │ │ └── storeInConstructor.sol │ ├── many_arguments.sol │ ├── mixed_features_1.sol │ ├── mixed_features_2.sol │ ├── mixed_features_3.sol │ ├── person_balances.sol │ ├── sort │ │ └── bubble.sol │ ├── store2.sol │ ├── storeInConstructor.sol │ ├── sum_oddness.sol │ ├── sum_oddness_conditional.sol │ └── sum_oddness_minimized.sol │ ├── linearity │ ├── linearity1.sol │ ├── linearity2.sol │ ├── linearity3.sol │ └── linearity4.sol │ ├── loop │ ├── array │ │ ├── inclusive_lower_half.sol │ │ ├── inclusive_middle_half.sol │ │ ├── inclusive_upper_half.sol │ │ ├── nested_computation.sol │ │ ├── simple.sol │ │ ├── simple_lower_half.sol │ │ ├── simple_middle_half.sol │ │ └── simple_upper_half.sol │ ├── complex │ │ ├── 1.sol │ │ ├── 2.sol │ │ ├── 3.sol │ │ ├── 4.sol │ │ ├── 5.sol │ │ └── 6.sol │ ├── do_while │ │ └── break_continue.sol │ ├── for │ │ ├── break_continue.sol │ │ └── unreachable_break.sol │ ├── range_bitlength_inference │ │ ├── i8_to_i16.sol │ │ ├── u16_to_i16.sol │ │ ├── u8_to_i8.sol │ │ ├── u8_to_u16.sol │ │ ├── u8_to_u256_const.sol │ │ ├── u8_to_u64_const.sol │ │ └── u8_to_u64_variable.sol │ ├── range_bound │ │ ├── i16.sol │ │ ├── i256_lower.sol │ │ ├── i256_upper.sol │ │ ├── i32_lower.sol │ │ ├── i32_upper.sol │ │ ├── i64_lower.sol │ │ ├── i64_upper.sol │ │ ├── i8.sol │ │ ├── u16.sol │ │ ├── u32.sol │ │ ├── u64.sol │ │ └── u8.sol │ └── while │ │ ├── break_continue.sol │ │ └── iterator_sum.sol │ ├── match │ ├── enum.sol │ ├── nested.sol │ ├── nested_scrutinee.sol │ └── scrutinee_complex.sol │ ├── modular │ ├── addmod.sol │ ├── addmod_complex.sol │ └── mulmod.sol │ ├── operator │ ├── arithmetic │ │ ├── addition_i128.sol │ │ ├── addition_i8.sol │ │ ├── addition_u8.sol │ │ ├── division_i128.sol │ │ ├── division_i8.sol │ │ ├── division_u8.sol │ │ ├── exponentiation_i128_const.sol │ │ ├── exponentiation_i8.sol │ │ ├── exponentiation_u8.sol │ │ ├── exponentiation_u8_const.sol │ │ ├── multiplication_i128.sol │ │ ├── multiplication_i8.sol │ │ ├── multiplication_u8.sol │ │ ├── negation_i128.sol │ │ ├── negation_i8.sol │ │ ├── negation_u8.sol │ │ ├── remainder_i128.sol │ │ ├── remainder_i8.sol │ │ ├── remainder_u8.sol │ │ ├── subtraction_i128.sol │ │ ├── subtraction_i8.sol │ │ ├── subtraction_u8.sol │ │ └── unchecked │ │ │ ├── addition.sol │ │ │ ├── exponentiation.sol │ │ │ ├── multiplication.sol │ │ │ ├── subtraction.sol │ │ │ ├── unchecked_try_catch1.sol │ │ │ └── unchecked_try_catch2.sol │ ├── assignment │ │ ├── addition_i128.sol │ │ ├── addition_i8.sol │ │ ├── addition_u8.sol │ │ ├── division_i128.sol │ │ ├── division_i8.sol │ │ ├── division_u8.sol │ │ ├── multiplication_i128.sol │ │ ├── multiplication_i8.sol │ │ ├── multiplication_u8.sol │ │ ├── remainder_i128.sol │ │ ├── remainder_i8.sol │ │ ├── remainder_u8.sol │ │ ├── subtraction_i128.sol │ │ ├── subtraction_i8.sol │ │ └── subtraction_u8.sol │ ├── bitwise │ │ ├── and_u256.sol │ │ ├── and_u8.sol │ │ ├── not_u256.sol │ │ ├── not_u8.sol │ │ ├── or_u256.sol │ │ ├── or_u8.sol │ │ ├── shift_left │ │ │ ├── u256_min_to_max.sol │ │ │ ├── u256_ordinar.sol │ │ │ ├── u8_min_to_max.sol │ │ │ └── u8_ordinar.sol │ │ ├── shift_right │ │ │ ├── u256_max_to_min.sol │ │ │ ├── u256_ordinar.sol │ │ │ ├── u8_max_to_min.sol │ │ │ └── u8_ordinar.sol │ │ ├── xor_u256.sol │ │ └── xor_u8.sol │ ├── casting │ │ ├── i128_to_u8.sol │ │ ├── i16_to_i8.sol │ │ ├── i16_to_u8.sol │ │ ├── i256_to_i128.sol │ │ ├── i256_to_u8.sol │ │ ├── i8_to_u8.sol │ │ ├── simple_casting.sol │ │ ├── u16_to_i8.sol │ │ ├── u16_to_u8.sol │ │ ├── u256_to_i128.sol │ │ ├── u256_to_u8.sol │ │ ├── u8_to_i128.sol │ │ └── u8_to_i8.sol │ ├── comparison │ │ ├── address │ │ │ ├── equals.sol │ │ │ ├── greater.sol │ │ │ ├── greater_equals.sol │ │ │ ├── lesser.sol │ │ │ ├── lesser_equals.sol │ │ │ ├── not_equals.sol │ │ │ └── ternary.sol │ │ ├── equals_i128.sol │ │ ├── equals_i8.sol │ │ ├── equals_u8.sol │ │ ├── greater_equals_i128.sol │ │ ├── greater_equals_i8.sol │ │ ├── greater_equals_u8.sol │ │ ├── greater_i128.sol │ │ ├── greater_i8.sol │ │ ├── greater_u8.sol │ │ ├── lesser_equals_i128.sol │ │ ├── lesser_equals_i8.sol │ │ ├── lesser_equals_u8.sol │ │ ├── lesser_i128.sol │ │ ├── lesser_i8.sol │ │ ├── lesser_u8.sol │ │ ├── not_equals_i128.sol │ │ ├── not_equals_i8.sol │ │ └── not_equals_u8.sol │ └── logical │ │ ├── and.sol │ │ ├── not.sol │ │ ├── or.sol │ │ └── xor.sol │ ├── order │ ├── casted_declared_const.sol │ ├── casted_inline_const.sol │ ├── casted_variable.sol │ ├── declared_const.sol │ ├── inline_const.sol │ └── variable.sol │ ├── overflow │ ├── negative │ │ ├── i128.sol │ │ ├── i16.sol │ │ ├── i248.sol │ │ ├── i256.sol │ │ ├── i32.sol │ │ ├── i64.sol │ │ ├── i8.sol │ │ ├── u16.sol │ │ ├── u248.sol │ │ ├── u256.sol │ │ ├── u32.sol │ │ ├── u64.sol │ │ └── u8.sol │ ├── overflow_decrement_increment.sol │ ├── positive │ │ ├── i128.sol │ │ ├── i16.sol │ │ ├── i248.sol │ │ ├── i256.sol │ │ ├── i32.sol │ │ ├── i64.sol │ │ ├── i8.sol │ │ ├── u16.sol │ │ ├── u248.sol │ │ ├── u256.sol │ │ ├── u32.sol │ │ ├── u64.sol │ │ └── u8.sol │ └── underflow_increment_decrement.sol │ ├── pointer │ ├── adjacent_memory_cells.sol │ ├── hash_map.sol │ ├── inlined_malloc.sol │ ├── large_offset.sol │ ├── malloc.sol │ ├── store_read.sol │ ├── store_read_malloc.sol │ ├── store_read_malloc_consequent.sol │ ├── store_read_multiple.sol │ ├── store_read_offset_negative.sol │ ├── store_read_offset_positive.sol │ ├── store_read_separate_fields_aligned.sol │ ├── store_read_separate_fields_unaligned.sol │ ├── store_read_wrapped.sol │ ├── vector.sol │ └── vector_minimal.sol │ ├── recursion │ ├── euclidean.sol │ ├── factorial.sol │ ├── fibonacci.sol │ ├── inheritance.sol │ ├── inheritance_complex.sol │ ├── inheritance_library.sol │ ├── inheritance_library_complex.sol │ ├── library.sol │ ├── library_complex.sol │ ├── recursion_keccak.sol │ ├── recursive_functions_scoped.sol │ ├── struct_delete_storage_nested_small.sol │ ├── using_library.sol │ └── virtual.sol │ ├── recursion_keccak.sol │ ├── return │ ├── bytes_to_bytes32.sol │ ├── calldata_array_order.sol │ ├── complex.sol │ ├── if_arithmetic.sol │ ├── if_logical.sol │ ├── loop │ │ ├── complex.sol │ │ ├── do_while.sol │ │ ├── for.sol │ │ └── while.sol │ ├── match.sol │ └── msg_sender.sol │ ├── solidity_by_example │ ├── applications │ │ └── merkle_tree.sol │ └── simple │ │ ├── array.sol │ │ ├── array_remove_by_shifting.sol │ │ ├── array_replace_from_end.sol │ │ ├── calling_parent_contracts.sol │ │ ├── constants.sol │ │ ├── data_locations.sol │ │ ├── enum.sol │ │ ├── error.sol │ │ ├── error_account.sol │ │ ├── ether_and_wei.sol │ │ ├── events.sol │ │ ├── first_app.sol │ │ ├── for_and_while_loop.sol │ │ ├── function.sol │ │ ├── function_modifier.sol │ │ ├── function_selector.sol │ │ ├── hello_world.sol │ │ ├── if_else.sol │ │ ├── immutable.sol │ │ ├── mapping.sol │ │ ├── nested_mapping.sol │ │ ├── primitive_data_types.sol │ │ ├── reading_and_writing_to_a_state_variable.sol │ │ ├── shadowing_inherited_state_variables.sol │ │ ├── structs.sol │ │ ├── variables.sol │ │ ├── verifying_signature.sol │ │ └── view_and_pure_functions.sol │ ├── stack_overflow.sol │ ├── storage │ ├── aligned │ │ ├── array │ │ │ ├── assign.sol │ │ │ ├── assign_nested.sol │ │ │ ├── product.sol │ │ │ ├── reassign.sol │ │ │ ├── reassign_nested.sol │ │ │ └── sum.sol │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ ├── mutating_conditional.sol │ │ ├── simple_operator.sol │ │ └── structure │ │ │ ├── assign.sol │ │ │ ├── assign_nested.sol │ │ │ ├── product.sol │ │ │ ├── reassign.sol │ │ │ ├── reassign_nested.sol │ │ │ └── sum.sol │ ├── mapping │ │ ├── call_getter.sol │ │ ├── call_getter_nested.sol │ │ ├── multiple.sol │ │ ├── mutating_one_element.sol │ │ ├── mutating_one_element_nested.sol │ │ ├── nested.sol │ │ └── simple.sol │ └── unaligned │ │ ├── array │ │ ├── assign.sol │ │ ├── assign_nested.sol │ │ ├── default_init.sol │ │ ├── mutating_one_element.sol │ │ ├── product.sol │ │ ├── reassign.sol │ │ ├── reassign_nested.sol │ │ └── sum.sol │ │ ├── complex_operator.sol │ │ ├── method_chain.sol │ │ ├── mixed_data_origin.sol │ │ ├── mutating_conditional.sol │ │ ├── simple_operator.sol │ │ └── structure │ │ ├── assign.sol │ │ ├── assign_nested.sol │ │ ├── product.sol │ │ ├── reassign.sol │ │ ├── reassign_nested.sol │ │ └── sum.sol │ ├── structure │ ├── mutating.sol │ ├── mutating_assignment.sol │ ├── nested_evaluation_stack.sol │ └── nested_storage.sol │ ├── system │ ├── balance.sol │ ├── block_number_returndata.sol │ ├── block_timestamp_returndata.sol │ ├── blockhash_returndata.sol │ ├── chainid_returndata.sol │ ├── coinbase_returndata.sol │ ├── difficulty_returndata.sol │ ├── extcodehash_returndata.sol │ ├── extcodesize_returndata.sol │ ├── forwarder.sol │ ├── gaslimit_returndata.sol │ ├── gasprice_returndata.sol │ ├── identity.sol │ ├── keccak256_returndata.sol │ ├── long_returndata_keccak256.sol │ ├── msize_returndata.sol │ ├── origin_returndata.sol │ └── prevrandao_returndata.sol │ ├── ternary_overflow.sol │ ├── try_catch │ ├── error_as_bytes.sol │ ├── event_instead_function.sol │ ├── external_call_as_arg.sol │ ├── infinite_loop_1.sol │ ├── infinite_loop_2.sol │ ├── invalid_return.sol │ ├── nested.sol │ ├── nested_2.sol │ ├── not_enough_balance.sol │ ├── not_matching_interface.sol │ ├── not_payable.sol │ ├── return_long_data_in_constructor.sol │ ├── revert_long_data.sol │ ├── signature_collision1.sol │ ├── signature_collision2.sol │ ├── simple.sol │ ├── this_in_constructor.sol │ └── unbalanced_gas_limit.sol │ ├── unused │ ├── argument.sol │ ├── arguments_many.sol │ ├── cases.sol │ └── functions.sol │ ├── yul_instructions │ ├── add.sol │ ├── addmod.sol │ ├── address.sol │ ├── and.sol │ ├── basefee.sol │ ├── blockhash.sol │ ├── byte.sol │ ├── caller.sol │ ├── callvalue.sol │ ├── chainid.sol │ ├── codecopy.sol │ ├── codesize.sol │ ├── coinbase.sol │ ├── difficulty.sol │ ├── div.sol │ ├── eq.sol │ ├── exp.sol │ ├── gas.sol │ ├── gaslimit.sol │ ├── gasprice.sol │ ├── gt.sol │ ├── invalid.sol │ ├── iszero.sol │ ├── keccak256.sol │ ├── log0.sol │ ├── log1.sol │ ├── log2.sol │ ├── log3.sol │ ├── log4.sol │ ├── lt.sol │ ├── mload.sol │ ├── mod.sol │ ├── msize.sol │ ├── mstore.sol │ ├── mstore8.sol │ ├── mul.sol │ ├── mulmod.sol │ ├── not.sol │ ├── number.sol │ ├── or.sol │ ├── origin.sol │ ├── pop.sol │ ├── prevrandao.sol │ ├── return.sol │ ├── returndatacopy.sol │ ├── returndatasize.sol │ ├── revert.sol │ ├── sar.sol │ ├── sdiv.sol │ ├── selfbalance.sol │ ├── sgt.sol │ ├── shl.sol │ ├── shr.sol │ ├── signextend.sol │ ├── sload_sstore.sol │ ├── slt.sol │ ├── smod.sol │ ├── stop.sol │ ├── sub.sol │ ├── timestamp.sol │ └── xor.sol │ └── yul_semantic │ ├── expressions.sol │ ├── expressions_complex.sol │ ├── for.sol │ ├── free_memory_pointer.sol │ ├── function_definitions.sol │ ├── function_definitions_recursive.sol │ ├── if.sol │ ├── literals.sol │ ├── statements.sol │ ├── switch.sol │ └── variables.sol ├── vyper ├── complex │ ├── array_one_element-0.3 │ │ ├── callable.vy │ │ ├── main.vy │ │ └── test.json │ ├── array_one_element │ │ ├── callable.vy │ │ ├── main.vy │ │ └── test.json │ ├── call_by_signature-0.3 │ │ ├── main.vy │ │ ├── storage.vy │ │ └── test.json │ ├── call_by_signature │ │ ├── main.vy │ │ ├── storage.vy │ │ └── test.json │ ├── call_chain-0.3 │ │ ├── first.vy │ │ ├── second.vy │ │ ├── test.json │ │ └── third.vy │ ├── call_chain │ │ ├── first.vy │ │ ├── second.vy │ │ ├── test.json │ │ └── third.vy │ ├── create_from_blueprint │ │ ├── create-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_chain-0.3 │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create2_chain │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create2_many-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_many │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_recursion_fact-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_recursion_fact │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_arguments-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_arguments │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_arguments_and_code_offset-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_arguments_and_code_offset │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_code_offset-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_with_code_offset │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_chain-0.3 │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create_chain │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create_fact_value-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_fact_value │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_many-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_many │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursion_fact-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursion_fact │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursive_sum-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursive_sum │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_arguments-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_arguments │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_arguments_and_code_offset-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_arguments_and_code_offset │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_code_offset-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_with_code_offset │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── relayer-0.3 │ │ │ ├── agent.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ └── relayer │ │ │ ├── agent.vy │ │ │ ├── main.vy │ │ │ └── test.json │ ├── create_minimal_proxy_to │ │ ├── create-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_chain-0.3 │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create2_chain │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create2_many-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_many │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_recursion_fact-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create2_recursion_fact │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_chain-0.3 │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create_chain │ │ │ ├── first.vy │ │ │ ├── second.vy │ │ │ ├── test.json │ │ │ └── third.vy │ │ ├── create_fact_value-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_fact_value │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_many-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_many │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursion_fact-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursion_fact │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── create_recursive_sum-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ └── create_recursive_sum │ │ │ ├── main.vy │ │ │ └── test.json │ ├── default-0.3 │ │ ├── callable.vy │ │ ├── main.vy │ │ └── test.json │ ├── default │ │ ├── callable.vy │ │ ├── main.vy │ │ └── test.json │ ├── defi │ │ ├── Curve-0.3 │ │ │ ├── AddressProvider.vy │ │ │ ├── Curve3pool │ │ │ │ ├── CurveTokenV3.vy │ │ │ │ ├── ERC20 │ │ │ │ │ ├── ERC20.vy │ │ │ │ │ └── test.json │ │ │ │ ├── StableSwap3Pool.vy │ │ │ │ └── test.json │ │ │ ├── CurveCalc.vy │ │ │ ├── PoolInfo.vy │ │ │ ├── Registry.vy │ │ │ ├── Swaps.vy │ │ │ └── test.json │ │ ├── Curve-0.4.0 │ │ │ ├── AddressProvider.vy │ │ │ ├── Curve3pool │ │ │ │ ├── CurveTokenV3.vy │ │ │ │ ├── ERC20 │ │ │ │ │ ├── ERC20.vy │ │ │ │ │ └── test.json │ │ │ │ ├── StableSwap3Pool.vy │ │ │ │ └── test.json │ │ │ ├── CurveCalc.vy │ │ │ ├── PoolInfo.vy │ │ │ ├── Registry.vy │ │ │ ├── Swaps.vy │ │ │ └── test.json │ │ └── Curve │ │ │ ├── AddressProvider.vy │ │ │ ├── Curve3pool │ │ │ ├── CurveTokenV3.vy │ │ │ ├── ERC20 │ │ │ │ ├── ERC20.vy │ │ │ │ └── test.json │ │ │ ├── StableSwap3Pool.vy │ │ │ └── test.json │ │ │ ├── CurveCalc.vy │ │ │ ├── PoolInfo.vy │ │ │ ├── Registry.vy │ │ │ ├── Swaps.vy │ │ │ └── test.json │ ├── ethereum │ │ ├── arithmetics │ │ │ ├── check_var_init-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ └── check_var_init │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ ├── array │ │ │ ├── copying │ │ │ │ ├── copying_bytes_multiassign-0.3 │ │ │ │ │ ├── receiver.vy │ │ │ │ │ ├── sender.vy │ │ │ │ │ └── test.json │ │ │ │ └── copying_bytes_multiassign │ │ │ │ │ ├── receiver.vy │ │ │ │ │ ├── sender.vy │ │ │ │ │ └── test.json │ │ │ ├── fixed_arrays_as_return_type-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ │ ├── fixed_arrays_as_return_type │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ │ ├── reusing_memory-0.3 │ │ │ │ ├── Helper.vy │ │ │ │ ├── Main.vy │ │ │ │ └── test.json │ │ │ └── reusing_memory │ │ │ │ ├── Helper.vy │ │ │ │ ├── Main.vy │ │ │ │ └── test.json │ │ ├── constructor │ │ ├── events │ │ │ ├── event_emit_from_other_contract-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── event_emit_from_other_contract-0.4.0 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ └── event_emit_from_other_contract │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ ├── fallback │ │ │ ├── call_forward_bytes-0.3 │ │ │ │ ├── receiver.vy │ │ │ │ ├── sender.vy │ │ │ │ └── test.json │ │ │ └── call_forward_bytes │ │ │ │ ├── receiver.vy │ │ │ │ ├── sender.vy │ │ │ │ └── test.json │ │ ├── functionCall │ │ │ ├── creation_function_call_no_args-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── creation_function_call_no_args │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── creation_function_call_with_args-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── creation_function_call_with_args │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── creation_function_call_with_salt-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── creation_function_call_with_salt │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ ├── external_call_at_construction_time-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── T.vy │ │ │ │ ├── U.vy │ │ │ │ └── test.json │ │ │ ├── external_call_at_construction_time │ │ │ │ ├── C.vy │ │ │ │ ├── T.vy │ │ │ │ ├── U.vy │ │ │ │ └── test.json │ │ │ ├── failed_create-0.3 │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ │ └── failed_create │ │ │ │ ├── C.vy │ │ │ │ ├── D.vy │ │ │ │ └── test.json │ │ ├── immutable │ │ │ ├── multi_creation-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ │ └── multi_creation │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ ├── isoltestTesting │ │ │ ├── balance_other_contract-0.3 │ │ │ │ ├── ClientReceipt.vy │ │ │ │ ├── Other.vy │ │ │ │ └── test.json │ │ │ └── balance_other_contract │ │ │ │ ├── ClientReceipt.vy │ │ │ │ ├── Other.vy │ │ │ │ └── test.json │ │ ├── revertStrings │ │ │ ├── bubble-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ │ ├── bubble │ │ │ │ ├── A.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ │ ├── transfer-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ │ └── transfer │ │ │ │ ├── A.vy │ │ │ │ ├── C.vy │ │ │ │ └── test.json │ │ ├── salted_create │ │ │ ├── salted_create-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ │ ├── salted_create │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ │ ├── salted_create_with_value-0.3 │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ │ └── salted_create_with_value │ │ │ │ ├── A.vy │ │ │ │ ├── B.vy │ │ │ │ └── test.json │ │ └── various │ │ │ ├── contract_binary_dependencies-0.3 │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ │ ├── contract_binary_dependencies │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ │ ├── senders_balance-0.3 │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ │ │ ├── senders_balance │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ │ │ ├── staticcall_for_view_and_pure-0.3 │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ │ │ ├── staticcall_for_view_and_pure │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ │ │ ├── write_storage_external-0.3 │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ │ │ └── write_storage_external │ │ │ ├── C.vy │ │ │ ├── D.vy │ │ │ └── test.json │ ├── indirect_recursion_fact-0.3 │ │ ├── first.vy │ │ ├── second.vy │ │ └── test.json │ ├── indirect_recursion_fact │ │ ├── first.vy │ │ ├── second.vy │ │ └── test.json │ ├── interface_casting-0.3 │ │ ├── c.vy │ │ ├── d.vy │ │ └── test.json │ ├── interface_casting │ │ ├── c.vy │ │ ├── d.vy │ │ └── test.json │ ├── invalid_signature │ │ ├── require-0.3 │ │ │ ├── simpleRequire.vy │ │ │ ├── test.json │ │ │ └── wrapper.vy │ │ ├── require │ │ │ ├── simpleRequire.vy │ │ │ ├── test.json │ │ │ └── wrapper.vy │ │ ├── simple-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ └── simple │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ ├── many_arguments │ │ ├── complex-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── complex │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── simple-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ └── simple │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ ├── nested_calls │ │ ├── delegatecall_call-0.3 │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── delegatecall_call │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── delegatecall_delegatecall-0.3 │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── delegatecall_delegatecall │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── staticcall_call-0.3 │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── staticcall_call │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ ├── staticcall_staticcall-0.3 │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ │ └── staticcall_staticcall │ │ │ ├── A.vy │ │ │ ├── B.vy │ │ │ ├── C.vy │ │ │ └── test.json │ ├── solidity_by_example │ │ ├── applications │ │ │ ├── iterable_mapping-0.3 │ │ │ │ ├── main.vy │ │ │ │ └── test.json │ │ │ └── iterable_mapping │ │ │ │ ├── main.vy │ │ │ │ └── test.json │ │ ├── hacks │ │ │ ├── delegate_call-0.3 │ │ │ │ ├── attack.vy │ │ │ │ ├── hack_me.vy │ │ │ │ ├── lib.vy │ │ │ │ └── test.json │ │ │ ├── delegate_call │ │ │ │ ├── attack.vy │ │ │ │ ├── hack_me.vy │ │ │ │ ├── lib.vy │ │ │ │ └── test.json │ │ │ ├── delegate_call_second-0.3 │ │ │ │ ├── attack.vy │ │ │ │ ├── hack_me.vy │ │ │ │ ├── lib.vy │ │ │ │ └── test.json │ │ │ ├── delegate_call_second │ │ │ │ ├── attack.vy │ │ │ │ ├── hack_me.vy │ │ │ │ ├── lib.vy │ │ │ │ └── test.json │ │ │ ├── hiding_malicious_code_with_external_contract-0.3 │ │ │ │ ├── bar.vy │ │ │ │ ├── foo.vy │ │ │ │ ├── mal.vy │ │ │ │ └── test.json │ │ │ ├── hiding_malicious_code_with_external_contract-0.4.0 │ │ │ │ ├── bar.vy │ │ │ │ ├── foo.vy │ │ │ │ ├── mal.vy │ │ │ │ └── test.json │ │ │ └── hiding_malicious_code_with_external_contract │ │ │ │ ├── bar.vy │ │ │ │ ├── foo.vy │ │ │ │ ├── mal.vy │ │ │ │ └── test.json │ │ └── simple │ │ │ ├── hashing_with_keccak256-0.3 │ │ │ ├── guess_the_magic_word.vy │ │ │ ├── hash_function.vy │ │ │ └── test.json │ │ │ ├── hashing_with_keccak256 │ │ │ ├── guess_the_magic_word.vy │ │ │ ├── hash_function.vy │ │ │ └── test.json │ │ │ ├── import-0.3 │ │ │ ├── Foo.vy │ │ │ ├── Import.vy │ │ │ └── test.json │ │ │ ├── import │ │ │ ├── Foo.vy │ │ │ ├── IFoo.vyi │ │ │ ├── Import.vy │ │ │ └── test.json │ │ │ ├── interface-0.3 │ │ │ ├── counter.vy │ │ │ ├── main.vy │ │ │ ├── my_contract.vy │ │ │ └── test.json │ │ │ ├── interface │ │ │ ├── counter.vy │ │ │ ├── main.vy │ │ │ ├── my_contract.vy │ │ │ └── test.json │ │ │ ├── visibility-0.3 │ │ │ ├── main.vy │ │ │ └── test.json │ │ │ └── visibility │ │ │ ├── main.vy │ │ │ └── test.json │ ├── storage-0.3 │ │ ├── main.vy │ │ ├── storage.vy │ │ └── test.json │ ├── storage │ │ ├── main.vy │ │ ├── storage.vy │ │ └── test.json │ ├── sum_of_squares-0.3 │ │ ├── main.vy │ │ ├── square.vy │ │ └── test.json │ ├── sum_of_squares │ │ ├── main.vy │ │ ├── square.vy │ │ └── test.json │ ├── value │ │ ├── delegatecall-0.3 │ │ │ ├── Main.vy │ │ │ ├── TestContract.vy │ │ │ └── test.json │ │ ├── delegatecall │ │ │ ├── Main.vy │ │ │ ├── TestContract.vy │ │ │ └── test.json │ │ ├── delegatecall_call-0.3 │ │ │ ├── First.vy │ │ │ ├── Second.vy │ │ │ ├── Third.vy │ │ │ └── test.json │ │ ├── delegatecall_call │ │ │ ├── First.vy │ │ │ ├── Second.vy │ │ │ ├── Third.vy │ │ │ └── test.json │ │ ├── delegatecall_delegatecall-0.3 │ │ │ ├── First.vy │ │ │ ├── Second.vy │ │ │ ├── Third.vy │ │ │ └── test.json │ │ ├── delegatecall_delegatecall │ │ │ ├── First.vy │ │ │ ├── Second.vy │ │ │ ├── Third.vy │ │ │ └── test.json │ │ ├── in_created_contract-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── in_created_contract │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ ├── many_created_contracts-0.3 │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ │ └── many_created_contracts │ │ │ ├── callable.vy │ │ │ ├── main.vy │ │ │ └── test.json │ ├── voting-0.3 │ │ ├── ballot.vy │ │ └── test.json │ └── voting │ │ ├── ballot.vy │ │ └── test.json ├── ethereum │ ├── abiEncoderV1 │ │ ├── abi_decode_fixed_arrays.vy │ │ ├── abi_encode.vy │ │ ├── abi_encode_call.vy │ │ ├── abi_encode_calldata_slice-0.3.vy │ │ ├── abi_encode_calldata_slice.vy │ │ ├── abi_encode_empty_string.vy │ │ ├── abi_encode_rational.vy │ │ ├── byte_arrays.vy │ │ ├── calldata_arrays_too_large.vy │ │ ├── dynamic_arrays.vy │ │ ├── memory_params_in_external_function-0.3.vy │ │ ├── memory_params_in_external_function.vy │ │ ├── return_dynamic_types_cross_call_advanced-0.3.vy │ │ ├── return_dynamic_types_cross_call_advanced.vy │ │ ├── return_dynamic_types_cross_call_simple-0.3.vy │ │ ├── return_dynamic_types_cross_call_simple.vy │ │ └── struct │ │ │ └── struct_storage_ptr.vy │ ├── abiEncoderV2 │ │ ├── abi_encode_calldata_slice-0.3.vy │ │ ├── abi_encode_calldata_slice.vy │ │ ├── abi_encode_empty_string_v2.vy │ │ ├── abi_encode_rational_v2.vy │ │ ├── abi_encode_v2.vy │ │ ├── bool_out_of_bounds.vy │ │ ├── byte_arrays.vy │ │ ├── calldata_array-0.3.vy │ │ ├── calldata_array.vy │ │ ├── calldata_array_dynamic-0.3.vy │ │ ├── calldata_array_dynamic.vy │ │ ├── calldata_array_dynamic_index_access.vy │ │ ├── calldata_array_dynamic_static_dynamic-0.3.vy │ │ ├── calldata_array_dynamic_static_dynamic.vy │ │ ├── calldata_array_dynamic_static_short_reencode-0.3.vy │ │ ├── calldata_array_dynamic_static_short_reencode.vy │ │ ├── calldata_array_multi_dynamic-0.3.vy │ │ ├── calldata_array_multi_dynamic.vy │ │ ├── calldata_array_short_no_revert_string.vy │ │ ├── calldata_array_static-0.3.vy │ │ ├── calldata_array_static.vy │ │ ├── calldata_array_static_dynamic_static-0.3.vy │ │ ├── calldata_array_static_dynamic_static.vy │ │ ├── calldata_array_static_index_access-0.3.vy │ │ ├── calldata_array_static_index_access.vy │ │ ├── calldata_array_struct_dynamic-0.3.vy │ │ ├── calldata_array_struct_dynamic.vy │ │ ├── calldata_array_two_dynamic-0.3.vy │ │ ├── calldata_array_two_dynamic.vy │ │ ├── calldata_array_two_static-0.3.vy │ │ ├── calldata_array_two_static.vy │ │ ├── calldata_nested_array_reencode.vy │ │ ├── calldata_nested_array_static_reencode-0.3.vy │ │ ├── calldata_nested_array_static_reencode.vy │ │ ├── calldata_struct_dynamic-0.3.vy │ │ ├── calldata_struct_dynamic.vy │ │ ├── calldata_struct_member_offset-0.3.vy │ │ ├── calldata_struct_member_offset.vy │ │ ├── calldata_struct_simple-0.3.vy │ │ ├── calldata_struct_simple.vy │ │ ├── cleanup │ │ │ ├── address.vy │ │ │ ├── bool-0.3.vy │ │ │ ├── bool.vy │ │ │ ├── bytesx.vy │ │ │ ├── cleanup.vy │ │ │ ├── dynamic_array.vy │ │ │ ├── intx.vy │ │ │ ├── simple_struct.vy │ │ │ ├── static_array.vy │ │ │ └── uintx.vy │ │ ├── dynamic_arrays.vy │ │ ├── dynamic_nested_arrays-0.3.vy │ │ ├── dynamic_nested_arrays.vy │ │ ├── memory_params_in_external_function-0.3.vy │ │ ├── memory_params_in_external_function.vy │ │ ├── storage_array_encoding.vy │ │ └── struct │ │ │ ├── mediocre2_struct.vy │ │ │ ├── mediocre_struct.vy │ │ │ ├── struct_short.vy │ │ │ ├── struct_simple.vy │ │ │ └── struct_validation.vy │ ├── abiencodedecode │ │ ├── abi_encode_call_is_consistent-0.3.vy │ │ ├── abi_encode_call_is_consistent.vy │ │ ├── abi_encode_call_special_args-0.3.vy │ │ ├── abi_encode_call_special_args.vy │ │ ├── abi_encode_call_uint_bytes-0.3.vy │ │ ├── abi_encode_call_uint_bytes.vy │ │ ├── abi_encode_empty_string_v1.vy │ │ ├── abi_encode_with_selector.vy │ │ ├── abi_encode_with_selectorv2.vy │ │ ├── abi_encode_with_signature.vy │ │ └── abi_encode_with_signaturev2.vy │ ├── accessor │ │ ├── accessor_for_state_variable-0.3.vy │ │ └── accessor_for_state_variable.vy │ ├── arithmetics │ │ ├── addmod_mulmod.vy │ │ ├── addmod_mulmod_zero.vy │ │ ├── checked_add_v2.vy │ │ ├── division_by_zero-0.3.vy │ │ ├── division_by_zero.vy │ │ ├── signed_mod-0.3.vy │ │ └── signed_mod.vy │ ├── array │ │ ├── arrays_complex_from_and_to_storage.vy │ │ ├── byte_array_transitional_2-0.3.vy │ │ ├── byte_array_transitional_2.vy │ │ ├── bytes_length_member.vy │ │ ├── bytes_to_fixed_bytes_cleanup-0.3.vy │ │ ├── bytes_to_fixed_bytes_cleanup.vy │ │ ├── bytes_to_fixed_bytes_simple-0.3.vy │ │ ├── bytes_to_fixed_bytes_simple.vy │ │ ├── bytes_to_fixed_bytes_too_long-0.3.vy │ │ ├── bytes_to_fixed_bytes_too_long.vy │ │ ├── calldata_array.vy │ │ ├── calldata_array_as_argument_internal_function.vy │ │ ├── calldata_array_dynamic_invalid.vy │ │ ├── calldata_array_dynamic_invalid_static_middle.vy │ │ ├── calldata_array_of_struct.vy │ │ ├── calldata_array_two_dimensional-0.3.vy │ │ ├── calldata_array_two_dimensional.vy │ │ ├── calldata_array_two_dimensional_1-0.3.vy │ │ ├── calldata_array_two_dimensional_1.vy │ │ ├── calldata_bytes_array_bounds.vy │ │ ├── concat │ │ │ ├── bytes_concat_2_args.vy │ │ │ ├── bytes_concat_3_args.vy │ │ │ ├── bytes_concat_as_argument.vy │ │ │ ├── bytes_concat_different_types-0.3.vy │ │ │ ├── bytes_concat_different_types.vy │ │ │ ├── bytes_concat_empty_strings.vy │ │ │ └── bytes_concat_nested.vy │ │ ├── constant_var_as_array_length-0.3.vy │ │ ├── constant_var_as_array_length.vy │ │ ├── copying │ │ │ ├── array_copy_calldata_storage.vy │ │ │ ├── array_copy_cleanup_uint128.vy │ │ │ ├── array_copy_cleanup_uint40.vy │ │ │ ├── array_copy_clear_storage.vy │ │ │ ├── array_copy_clear_storage_packed.vy │ │ │ ├── array_copy_including_array-0.3.vy │ │ │ ├── array_copy_including_array.vy │ │ │ ├── array_copy_memory_to_storage.vy │ │ │ ├── array_copy_nested_array.vy │ │ │ ├── array_copy_storage_abi_signed.vy │ │ │ ├── array_copy_storage_storage_dyn_dyn-0.3.vy │ │ │ ├── array_copy_storage_storage_dyn_dyn.vy │ │ │ ├── array_copy_storage_storage_dynamic_dynamic.vy │ │ │ ├── array_copy_storage_storage_static_simple-0.3.vy │ │ │ ├── array_copy_storage_storage_static_simple.vy │ │ │ ├── array_copy_storage_storage_static_static.vy │ │ │ ├── array_copy_storage_storage_struct-0.3.vy │ │ │ ├── array_copy_storage_storage_struct.vy │ │ │ ├── array_copy_storage_to_memory.vy │ │ │ ├── array_copy_storage_to_memory_nested.vy │ │ │ ├── array_nested_calldata_to_memory.vy │ │ │ ├── array_nested_calldata_to_storage.vy │ │ │ ├── array_nested_memory_to_storage.vy │ │ │ ├── array_of_struct_calldata_to_memory.vy │ │ │ ├── array_of_struct_calldata_to_storage.vy │ │ │ ├── array_of_struct_memory_to_storage.vy │ │ │ ├── array_of_structs_containing_arrays_calldata_to_memory-0.3.vy │ │ │ ├── array_of_structs_containing_arrays_calldata_to_memory.vy │ │ │ ├── array_of_structs_containing_arrays_calldata_to_storage-0.3.vy │ │ │ ├── array_of_structs_containing_arrays_calldata_to_storage.vy │ │ │ ├── array_of_structs_containing_arrays_memory_to_storage-0.3.vy │ │ │ ├── array_of_structs_containing_arrays_memory_to_storage.vy │ │ │ ├── array_storage_multi_items_per_slot.vy │ │ │ ├── arrays_from_and_to_storage.vy │ │ │ ├── bytes_calldata_to_string_calldata.vy │ │ │ ├── bytes_inside_mappings.vy │ │ │ ├── bytes_memory_to_storage.vy │ │ │ ├── bytes_storage_to_memory-0.3.vy │ │ │ ├── bytes_storage_to_memory.vy │ │ │ ├── bytes_storage_to_storage-0.3.vy │ │ │ ├── bytes_storage_to_storage.vy │ │ │ ├── calldata_2d_bytes_to_memory.vy │ │ │ ├── calldata_2d_bytes_to_memory_2.vy │ │ │ ├── calldata_array_dynamic_to_storage.vy │ │ │ ├── calldata_array_of_struct_to_memory.vy │ │ │ ├── calldata_array_static_to_memory.vy │ │ │ ├── calldata_bytes_array_to_memory.vy │ │ │ ├── calldata_bytes_to_storage.vy │ │ │ ├── calldata_dyn_2d_bytes_to_memory.vy │ │ │ ├── calldata_dynamic_array_to_memory.vy │ │ │ ├── calldata_nested_array_copy_to_memory-0.3.vy │ │ │ ├── calldata_nested_array_copy_to_memory.vy │ │ │ ├── cleanup_during_multi_element_per_slot_copy-0.3.vy │ │ │ ├── cleanup_during_multi_element_per_slot_copy.vy │ │ │ ├── copy_byte_array_in_struct_to_storage.vy │ │ │ ├── copy_removes_bytes_data.vy │ │ │ ├── empty_bytes_copy-0.3.vy │ │ │ ├── empty_bytes_copy.vy │ │ │ ├── memory_dyn_2d_bytes_to_storage-0.3.vy │ │ │ ├── memory_dyn_2d_bytes_to_storage.vy │ │ │ ├── storage_memory_nested.vy │ │ │ ├── storage_memory_nested_bytes-0.3.vy │ │ │ ├── storage_memory_nested_bytes.vy │ │ │ ├── storage_memory_nested_from_pointer.vy │ │ │ ├── storage_memory_nested_struct.vy │ │ │ ├── storage_memory_packed.vy │ │ │ ├── storage_memory_packed_dyn-0.3.vy │ │ │ ├── storage_memory_packed_dyn.vy │ │ │ └── string_calldata_to_bytes_calldata.vy │ │ ├── create_dynamic_array_with_zero_length.vy │ │ ├── create_memory_array.vy │ │ ├── create_memory_array_too_large.vy │ │ ├── create_memory_byte_array.vy │ │ ├── create_multiple_dynamic_arrays-0.3.vy │ │ ├── create_multiple_dynamic_arrays.vy │ │ ├── delete │ │ │ ├── delete_bytes_array.vy │ │ │ ├── delete_memory_array.vy │ │ │ ├── delete_on_array_of_structs.vy │ │ │ ├── delete_removes_bytes_data.vy │ │ │ ├── delete_storage_array.vy │ │ │ ├── delete_storage_array_packed.vy │ │ │ ├── memory_arrays_delete-0.3.vy │ │ │ └── memory_arrays_delete.vy │ │ ├── dynamic_array_cleanup-0.3.vy │ │ ├── dynamic_array_cleanup.vy │ │ ├── dynamic_arrays_in_storage-0.3.vy │ │ ├── dynamic_arrays_in_storage.vy │ │ ├── dynamic_multi_array_cleanup-0.3.vy │ │ ├── dynamic_multi_array_cleanup.vy │ │ ├── dynamic_out_of_bounds_array_access-0.3.vy │ │ ├── dynamic_out_of_bounds_array_access.vy │ │ ├── evm_exceptions_out_of_band_access-0.3.vy │ │ ├── evm_exceptions_out_of_band_access.vy │ │ ├── external_array_args.vy │ │ ├── fixed_array_cleanup-0.3.vy │ │ ├── fixed_array_cleanup.vy │ │ ├── fixed_arrays_in_constructors-0.3.vy │ │ ├── fixed_arrays_in_constructors.vy │ │ ├── fixed_arrays_in_storage.vy │ │ ├── fixed_out_of_bounds_array_access.vy │ │ ├── indexAccess │ │ │ ├── arrays_complex_memory_index_access.vy │ │ │ ├── inline_array_index_access_ints.vy │ │ │ ├── inline_array_index_access_strings.vy │ │ │ ├── memory_arrays_dynamic_index_access_write-0.3.vy │ │ │ ├── memory_arrays_dynamic_index_access_write.vy │ │ │ └── memory_arrays_index_access_write.vy │ │ ├── inline_array_return.vy │ │ ├── inline_array_singleton.vy │ │ ├── inline_array_storage_to_memory_conversion_ints.vy │ │ ├── inline_array_storage_to_memory_conversion_strings-0.3.vy │ │ ├── inline_array_storage_to_memory_conversion_strings.vy │ │ ├── inline_array_strings_from_document-0.3.vy │ │ ├── inline_array_strings_from_document.vy │ │ ├── memory-0.3.vy │ │ ├── memory.vy │ │ ├── memory_arrays_of_various_sizes-0.3.vy │ │ ├── memory_arrays_of_various_sizes.vy │ │ ├── pop │ │ │ ├── array_pop.vy │ │ │ ├── array_pop_array_transition-0.3.vy │ │ │ ├── array_pop_array_transition.vy │ │ │ ├── array_pop_empty_exception.vy │ │ │ ├── array_pop_isolated.vy │ │ │ ├── array_pop_storage_empty.vy │ │ │ ├── array_pop_uint16_transition-0.3.vy │ │ │ ├── array_pop_uint16_transition.vy │ │ │ ├── array_pop_uint24_transition-0.3.vy │ │ │ ├── array_pop_uint24_transition.vy │ │ │ └── parenthesized.vy │ │ ├── push │ │ │ ├── array_push.vy │ │ │ ├── array_push_nested-0.3.vy │ │ │ ├── array_push_nested.vy │ │ │ ├── array_push_nested_from_calldata-0.3.vy │ │ │ ├── array_push_nested_from_calldata.vy │ │ │ ├── array_push_nested_from_memory-0.3.vy │ │ │ ├── array_push_nested_from_memory.vy │ │ │ ├── array_push_packed_array.vy │ │ │ ├── array_push_struct.vy │ │ │ └── array_push_struct_from_calldata.vy │ │ ├── short_fixed_array_cleanup-0.3.vy │ │ ├── short_fixed_array_cleanup.vy │ │ ├── slices │ │ │ ├── array_slice_calldata_as_argument_of_external_calls-0.3.vy │ │ │ └── array_slice_calldata_as_argument_of_external_calls.vy │ │ ├── storage_array_ref-0.3.vy │ │ ├── storage_array_ref.vy │ │ ├── string_allocation_bug-0.3.vy │ │ ├── string_allocation_bug.vy │ │ ├── string_bytes_conversion.vy │ │ ├── string_literal_assign_to_storage_bytes-0.3.vy │ │ ├── string_literal_assign_to_storage_bytes.vy │ │ ├── strings_in_struct-0.3.vy │ │ └── strings_in_struct.vy │ ├── builtinFunctions │ │ ├── assignment_to_const_var_involving_keccak.vy │ │ ├── blockhash.vy │ │ ├── blockhash_shadow_resolution.vy │ │ ├── iterated_keccak256_with_bytes.vy │ │ ├── keccak256_empty.vy │ │ ├── keccak256_multiple_arguments.vy │ │ ├── keccak256_multiple_arguments_with_numeric_literals.vy │ │ ├── keccak256_multiple_arguments_with_string_literals.vy │ │ ├── keccak256_with_bytes.vy │ │ └── sha256_empty.vy │ ├── byte_array_to_storage_cleanup-0.4.vy │ ├── byte_array_to_storage_cleanup.vy │ ├── calldata │ │ ├── calldata_array_dynamic_bytes.vy │ │ ├── calldata_bound_bytes.vy │ │ ├── calldata_bound_dynamic_array_or_slice.vy │ │ ├── calldata_bound_static_array.vy │ │ ├── calldata_bound_struct.vy │ │ ├── calldata_bytes_external-0.3.vy │ │ ├── calldata_bytes_external.vy │ │ ├── calldata_bytes_internal.vy │ │ ├── calldata_bytes_to_memory.vy │ │ ├── calldata_bytes_to_memory_encode.vy │ │ ├── calldata_internal_multi_array-0.3.vy │ │ ├── calldata_internal_multi_array.vy │ │ ├── calldata_internal_multi_fixed_array-0.3.vy │ │ ├── calldata_internal_multi_fixed_array.vy │ │ ├── calldata_memory_mixed-0.3.vy │ │ ├── calldata_memory_mixed.vy │ │ ├── calldata_string_array.vy │ │ ├── calldata_struct.vy │ │ ├── calldata_struct_cleaning.vy │ │ ├── calldata_struct_internal.vy │ │ └── copy_from_calldata_removes_bytes_data.vy │ ├── cleanup │ │ ├── bool_conversion_v2.vy │ │ ├── cleanup_address_types_v2.vy │ │ └── cleanup_bytes_types_v2.vy │ ├── constantEvaluator │ │ ├── negative_fractional_mod.vy │ │ ├── rounding-0.3.vy │ │ └── rounding.vy │ ├── constants │ │ ├── constant_string.vy │ │ ├── constant_string_at_file_level.vy │ │ ├── constant_variables.vy │ │ ├── consteval_array_length-0.3.vy │ │ ├── consteval_array_length.vy │ │ └── simple_constant_variables_test.vy │ ├── constructor │ ├── constructor_with_params-0.3.vy │ ├── constructor_with_params.vy │ ├── conversions │ │ └── string_to_bytes.vy │ ├── dirty_calldata_bytes-0.3.vy │ ├── dirty_calldata_bytes.vy │ ├── dirty_calldata_dynamic_array.vy │ ├── ecrecover │ │ ├── ecrecover.vy │ │ ├── failing_ecrecover_invalid_input.vy │ │ ├── failing_ecrecover_invalid_input_asm.vy │ │ └── failing_ecrecover_invalid_input_proper.vy │ ├── empty_contract.vy │ ├── events │ │ ├── event-0.4.vy │ │ ├── event.vy │ │ ├── event_constructor-0.3.vy │ │ ├── event_constructor-0.4.0.vy │ │ ├── event_constructor.vy │ │ ├── event_dynamic_array_memory-0.4.vy │ │ ├── event_dynamic_array_memory.vy │ │ ├── event_dynamic_array_storage-0.3.vy │ │ ├── event_dynamic_array_storage-0.4.0.vy │ │ ├── event_dynamic_array_storage.vy │ │ ├── event_dynamic_nested_array_memory_v2-0.4.vy │ │ ├── event_dynamic_nested_array_memory_v2.vy │ │ ├── event_dynamic_nested_array_storage_v2-0.4.vy │ │ ├── event_dynamic_nested_array_storage_v2.vy │ │ ├── event_emit-0.4.vy │ │ ├── event_emit.vy │ │ ├── event_indexed_mixed-0.4.vy │ │ ├── event_indexed_mixed.vy │ │ ├── event_indexed_string.vy │ │ ├── event_lots_of_data-0.4.vy │ │ ├── event_lots_of_data.vy │ │ ├── event_no_arguments.vy │ │ ├── event_really_lots_of_data-0.4.vy │ │ ├── event_really_lots_of_data.vy │ │ ├── event_really_lots_of_data_from_storage-0.4.vy │ │ ├── event_really_lots_of_data_from_storage.vy │ │ ├── event_really_really_lots_of_data_from_storage-0.4.vy │ │ ├── event_really_really_lots_of_data_from_storage.vy │ │ ├── event_string-0.4.vy │ │ ├── event_string.vy │ │ ├── event_struct_memory_v2-0.3.vy │ │ ├── event_struct_memory_v2-0.4.0.vy │ │ ├── event_struct_memory_v2.vy │ │ ├── event_struct_storage_v2-0.4.vy │ │ └── event_struct_storage_v2.vy │ ├── expressions │ │ ├── bit_operators.vy │ │ ├── exp_operator_const.vy │ │ ├── exp_operator_const_signed.vy │ │ ├── exp_zero_literal.vy │ │ └── unary_too_long_literal.vy │ ├── fallback │ │ ├── falback_return.vy │ │ ├── fallback_return_data.vy │ │ └── short_data_calls_fallback.vy │ ├── functionCall │ │ ├── array_multiple_local_vars-0.3.vy │ │ ├── array_multiple_local_vars.vy │ │ ├── call_internal_function_via_expression.vy │ │ ├── calling_nonexisting_contract_throws-0.3.vy │ │ ├── calling_nonexisting_contract_throws.vy │ │ ├── calling_other_functions-0.3.vy │ │ ├── calling_other_functions.vy │ │ ├── delegatecall_return_value.vy │ │ ├── delegatecall_return_value_pre_byzantium.vy │ │ ├── external_call-0.3.vy │ │ ├── external_call.vy │ │ ├── external_call_dynamic_returndata-0.3.vy │ │ ├── external_call_dynamic_returndata.vy │ │ ├── external_call_to_nonexisting-0.3.vy │ │ ├── external_call_to_nonexisting.vy │ │ ├── external_call_value-0.3.vy │ │ ├── external_call_value.vy │ │ ├── external_function.vy │ │ ├── member_accessors-0.3.vy │ │ ├── member_accessors.vy │ │ ├── multiple_functions.vy │ │ ├── multiple_return_values.vy │ │ ├── transaction_status.vy │ │ └── value_test.vy │ ├── getters │ │ ├── array_mapping_struct-0.3.vy │ │ ├── array_mapping_struct.vy │ │ ├── arrays-0.3.vy │ │ ├── arrays.vy │ │ ├── bytes-0.3.vy │ │ ├── bytes.vy │ │ ├── mapping-0.3.vy │ │ ├── mapping.vy │ │ ├── mapping_array_struct-0.3.vy │ │ ├── mapping_array_struct.vy │ │ ├── mapping_of_string-0.3.vy │ │ ├── mapping_of_string.vy │ │ ├── mapping_to_struct-0.3.vy │ │ ├── mapping_to_struct.vy │ │ ├── string_and_bytes-0.3.vy │ │ ├── string_and_bytes.vy │ │ ├── struct_with_bytes-0.3.vy │ │ ├── struct_with_bytes.vy │ │ ├── struct_with_bytes_simple-0.3.vy │ │ ├── struct_with_bytes_simple.vy │ │ ├── value_types-0.3.vy │ │ └── value_types.vy │ ├── immutable │ │ ├── assign_at_declaration-0.3.vy │ │ ├── assign_at_declaration.vy │ │ ├── assign_from_immutables-0.3.vy │ │ ├── assign_from_immutables.vy │ │ ├── fun_read_in_ctor-0.3.vy │ │ ├── fun_read_in_ctor.vy │ │ ├── immutable_signed-0.3.vy │ │ ├── immutable_signed.vy │ │ ├── read_in_ctor-0.3.vy │ │ ├── read_in_ctor.vy │ │ ├── small_types_in_reverse-0.3.vy │ │ ├── small_types_in_reverse.vy │ │ ├── stub-0.3.vy │ │ ├── stub.vy │ │ ├── use_scratch-0.3.vy │ │ └── use_scratch.vy │ ├── index.yaml │ ├── integer │ │ ├── basic-0.3.vy │ │ ├── basic.vy │ │ ├── int-0.3.vy │ │ ├── int.vy │ │ ├── many_local_variables.vy │ │ ├── small_signed_types.vy │ │ ├── uint-0.3.vy │ │ └── uint.vy │ ├── interfaceID │ │ ├── homer.vy │ │ ├── lisa-0.3.vy │ │ └── lisa.vy │ ├── isoltestFormatting.vy │ ├── isoltestTesting │ │ ├── account.vy │ │ ├── balance_with_balance-0.3.vy │ │ ├── balance_with_balance.vy │ │ ├── balance_with_balance2-0.3.vy │ │ ├── balance_with_balance2.vy │ │ ├── balance_without_balance.vy │ │ ├── builtins.vy │ │ ├── effects.vy │ │ ├── format_raw_string_with_control_chars.vy │ │ └── storage │ │ │ ├── storage_empty.vy │ │ │ └── storage_nonempty.vy │ ├── literals │ │ ├── denominations.vy │ │ ├── escape.vy │ │ ├── ether.vy │ │ ├── gwei.vy │ │ ├── hex_string_with_non_printable_characters.vy │ │ ├── scientific_notation.vy │ │ └── wei.vy │ ├── memoryManagement │ │ └── memory_types_initialisation.vy │ ├── operators │ │ ├── compound_assign.vy │ │ └── shifts │ │ │ ├── bitwise_shifting_constantinople-0.3.vy │ │ │ ├── bitwise_shifting_constantinople.vy │ │ │ ├── bitwise_shifting_constantinople_combined-0.3.vy │ │ │ ├── bitwise_shifting_constantinople_combined.vy │ │ │ ├── bitwise_shifting_constants_constantinople-0.3.vy │ │ │ ├── bitwise_shifting_constants_constantinople.vy │ │ │ ├── shift_cleanup-0.3.vy │ │ │ ├── shift_cleanup.vy │ │ │ ├── shift_cleanup_garbled-0.3.vy │ │ │ ├── shift_cleanup_garbled.vy │ │ │ ├── shift_constant_left-0.3.vy │ │ │ ├── shift_constant_left.vy │ │ │ ├── shift_constant_right-0.3.vy │ │ │ ├── shift_constant_right.vy │ │ │ ├── shift_left-0.3.vy │ │ │ ├── shift_left.vy │ │ │ ├── shift_overflow-0.3.vy │ │ │ ├── shift_overflow.vy │ │ │ ├── shift_right-0.3.vy │ │ │ ├── shift_right.vy │ │ │ ├── shift_underflow_negative_rvalue-0.3.vy │ │ │ ├── shift_underflow_negative_rvalue.vy │ │ │ ├── shifts-0.3.vy │ │ │ └── shifts.vy │ ├── optimizer │ │ ├── shift_bytes-0.3.vy │ │ └── shift_bytes.vy │ ├── revertStrings │ │ ├── calldata_array_dynamic_invalid.vy │ │ ├── calldata_array_invalid_length.vy │ │ ├── calldata_arrays_too_large.vy │ │ ├── calldata_tail_short.vy │ │ ├── called_contract_has_code-0.3.vy │ │ ├── called_contract_has_code.vy │ │ ├── empty_v1.vy │ │ ├── ether_non_payable_function.vy │ │ ├── function_entry_checks_v1.vy │ │ ├── short_input_array.vy │ │ ├── short_input_bytes.vy │ │ └── unknown_sig_no_fallback.vy │ ├── reverts │ │ ├── assert_require.vy │ │ ├── revert-0.3.vy │ │ ├── revert.vy │ │ └── simple_throw.vy │ ├── smoke │ │ ├── alignment-0.3.vy │ │ ├── alignment.vy │ │ ├── arrays-0.3.vy │ │ ├── arrays.vy │ │ ├── basic.vy │ │ ├── bytes_and_strings.vy │ │ ├── constructor-0.3.vy │ │ ├── constructor.vy │ │ ├── failure.vy │ │ ├── fallback.vy │ │ ├── multiline.vy │ │ ├── multiline_comments.vy │ │ ├── structs-0.3.vy │ │ └── structs.vy │ ├── specialFunctions │ │ └── keccak256_optimized.vy │ ├── state │ │ ├── gasleft.vy │ │ ├── msg_data.vy │ │ ├── msg_sender.vy │ │ └── msg_value.vy │ ├── state_var_initialization-0.3.vy │ ├── state_var_initialization.vy │ ├── storage │ │ ├── accessors_mapping_for_array-0.3.vy │ │ ├── accessors_mapping_for_array.vy │ │ ├── array_accessor-0.3.vy │ │ ├── array_accessor.vy │ │ ├── chop_sign_bits-0.3.vy │ │ ├── chop_sign_bits.vy │ │ ├── complex_accessors-0.3.vy │ │ ├── complex_accessors.vy │ │ ├── empty_nonempty_empty.vy │ │ ├── mapping_state.vy │ │ ├── mapping_string_key.vy │ │ ├── mappings_array2d_pop_delete.vy │ │ ├── mappings_array_pop_delete.vy │ │ ├── packed_storage_signed.vy │ │ ├── packed_storage_structs_bytes.vy │ │ ├── packed_storage_structs_uint.vy │ │ ├── simple_accessor-0.3.vy │ │ ├── simple_accessor.vy │ │ ├── state_smoke_test.vy │ │ ├── struct_accessor-0.3.vy │ │ └── struct_accessor.vy │ ├── strings │ │ ├── concat │ │ │ ├── string_concat_2_args.vy │ │ │ ├── string_concat_different_types-0.3.vy │ │ │ ├── string_concat_different_types.vy │ │ │ ├── string_concat_empty_strings.vy │ │ │ └── string_concat_nested.vy │ │ ├── constant_string_literal-0.3.vy │ │ ├── constant_string_literal.vy │ │ ├── empty_storage_string-0.3.vy │ │ ├── empty_storage_string-0.4.0.vy │ │ ├── empty_storage_string.vy │ │ ├── empty_string.vy │ │ ├── empty_string_input.vy │ │ ├── return_string.vy │ │ ├── string_escapes.vy │ │ ├── unicode_escapes.vy │ │ └── unicode_string.vy │ ├── structs │ │ ├── array_of_recursive_struct.vy │ │ ├── calldata │ │ │ ├── calldata_nested_structs.vy │ │ │ ├── calldata_struct.vy │ │ │ ├── calldata_struct_and_ints.vy │ │ │ ├── calldata_struct_array_member.vy │ │ │ ├── calldata_struct_array_member_dynamic.vy │ │ │ ├── calldata_struct_as_memory_argument.vy │ │ │ ├── calldata_struct_struct_member.vy │ │ │ ├── calldata_struct_struct_member_dynamic.vy │ │ │ ├── calldata_struct_to_memory.vy │ │ │ ├── calldata_struct_to_storage.vy │ │ │ ├── calldata_struct_with_array_to_memory.vy │ │ │ ├── calldata_struct_with_bytes_to_memory.vy │ │ │ ├── calldata_struct_with_nested_array_to_memory.vy │ │ │ ├── calldata_struct_with_nested_array_to_storage.vy │ │ │ ├── calldata_structs.vy │ │ │ ├── dynamic_nested.vy │ │ │ └── dynamically_encoded.vy │ │ ├── conversion │ │ │ ├── recursive_storage_memory.vy │ │ │ └── recursive_storage_memory_complex.vy │ │ ├── copy_from_storage-0.3.vy │ │ ├── copy_from_storage.vy │ │ ├── copy_struct_array_from_storage-0.3.vy │ │ ├── copy_struct_array_from_storage.vy │ │ ├── delete_struct-0.3.vy │ │ ├── delete_struct.vy │ │ ├── event-0.3.vy │ │ ├── event-0.4.0.vy │ │ ├── event.vy │ │ ├── global.vy │ │ ├── lone_struct_array_type.vy │ │ ├── memory_struct_named_constructor.vy │ │ ├── memory_structs_as_function_args.vy │ │ ├── memory_structs_nested.vy │ │ ├── memory_structs_nested_load.vy │ │ ├── memory_structs_read_write.vy │ │ ├── msg_data_to_struct_member_copy.vy │ │ ├── multislot_struct_allocation-0.3.vy │ │ ├── multislot_struct_allocation.vy │ │ ├── nested_struct_allocation-0.3.vy │ │ ├── nested_struct_allocation.vy │ │ ├── packed_storage_structs_delete.vy │ │ ├── recursive_structs.vy │ │ ├── simple_struct_allocation-0.3.vy │ │ ├── simple_struct_allocation.vy │ │ ├── struct_constructor_nested-0.3.vy │ │ ├── struct_constructor_nested.vy │ │ ├── struct_containing_bytes_copy_and_delete.vy │ │ ├── struct_copy.vy │ │ ├── struct_copy_via_local.vy │ │ ├── struct_delete_member-0.3.vy │ │ ├── struct_delete_member.vy │ │ ├── struct_delete_storage-0.3.vy │ │ ├── struct_delete_storage.vy │ │ ├── struct_delete_storage_nested_small.vy │ │ ├── struct_delete_storage_small.vy │ │ ├── struct_delete_storage_with_array.vy │ │ ├── struct_delete_storage_with_arrays_small.vy │ │ ├── struct_delete_struct_in_mapping-0.3.vy │ │ ├── struct_delete_struct_in_mapping.vy │ │ ├── struct_memory_to_storage-0.3.vy │ │ ├── struct_memory_to_storage.vy │ │ ├── struct_named_constructor.vy │ │ ├── struct_storage_push_zero_value-0.3.vy │ │ ├── struct_storage_push_zero_value.vy │ │ ├── struct_storage_to_mapping.vy │ │ ├── struct_storage_to_memory-0.3.vy │ │ ├── struct_storage_to_memory.vy │ │ └── structs.vy │ ├── types │ │ ├── assign_calldata_value_type.vy │ │ ├── convert_fixed_bytes_to_fixed_bytes_greater_size.vy │ │ ├── convert_fixed_bytes_to_fixed_bytes_smaller_size.vy │ │ ├── convert_fixed_bytes_to_uint_greater_size.vy │ │ ├── convert_fixed_bytes_to_uint_same_min_size.vy │ │ ├── convert_fixed_bytes_to_uint_same_type.vy │ │ ├── convert_fixed_bytes_to_uint_smaller_size.vy │ │ ├── convert_uint_to_fixed_bytes_greater_size.vy │ │ ├── convert_uint_to_fixed_bytes_same_min_size.vy │ │ ├── convert_uint_to_fixed_bytes_same_size.vy │ │ ├── convert_uint_to_fixed_bytes_smaller_size.vy │ │ ├── mapping_contract_key.vy │ │ ├── mapping_contract_key_getter-0.3.vy │ │ ├── mapping_contract_key_getter.vy │ │ ├── mapping_simple.vy │ │ ├── packing_signed_types.vy │ │ ├── packing_unpacking_types.vy │ │ └── strings.vy │ ├── underscore │ │ └── as_function.vy │ ├── variables │ │ ├── delete_local.vy │ │ └── delete_locals.vy │ ├── various │ │ ├── assignment_to_const_var_involving_expression.vy │ │ ├── balance-0.3.vy │ │ ├── balance.vy │ │ ├── byte_optimization_bug.vy │ │ ├── decayed_tuple.vy │ │ ├── empty_name_return_parameter.vy │ │ ├── erc20-0.3.vy │ │ ├── erc20-0.4.0.vy │ │ ├── erc20.vy │ │ ├── flipping_sign_tests-0.3.vy │ │ ├── flipping_sign_tests.vy │ │ ├── gasleft_decrease.vy │ │ ├── inline_member_init-0.3.vy │ │ ├── inline_member_init.vy │ │ ├── inline_tuple_with_rational_numbers.vy │ │ ├── iszero_bnot_correct.vy │ │ ├── literal_empty_string-0.3.vy │ │ ├── literal_empty_string.vy │ │ ├── memory_overwrite.vy │ │ ├── negative_stack_height.vy │ │ ├── nested_calldata_struct.vy │ │ ├── nested_calldata_struct_to_memory.vy │ │ ├── positive_integers_to_signed-0.3.vy │ │ ├── positive_integers_to_signed.vy │ │ ├── skip_dynamic_types-0.3.vy │ │ ├── skip_dynamic_types.vy │ │ ├── skip_dynamic_types_for_static_arrays_with_dynamic_elements-0.3.vy │ │ ├── skip_dynamic_types_for_static_arrays_with_dynamic_elements.vy │ │ ├── state_variable_local_variable_mixture-0.3.vy │ │ ├── state_variable_local_variable_mixture.vy │ │ ├── storage_string_as_mapping_key_without_variable.vy │ │ ├── store_bytes.vy │ │ ├── string_tuples.vy │ │ ├── swap_in_storage_overwrite.vy │ │ ├── tuples-0.3.vy │ │ └── tuples.vy │ └── viaYul │ │ ├── array_2d_assignment.vy │ │ ├── array_2d_new.vy │ │ ├── array_3d_assignment.vy │ │ ├── array_3d_new.vy │ │ ├── array_memory_allocation │ │ ├── array_2d_zeroed_memory_index_access-0.3.vy │ │ ├── array_2d_zeroed_memory_index_access.vy │ │ ├── array_array_static.vy │ │ ├── array_static_return_param_zeroed_memory_index_access.vy │ │ ├── array_static_zeroed_memory_index_access.vy │ │ └── array_zeroed_memory_index_access.vy │ │ ├── array_memory_as_parameter.vy │ │ ├── array_memory_create.vy │ │ ├── array_memory_index_access-0.3.vy │ │ ├── array_memory_index_access.vy │ │ ├── array_push_with_arg.vy │ │ ├── array_storage_index_access-0.3.vy │ │ ├── array_storage_index_access.vy │ │ ├── array_storage_index_boundary_test.vy │ │ ├── array_storage_length_access.vy │ │ ├── array_storage_pop_zero_length.vy │ │ ├── array_storage_push_pop.vy │ │ ├── assert.vy │ │ ├── assert_and_require.vy │ │ ├── assign_tuple_from_function_call.vy │ │ ├── calldata_array_access.vy │ │ ├── calldata_array_length.vy │ │ ├── calldata_array_three_dimensional.vy │ │ ├── calldata_bytes_array_bounds.vy │ │ ├── comparison.vy │ │ ├── conversion │ │ ├── explicit_cast_assignment.vy │ │ ├── explicit_cast_function_call.vy │ │ ├── explicit_cast_local_assignment.vy │ │ └── explicit_string_bytes_calldata_cast.vy │ │ ├── define_tuple_from_function_call.vy │ │ ├── detect_add_overflow.vy │ │ ├── detect_add_overflow_signed.vy │ │ ├── detect_div_overflow.vy │ │ ├── detect_mod_zero.vy │ │ ├── detect_mod_zero_signed.vy │ │ ├── detect_mul_overflow.vy │ │ ├── detect_mul_overflow_signed.vy │ │ ├── detect_sub_overflow.vy │ │ ├── detect_sub_overflow_signed.vy │ │ ├── exp_literals-0.3.vy │ │ ├── exp_literals.vy │ │ ├── exp_literals_success-0.3.vy │ │ ├── exp_literals_success.vy │ │ ├── function_entry_checks.vy │ │ ├── if-0.3.vy │ │ ├── if.vy │ │ ├── keccak.vy │ │ ├── local_address_assignment.vy │ │ ├── local_assignment.vy │ │ ├── local_bool_assignment.vy │ │ ├── local_variable_without_init.vy │ │ ├── loops │ │ ├── break-0.3.vy │ │ ├── break.vy │ │ ├── continue-0.3.vy │ │ ├── continue.vy │ │ ├── return-0.3.vy │ │ ├── return.vy │ │ ├── simple-0.3.vy │ │ └── simple.vy │ │ ├── mapping_getters.vy │ │ ├── mapping_string_key.vy │ │ ├── msg_sender.vy │ │ ├── negation_bug.vy │ │ ├── require.vy │ │ ├── return.vy │ │ ├── return_and_convert.vy │ │ ├── short_circuit.vy │ │ ├── simple_assignment.vy │ │ ├── smoke_test.vy │ │ ├── storage │ │ ├── dirty_storage_bytes_long-0.3.vy │ │ ├── dirty_storage_bytes_long.vy │ │ ├── mappings-0.3.vy │ │ ├── mappings.vy │ │ ├── packed_storage.vy │ │ └── simple_storage.vy │ │ ├── string_format.vy │ │ ├── string_literals.vy │ │ ├── struct_member_access-0.3.vy │ │ ├── struct_member_access.vy │ │ ├── tuple_evaluation_order.vy │ │ └── unary_operations.vy └── simple │ ├── algorithm │ ├── arrays │ │ ├── multidimensional-0.3.vy │ │ ├── multidimensional.vy │ │ ├── standard_functions-0.3.vy │ │ └── standard_functions.vy │ ├── call_conditions-0.3.vy │ ├── call_conditions.vy │ ├── cryptography │ │ ├── book_cypher-0.3.vy │ │ ├── book_cypher.vy │ │ ├── caesar_cypher-0.3.vy │ │ ├── caesar_cypher.vy │ │ ├── vigenere_cypher-0.3.vy │ │ └── vigenere_cypher.vy │ ├── factorial-0.3.vy │ ├── factorial.vy │ ├── fibonacci-0.3.vy │ ├── fibonacci.vy │ ├── floating_point_simulation │ │ ├── geometry │ │ │ ├── area-0.3.vy │ │ │ ├── area.vy │ │ │ ├── lines-0.3.vy │ │ │ ├── lines.vy │ │ │ ├── volume-0.3.vy │ │ │ └── volume.vy │ │ ├── square_equation-0.3.vy │ │ └── square_equation.vy │ ├── hash-0.3.vy │ ├── hash.vy │ ├── long_arithmetic-0.3.vy │ ├── long_arithmetic.vy │ ├── matrix-0.3.vy │ ├── matrix.vy │ ├── person_balances-0.3.vy │ ├── person_balances.vy │ ├── sort │ │ ├── bubble-0.3.vy │ │ ├── bubble.vy │ │ ├── merge_iterative-0.3.vy │ │ └── merge_iterative.vy │ ├── split-0.3.vy │ ├── split.vy │ ├── sum_oddness-0.3.vy │ └── sum_oddness.vy │ ├── array │ ├── mutating_assignment-0.3.vy │ ├── mutating_assignment.vy │ ├── mutating_nested_one_element-0.3.vy │ ├── mutating_nested_one_element.vy │ ├── size_constant_expression-0.3.vy │ ├── size_constant_expression.vy │ ├── store_load_constant_array_witness_index-0.3.vy │ ├── store_load_constant_array_witness_index.vy │ ├── store_load_nested_constant_array_witness_index-0.3.vy │ ├── store_load_nested_constant_array_witness_index.vy │ ├── store_load_nested_witness_array_constant_index-0.3.vy │ ├── store_load_nested_witness_array_constant_index.vy │ ├── store_load_nested_witness_array_witness_index-0.3.vy │ ├── store_load_nested_witness_array_witness_index.vy │ ├── store_load_witness_array_constant_index-0.3.vy │ ├── store_load_witness_array_constant_index.vy │ ├── store_load_witness_array_witness_index-0.3.vy │ └── store_load_witness_array_witness_index.vy │ ├── block │ ├── expression-0.3.vy │ ├── expression.vy │ ├── mutating-0.3.vy │ ├── mutating.vy │ ├── pyramid-0.3.vy │ └── pyramid.vy │ ├── built_in_functions │ ├── abs-0.3.vy │ ├── abs.vy │ ├── ceil-0.3.vy │ ├── ceil.vy │ ├── floor-0.3.vy │ ├── floor.vy │ ├── max-0.3.vy │ ├── max.vy │ ├── min-0.3.vy │ ├── min.vy │ ├── sqrt-0.3.vy │ ├── sqrt.vy │ ├── uint256_addmod-0.3.vy │ ├── uint256_addmod.vy │ ├── uint256_mulmod-0.3.vy │ ├── uint256_mulmod.vy │ ├── unsafe_div-0.3.vy │ └── unsafe_div.vy │ ├── conditional │ ├── mutating_complex-0.3.vy │ ├── mutating_complex.vy │ ├── mutating_simple-0.3.vy │ ├── mutating_simple.vy │ ├── nested_condition-0.3.vy │ ├── nested_condition.vy │ ├── nested_gates-0.3.vy │ ├── nested_gates.vy │ ├── nested_gates_mutating-0.3.vy │ ├── nested_gates_mutating.vy │ ├── require-0.3.vy │ └── require.vy │ ├── constructor │ ├── default-0.3.vy │ ├── default.vy │ ├── destructuring │ ├── tuple-0.3.vy │ └── tuple.vy │ ├── error │ ├── assert_unreachable.vy │ ├── default-0.3.vy │ └── default.vy │ ├── evaluation_order-0.3.vy │ ├── evaluation_order.vy │ ├── events │ ├── 1_topic-0.3.vy │ ├── 1_topic-0.4.0.vy │ ├── 1_topic.vy │ ├── 1_topic_0_bytes-0.3.vy │ ├── 1_topic_0_bytes.vy │ ├── 1_topic_32_bytes-0.3.vy │ ├── 1_topic_32_bytes-0.4.0.vy │ ├── 1_topic_32_bytes.vy │ ├── 1_topic_64_bytes-0.3.vy │ ├── 1_topic_64_bytes-0.4.0.vy │ ├── 1_topic_64_bytes.vy │ ├── 1_topic_96_bytes-0.3.vy │ ├── 1_topic_96_bytes-0.4.0.vy │ ├── 1_topic_96_bytes.vy │ ├── 2_topics-0.3.vy │ ├── 2_topics-0.4.0.vy │ ├── 2_topics.vy │ ├── 2_topics_0_bytes-0.3.vy │ ├── 2_topics_0_bytes-0.4.0.vy │ ├── 2_topics_0_bytes.vy │ ├── 2_topics_32_bytes-0.3.vy │ ├── 2_topics_32_bytes-0.4.0.vy │ ├── 2_topics_32_bytes.vy │ ├── 2_topics_64_bytes-0.3.vy │ ├── 2_topics_64_bytes-0.4.0.vy │ ├── 2_topics_64_bytes.vy │ ├── 2_topics_96_bytes-0.3.vy │ ├── 2_topics_96_bytes-0.4.0.vy │ ├── 2_topics_96_bytes.vy │ ├── 3_topics-0.3.vy │ ├── 3_topics-0.4.0.vy │ ├── 3_topics.vy │ ├── 3_topics_0_bytes-0.3.vy │ ├── 3_topics_0_bytes-0.4.0.vy │ ├── 3_topics_0_bytes.vy │ ├── 3_topics_32_bytes-0.3.vy │ ├── 3_topics_32_bytes-0.4.0.vy │ ├── 3_topics_32_bytes.vy │ ├── 3_topics_64_bytes-0.3.vy │ ├── 3_topics_64_bytes-0.4.0.vy │ ├── 3_topics_64_bytes.vy │ ├── 3_topics_96_bytes-0.3.vy │ ├── 3_topics_96_bytes-0.4.0.vy │ ├── 3_topics_96_bytes.vy │ ├── 4_topics-0.3.vy │ ├── 4_topics-0.4.0.vy │ ├── 4_topics.vy │ ├── 4_topics_0_bytes-0.3.vy │ ├── 4_topics_0_bytes-0.4.0.vy │ ├── 4_topics_0_bytes.vy │ ├── 4_topics_32_bytes-0.3.vy │ ├── 4_topics_32_bytes-0.4.0.vy │ ├── 4_topics_32_bytes.vy │ ├── 4_topics_64_bytes-0.3.vy │ ├── 4_topics_64_bytes-0.4.0.vy │ ├── 4_topics_64_bytes.vy │ ├── 4_topics_96_bytes-0.3.vy │ ├── 4_topics_96_bytes-0.4.0.vy │ ├── 4_topics_96_bytes.vy │ ├── default-0.3.vy │ ├── default-0.4.0.vy │ └── default.vy │ ├── expression │ ├── complex_access-0.3.vy │ ├── complex_access.vy │ ├── complex_function_result_slice-0.3.vy │ ├── complex_function_result_slice.vy │ ├── complex_operator-0.3.vy │ ├── complex_operator.vy │ ├── complex_operator_minimal-0.3.vy │ ├── complex_operator_minimal.vy │ ├── constant_complex-0.3.vy │ ├── constant_complex.vy │ ├── constant_conditional-0.3.vy │ ├── constant_conditional.vy │ ├── constant_match-0.3.vy │ ├── constant_match.vy │ ├── inference_operator-0.3.vy │ ├── inference_operator.vy │ ├── mixed_item_constantness-0.3.vy │ ├── mixed_item_constantness.vy │ ├── mixed_literal_base-0.3.vy │ └── mixed_literal_base.vy │ ├── fallback │ ├── simple-0.3.vy │ └── simple.vy │ ├── function │ ├── many_arguments_1-0.3.vy │ ├── many_arguments_1.vy │ ├── many_arguments_1_complex-0.3.vy │ ├── many_arguments_1_complex.vy │ ├── many_arguments_1_complex_types-0.3.vy │ ├── many_arguments_1_complex_types.vy │ ├── many_arguments_1_types-0.3.vy │ ├── many_arguments_1_types.vy │ ├── many_arguments_2-0.3.vy │ ├── many_arguments_2.vy │ ├── many_arguments_2_complex-0.3.vy │ ├── many_arguments_2_complex.vy │ ├── many_arguments_3-0.3.vy │ ├── many_arguments_3.vy │ ├── many_arguments_3_complex-0.3.vy │ ├── many_arguments_3_complex.vy │ ├── many_arguments_4-0.3.vy │ ├── many_arguments_4.vy │ ├── simple-0.3.vy │ ├── simple.vy │ ├── simple_types-0.3.vy │ └── simple_types.vy │ ├── immutable │ ├── aligned │ │ ├── array │ │ │ ├── copy-0.3.vy │ │ │ ├── copy.vy │ │ │ ├── product-0.3.vy │ │ │ ├── product.vy │ │ │ ├── sum-0.3.vy │ │ │ └── sum.vy │ │ ├── complex_operator-0.3.vy │ │ ├── complex_operator.vy │ │ ├── method_chain-0.3.vy │ │ ├── method_chain.vy │ │ ├── mixed_data_origin-0.3.vy │ │ ├── mixed_data_origin.vy │ │ ├── simple_operator-0.3.vy │ │ ├── simple_operator.vy │ │ └── structure │ │ │ ├── copy-0.3.vy │ │ │ ├── copy.vy │ │ │ ├── product-0.3.vy │ │ │ ├── product.vy │ │ │ ├── sum-0.3.vy │ │ │ └── sum.vy │ ├── bytestring │ │ ├── copy-0.3.vy │ │ └── copy.vy │ ├── complex │ │ ├── full-0.3.vy │ │ ├── full.vy │ │ ├── minimized-0.3.3.vy │ │ └── minimized.vy │ ├── constructor-0.3.vy │ ├── constructor.vy │ ├── string │ │ ├── copy-0.3.vy │ │ └── copy.vy │ └── unaligned │ │ ├── array │ │ ├── copy-0.3.vy │ │ ├── copy.vy │ │ ├── product-0.3.vy │ │ ├── product.vy │ │ ├── sum-0.3.vy │ │ └── sum.vy │ │ ├── complex_operator-0.3.vy │ │ ├── complex_operator.vy │ │ ├── method_chain-0.3.vy │ │ ├── method_chain.vy │ │ ├── mixed_data_origin-0.3.vy │ │ ├── mixed_data_origin.vy │ │ ├── simple_operator-0.3.vy │ │ ├── simple_operator.vy │ │ └── structure │ │ ├── copy-0.3.vy │ │ ├── copy.vy │ │ ├── product-0.3.vy │ │ ├── product.vy │ │ ├── sum-0.3.vy │ │ └── sum.vy │ ├── interface │ ├── simple_call-0.3.vy │ ├── simple_call.vy │ ├── structure_common_namespace-0.3.vy │ ├── structure_common_namespace.vy │ ├── structure_constructor-0.3.vy │ ├── structure_constructor.vy │ ├── structure_immutable_method-0.3.vy │ ├── structure_immutable_method.vy │ ├── structure_method_chain-0.3.vy │ ├── structure_method_chain.vy │ ├── structure_mutable_method-0.3.vy │ └── structure_mutable_method.vy │ ├── loop │ ├── array │ │ ├── nested_computation-0.3.vy │ │ ├── nested_computation.vy │ │ ├── simple-0.3.vy │ │ ├── simple.vy │ │ ├── simple_lower_half-0.3.vy │ │ ├── simple_lower_half.vy │ │ ├── simple_middle_half-0.3.vy │ │ ├── simple_middle_half.vy │ │ ├── simple_upper_half-0.3.vy │ │ └── simple_upper_half.vy │ ├── bounds │ │ ├── complex-0.3.vy │ │ ├── complex.vy │ │ ├── complex_explicit-0.3.vy │ │ ├── complex_explicit.vy │ │ ├── simple_explicit-0.3.vy │ │ └── simple_explicit.vy │ ├── complex │ │ ├── 1-0.3.vy │ │ ├── 1.vy │ │ ├── 2-0.3.vy │ │ ├── 2.vy │ │ ├── 3-0.3.vy │ │ ├── 3.vy │ │ ├── 4-0.3.vy │ │ ├── 4.vy │ │ ├── 5-0.3.vy │ │ ├── 5.vy │ │ ├── 6-0.3.vy │ │ └── 6.vy │ ├── for │ │ ├── array-0.3.vy │ │ ├── array.vy │ │ ├── break_continue-0.3.vy │ │ ├── break_continue.vy │ │ ├── unreachable_break-0.3.vy │ │ └── unreachable_break.vy │ ├── range_bitlength_inference │ │ ├── i8_to_i16-0.3.vy │ │ ├── i8_to_i16.vy │ │ ├── u16_to_i16-0.3.vy │ │ ├── u16_to_i16.vy │ │ ├── u8_to_i8-0.3.vy │ │ ├── u8_to_i8.vy │ │ ├── u8_to_u16-0.3.vy │ │ ├── u8_to_u16.vy │ │ ├── u8_to_u256_const-0.3.vy │ │ ├── u8_to_u256_const.vy │ │ ├── u8_to_u64_const-0.3.vy │ │ └── u8_to_u64_const.vy │ └── range_bound │ │ ├── i16-0.3.vy │ │ ├── i16.vy │ │ ├── i256_lower-0.3.vy │ │ ├── i256_lower.vy │ │ ├── i256_upper-0.3.vy │ │ ├── i256_upper.vy │ │ ├── i32_lower-0.3.vy │ │ ├── i32_lower.vy │ │ ├── i32_upper-0.3.vy │ │ ├── i32_upper.vy │ │ ├── i64_lower-0.3.vy │ │ ├── i64_lower.vy │ │ ├── i64_upper-0.3.vy │ │ ├── i64_upper.vy │ │ ├── i8-0.3.vy │ │ ├── i8.vy │ │ ├── u16-0.3.vy │ │ ├── u16.vy │ │ ├── u32-0.3.vy │ │ ├── u32.vy │ │ ├── u64-0.3.vy │ │ ├── u64.vy │ │ ├── u8-0.3.vy │ │ └── u8.vy │ ├── modular │ ├── addmod-0.3.vy │ ├── addmod.vy │ ├── mulmod-0.3.vy │ └── mulmod.vy │ ├── operator │ ├── arithmetic │ │ ├── addition_i128-0.3.vy │ │ ├── addition_i128.vy │ │ ├── addition_i8-0.3.vy │ │ ├── addition_i8.vy │ │ ├── addition_u8-0.3.vy │ │ ├── addition_u8.vy │ │ ├── division_i128-0.3.vy │ │ ├── division_i128.vy │ │ ├── division_i8-0.3.vy │ │ ├── division_i8.vy │ │ ├── division_u8-0.3.vy │ │ ├── division_u8.vy │ │ ├── exponentiation_i128_const-0.3.vy │ │ ├── exponentiation_i128_const.vy │ │ ├── exponentiation_u8_const-0.3.vy │ │ ├── exponentiation_u8_const.vy │ │ ├── multiplication_i128-0.3.vy │ │ ├── multiplication_i128.vy │ │ ├── multiplication_i8-0.3.vy │ │ ├── multiplication_i8.vy │ │ ├── multiplication_u8-0.3.vy │ │ ├── multiplication_u8.vy │ │ ├── negation_i128-0.3.vy │ │ ├── negation_i128.vy │ │ ├── negation_i8-0.3.vy │ │ ├── negation_i8.vy │ │ ├── negation_u8-0.3.vy │ │ ├── negation_u8.vy │ │ ├── remainder_i128-0.3.vy │ │ ├── remainder_i128.vy │ │ ├── remainder_i8-0.3.vy │ │ ├── remainder_i8.vy │ │ ├── remainder_u8-0.3.vy │ │ ├── remainder_u8.vy │ │ ├── subtraction_i128-0.3.vy │ │ ├── subtraction_i128.vy │ │ ├── subtraction_i8-0.3.vy │ │ ├── subtraction_i8.vy │ │ ├── subtraction_u8-0.3.vy │ │ └── subtraction_u8.vy │ ├── assignment │ │ ├── addition_i128-0.3.vy │ │ ├── addition_i128.vy │ │ ├── addition_i8-0.3.vy │ │ ├── addition_i8.vy │ │ ├── addition_u8-0.3.vy │ │ ├── addition_u8.vy │ │ ├── division_i128-0.3.vy │ │ ├── division_i128.vy │ │ ├── division_i8-0.3.vy │ │ ├── division_i8.vy │ │ ├── division_u8-0.3.vy │ │ ├── division_u8.vy │ │ ├── multiplication_i128-0.3.vy │ │ ├── multiplication_i128.vy │ │ ├── multiplication_i8-0.3.vy │ │ ├── multiplication_i8.vy │ │ ├── multiplication_u8-0.3.vy │ │ ├── multiplication_u8.vy │ │ ├── remainder_i128-0.3.vy │ │ ├── remainder_i128.vy │ │ ├── remainder_i8-0.3.vy │ │ ├── remainder_i8.vy │ │ ├── remainder_u8-0.3.vy │ │ ├── remainder_u8.vy │ │ ├── subtraction_i128-0.3.vy │ │ ├── subtraction_i128.vy │ │ ├── subtraction_i8-0.3.vy │ │ ├── subtraction_i8.vy │ │ ├── subtraction_u8-0.3.vy │ │ └── subtraction_u8.vy │ ├── bitwise │ │ ├── and_u256-0.3.vy │ │ ├── and_u256.vy │ │ ├── not_u256-0.3.vy │ │ ├── not_u256.vy │ │ ├── or_u256-0.3.vy │ │ ├── or_u256.vy │ │ ├── shift_left │ │ │ ├── u256_min_to_max-0.3.vy │ │ │ ├── u256_min_to_max.vy │ │ │ ├── u256_ordinar-0.3.vy │ │ │ └── u256_ordinar.vy │ │ ├── shift_right │ │ │ ├── u256_max_to_min-0.3.vy │ │ │ ├── u256_max_to_min.vy │ │ │ ├── u256_ordinar-0.3.vy │ │ │ └── u256_ordinar.vy │ │ ├── xor_u256-0.3.vy │ │ └── xor_u256.vy │ ├── casting │ │ ├── i128_to_u8-0.3.vy │ │ ├── i128_to_u8.vy │ │ ├── i16_to_i8-0.3.vy │ │ ├── i16_to_i8.vy │ │ ├── i16_to_u8-0.3.vy │ │ ├── i16_to_u8.vy │ │ ├── i256_to_i128-0.3.vy │ │ ├── i256_to_i128.vy │ │ ├── i256_to_u8-0.3.vy │ │ ├── i256_to_u8.vy │ │ ├── i8_to_u8-0.3.vy │ │ ├── i8_to_u8.vy │ │ ├── u16_to_i8-0.3.vy │ │ ├── u16_to_i8.vy │ │ ├── u16_to_u8-0.3.vy │ │ ├── u16_to_u8.vy │ │ ├── u256_to_i128-0.3.vy │ │ ├── u256_to_i128.vy │ │ ├── u256_to_u8-0.3.vy │ │ ├── u256_to_u8.vy │ │ ├── u8_to_i128-0.3.vy │ │ ├── u8_to_i128.vy │ │ ├── u8_to_i8-0.3.vy │ │ └── u8_to_i8.vy │ ├── comparison │ │ ├── address │ │ │ ├── equals-0.3.vy │ │ │ ├── equals.vy │ │ │ ├── not_equals-0.3.vy │ │ │ └── not_equals.vy │ │ ├── equals_i128-0.3.vy │ │ ├── equals_i128.vy │ │ ├── equals_i8-0.3.vy │ │ ├── equals_i8.vy │ │ ├── equals_u8-0.3.vy │ │ ├── equals_u8.vy │ │ ├── greater_equals_i128-0.3.vy │ │ ├── greater_equals_i128.vy │ │ ├── greater_equals_i8-0.3.vy │ │ ├── greater_equals_i8.vy │ │ ├── greater_equals_u8-0.3.vy │ │ ├── greater_equals_u8.vy │ │ ├── greater_i128-0.3.vy │ │ ├── greater_i128.vy │ │ ├── greater_i8-0.3.vy │ │ ├── greater_i8.vy │ │ ├── greater_u8-0.3.vy │ │ ├── greater_u8.vy │ │ ├── lesser_equals_i128-0.3.vy │ │ ├── lesser_equals_i128.vy │ │ ├── lesser_equals_i8-0.3.vy │ │ ├── lesser_equals_i8.vy │ │ ├── lesser_equals_u8-0.3.vy │ │ ├── lesser_equals_u8.vy │ │ ├── lesser_i128-0.3.vy │ │ ├── lesser_i128.vy │ │ ├── lesser_i8-0.3.vy │ │ ├── lesser_i8.vy │ │ ├── lesser_u8-0.3.vy │ │ ├── lesser_u8.vy │ │ ├── not_equals_i128-0.3.vy │ │ ├── not_equals_i128.vy │ │ ├── not_equals_i8-0.3.vy │ │ ├── not_equals_i8.vy │ │ ├── not_equals_u8-0.3.vy │ │ └── not_equals_u8.vy │ └── logical │ │ ├── and-0.3.vy │ │ ├── and.vy │ │ ├── not-0.3.vy │ │ ├── not.vy │ │ ├── or-0.3.vy │ │ └── or.vy │ ├── order │ ├── casted_declared_const-0.3.vy │ ├── casted_declared_const.vy │ ├── casted_inline_const-0.3.vy │ ├── casted_inline_const.vy │ ├── casted_variable-0.3.vy │ ├── casted_variable.vy │ ├── declared_const-0.3.vy │ ├── declared_const.vy │ ├── inline_const-0.3.vy │ ├── inline_const.vy │ ├── variable-0.3.vy │ └── variable.vy │ ├── overflow │ ├── negative │ │ ├── i128-0.3.vy │ │ ├── i128.vy │ │ ├── i16-0.3.vy │ │ ├── i16.vy │ │ ├── i248-0.3.vy │ │ ├── i248.vy │ │ ├── i256-0.3.vy │ │ ├── i256.vy │ │ ├── i32-0.3.vy │ │ ├── i32.vy │ │ ├── i64-0.3.vy │ │ ├── i64.vy │ │ ├── i8-0.3.vy │ │ ├── i8.vy │ │ ├── u16-0.3.vy │ │ ├── u16.vy │ │ ├── u248-0.3.vy │ │ ├── u248.vy │ │ ├── u256-0.3.vy │ │ ├── u256.vy │ │ ├── u32-0.3.vy │ │ ├── u32.vy │ │ ├── u64-0.3.vy │ │ ├── u64.vy │ │ ├── u8-0.3.vy │ │ └── u8.vy │ └── positive │ │ ├── i128-0.3.vy │ │ ├── i128.vy │ │ ├── i16-0.3.vy │ │ ├── i16.vy │ │ ├── i248-0.3.vy │ │ ├── i248.vy │ │ ├── i256-0.3.vy │ │ ├── i256.vy │ │ ├── i32-0.3.vy │ │ ├── i32.vy │ │ ├── i64-0.3.vy │ │ ├── i64.vy │ │ ├── i8-0.3.vy │ │ ├── i8.vy │ │ ├── u16-0.3.vy │ │ ├── u16.vy │ │ ├── u248-0.3.vy │ │ ├── u248.vy │ │ ├── u256-0.3.vy │ │ ├── u256.vy │ │ ├── u32-0.3.vy │ │ ├── u32.vy │ │ ├── u64-0.3.vy │ │ ├── u64.vy │ │ ├── u8-0.3.vy │ │ └── u8.vy │ ├── return │ ├── bytes_to_bytes32-0.3.vy │ ├── bytes_to_bytes32.vy │ ├── complex-0.3.vy │ ├── complex.vy │ ├── if_arithmetic-0.3.vy │ ├── if_arithmetic.vy │ ├── if_logical-0.3.vy │ ├── if_logical.vy │ ├── loop │ │ ├── complex-0.3.vy │ │ ├── complex.vy │ │ ├── for-0.3.vy │ │ └── for.vy │ ├── msg_sender-0.3.vy │ └── msg_sender.vy │ ├── revert_on_failure │ ├── max_outsize_non_zero-0.3.vy │ ├── max_outsize_non_zero.vy │ ├── max_outsize_zero-0.3.vy │ └── max_outsize_zero.vy │ ├── solidity_by_example │ ├── applications │ │ ├── merkle_tree-0.3.vy │ │ └── merkle_tree.vy │ └── simple │ │ ├── array-0.3.vy │ │ ├── array.vy │ │ ├── array_remove_by_shifting-0.3.vy │ │ ├── array_remove_by_shifting.vy │ │ ├── array_replace_from_end-0.3.vy │ │ ├── array_replace_from_end.vy │ │ ├── constants-0.3.vy │ │ ├── constants.vy │ │ ├── error-0.3.vy │ │ ├── error.vy │ │ ├── error_account-0.3.vy │ │ ├── error_account.vy │ │ ├── ether_and_wei-0.3.vy │ │ ├── ether_and_wei.vy │ │ ├── events-0.3.vy │ │ ├── events-0.4.0.vy │ │ ├── events.vy │ │ ├── first_app-0.3.vy │ │ ├── first_app.vy │ │ ├── function-0.3.vy │ │ ├── function.vy │ │ ├── function_selector-0.3.vy │ │ ├── function_selector.vy │ │ ├── hello_world-0.3.vy │ │ ├── hello_world.vy │ │ ├── if_else-0.3.vy │ │ ├── if_else.vy │ │ ├── immutable-0.3.vy │ │ ├── immutable.vy │ │ ├── mapping-0.3.vy │ │ ├── mapping.vy │ │ ├── nested_mapping-0.3.vy │ │ ├── nested_mapping.vy │ │ ├── primitive_data_types-0.3.vy │ │ ├── primitive_data_types.vy │ │ ├── reading_and_writing_to_a_state_variable-0.3.vy │ │ ├── reading_and_writing_to_a_state_variable.vy │ │ ├── structs-0.3.vy │ │ ├── structs.vy │ │ ├── variables-0.3.vy │ │ ├── variables.vy │ │ ├── verifying_signature-0.3.vy │ │ ├── verifying_signature.vy │ │ ├── view_and_pure_functions-0.3.vy │ │ └── view_and_pure_functions.vy │ ├── storage │ ├── aligned │ │ ├── array │ │ │ ├── assign-0.3.vy │ │ │ ├── assign.vy │ │ │ ├── assign_nested-0.3.vy │ │ │ ├── assign_nested.vy │ │ │ ├── product-0.3.vy │ │ │ ├── product.vy │ │ │ ├── reassign-0.3.vy │ │ │ ├── reassign.vy │ │ │ ├── reassign_nested-0.3.vy │ │ │ ├── reassign_nested.vy │ │ │ ├── sum-0.3.vy │ │ │ └── sum.vy │ │ ├── complex_operator-0.3.vy │ │ ├── complex_operator.vy │ │ ├── method_chain-0.3.vy │ │ ├── method_chain.vy │ │ ├── mixed_data_origin-0.3.vy │ │ ├── mixed_data_origin.vy │ │ ├── mutating_conditional-0.3.vy │ │ ├── mutating_conditional.vy │ │ ├── simple_operator-0.3.vy │ │ ├── simple_operator.vy │ │ └── structure │ │ │ ├── assign-0.3.vy │ │ │ ├── assign.vy │ │ │ ├── assign_nested-0.3.vy │ │ │ ├── assign_nested.vy │ │ │ ├── product-0.3.vy │ │ │ ├── product.vy │ │ │ ├── reassign-0.3.vy │ │ │ ├── reassign.vy │ │ │ ├── reassign_nested-0.3.vy │ │ │ ├── reassign_nested.vy │ │ │ ├── sum-0.3.vy │ │ │ └── sum.vy │ ├── mapping │ │ ├── call_getter-0.3.vy │ │ ├── call_getter.vy │ │ ├── call_getter_nested-0.3.vy │ │ ├── call_getter_nested.vy │ │ ├── multiple-0.3.vy │ │ ├── multiple.vy │ │ ├── mutating_one_element-0.3.vy │ │ ├── mutating_one_element.vy │ │ ├── mutating_one_element_nested-0.3.vy │ │ ├── mutating_one_element_nested.vy │ │ ├── nested-0.3.vy │ │ ├── nested.vy │ │ ├── simple-0.3.vy │ │ └── simple.vy │ └── unaligned │ │ ├── array │ │ ├── assign-0.3.vy │ │ ├── assign.vy │ │ ├── assign_nested-0.3.vy │ │ ├── assign_nested.vy │ │ ├── default_init-0.3.vy │ │ ├── default_init.vy │ │ ├── mutating_one_element-0.3.vy │ │ ├── mutating_one_element.vy │ │ ├── product-0.3.vy │ │ ├── product.vy │ │ ├── reassign-0.3.vy │ │ ├── reassign.vy │ │ ├── reassign_nested-0.3.vy │ │ ├── reassign_nested.vy │ │ ├── sum-0.3.vy │ │ └── sum.vy │ │ ├── complex_operator-0.3.vy │ │ ├── complex_operator.vy │ │ ├── method_chain-0.3.vy │ │ ├── method_chain.vy │ │ ├── mixed_data_origin-0.3.vy │ │ ├── mixed_data_origin.vy │ │ ├── mutating_conditional-0.3.vy │ │ ├── mutating_conditional.vy │ │ ├── simple_operator-0.3.vy │ │ ├── simple_operator.vy │ │ └── structure │ │ ├── assign-0.3.vy │ │ ├── assign.vy │ │ ├── assign_nested-0.3.vy │ │ ├── assign_nested.vy │ │ ├── product-0.3.vy │ │ ├── product.vy │ │ ├── reassign-0.3.vy │ │ ├── reassign.vy │ │ ├── reassign_nested-0.3.vy │ │ ├── reassign_nested.vy │ │ ├── sum-0.3.vy │ │ └── sum.vy │ ├── structure │ ├── mutating-0.3.vy │ ├── mutating.vy │ ├── mutating_assignment-0.3.vy │ ├── mutating_assignment.vy │ ├── nested_constant-0.3.vy │ ├── nested_constant.vy │ ├── nested_evaluation_stack-0.3.vy │ ├── nested_evaluation_stack.vy │ ├── nested_storage-0.3.vy │ └── nested_storage.vy │ ├── unchecked_math │ ├── addition-0.3.vy │ ├── addition.vy │ ├── exponentiation-0.3.vy │ ├── exponentiation.vy │ ├── multiplication-0.3.vy │ ├── multiplication.vy │ ├── subtraction-0.3.vy │ └── subtraction.vy │ └── unused │ ├── argument-0.3.vy │ ├── argument.vy │ ├── arguments_many-0.3.vy │ ├── arguments_many.vy │ ├── cases-0.3.vy │ ├── cases.vy │ ├── functions-0.3.vy │ └── functions.vy └── yul ├── address_space_distinction.yul ├── default.yul ├── examples ├── example_1.yul ├── example_2.yul ├── example_3.yul ├── example_4.yul └── example_5.yul ├── immutable_high_indexes.yul ├── instructions ├── byte.yul ├── calldatacopy │ ├── large_destination.yul │ └── large_source.yul ├── event │ ├── 0_topics_0_cells.yul │ └── 0_topics_2_cells.yul ├── greater_equals.yul ├── greater_than.yul ├── lesser_equals.yul ├── lesser_than.yul ├── load.yul ├── msize.yul ├── mstore8.yul ├── revert.yul ├── shift_arithmetic_right.yul ├── sign_extend.yul ├── signed_division.yul └── store.yul ├── multiple_return_values.yul ├── near_call_abi ├── evaluation_order.yul ├── panic │ ├── complex.yul │ ├── different_count_of_arguments.yul │ ├── different_return_types.yul │ ├── nested.yul │ ├── out_of_gas │ │ ├── 1.yul │ │ └── 2.yul │ ├── recursion_fact.yul │ └── simple.yul ├── simple_tuple.yul └── verbatim │ ├── throw_nested.yul │ └── throw_simple.yul ├── optimizer_bug.yul ├── precompiles ├── ecadd.yul ├── ecadd_source.yul ├── ecmul.yul ├── ecmul_source.yul ├── modexp_source.yul └── p256verify_source.yul ├── self_call_nested.yul ├── self_call_stack_overflow.yul ├── semantic ├── expressions.yul ├── for.yul ├── function_definitions.yul ├── if.yul ├── literals.yul ├── statements.yul ├── switch.yul └── variables.yul └── simulations ├── active_ptr_data_copy.yul ├── active_ptr_data_load.yul ├── active_ptr_data_size.yul ├── call_flags.yul ├── code_source.yul ├── const_array.yul ├── decommit.yul ├── event_initialize.yul ├── event_write.yul ├── extra_abi_data.yul ├── increment_tx_counter.yul ├── load_calldata_ptr_into_active.yul ├── load_return_data_ptr_into_active.yul ├── meta.yul ├── mimic_call.yul ├── mimic_call_by_ref.yul ├── multiplication_high.yul ├── precompile.yul ├── ptr_add_into_active.yul ├── ptr_calldata.yul ├── ptr_pack_into_active.yul ├── ptr_return_data.yul ├── ptr_shrink_into_active.yul ├── raw_far_call.yul ├── raw_far_call_by_ref.yul ├── set_context_u128.yul ├── set_pubdata_price.yul ├── system_call.yul ├── system_call_by_ref.yul ├── system_mimic_call.yul ├── system_mimic_call_by_ref.yul └── to_l1.yul /.gitignore: -------------------------------------------------------------------------------- 1 | # IDE 2 | 3 | /.idea/ 4 | /.vscode/ 5 | -------------------------------------------------------------------------------- /solidity/complex/array_one_element/callable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.9; 4 | 5 | contract Callable { 6 | function f(uint[1] memory p1) public pure returns(uint) { 7 | return p1[0]; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/call_chain/first.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | import "./second.sol"; 6 | 7 | contract First { 8 | function f(uint p, Second second, Third third) public returns(uint) { 9 | return second.f(p, third); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/call_chain/second.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | import "./third.sol"; 6 | 7 | contract Second { 8 | function f(uint p, Third third) public returns(uint) { 9 | return third.f(p) * 2; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/call_chain/third.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Third { 6 | function f(uint p) public pure returns(uint) { 7 | return p * 3; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/create/create2_chain/third.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Third { 6 | function f(uint256 p) public returns(uint) { 7 | return p * 3; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/create/create_chain/third.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Third { 6 | function f(uint256 p) public returns(uint) { 7 | return p * 3; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/create/create_in_library/callable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Callable { 6 | function f(uint a) public pure returns(uint) { 7 | return a * 2; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/create/create_in_library/library.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.2; 4 | 5 | import "./callable.sol"; 6 | 7 | library L { 8 | function f() public returns(address) { 9 | return address(new Callable()); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/default/callable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Callable { 6 | function f(uint a) public pure returns(uint) { 7 | return a * 2; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/default/main.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | import "./callable.sol"; 6 | 7 | contract Main { 8 | function main(Callable callable) public returns(uint) { 9 | return callable.f(5); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/defi/UniswapV2Router01/interfaces/IWETH.sol: -------------------------------------------------------------------------------- 1 | pragma solidity >=0.8.1; 2 | 3 | interface IWETH { 4 | function deposit() external payable; 5 | function transfer(address to, uint value) external returns (bool); 6 | function withdraw(uint) external; 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/defi/UniswapV3/v3-periphery/test/SelfPermitTest.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: UNLICENSED 2 | pragma solidity =0.7.6; 3 | 4 | import '../base/SelfPermit.sol'; 5 | 6 | /// @dev Same as SelfPermit but not abstract 7 | contract SelfPermitTest is SelfPermit { 8 | 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/import_library_inline/Foo.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.2; 4 | 5 | library Foo { 6 | string public constant name = "Foo"; 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/interpreter/Dummy.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.8.20; 4 | 5 | contract Dummy { 6 | fallback() external { 7 | assembly { 8 | return(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/invalid_signature/simple/callable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Callable { 6 | function f(uint a) public pure returns(uint) { 7 | return a * 2; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/invalid_signature/simple/icallable.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | interface ICallable { 6 | function f(uint a, bool x) external pure returns(uint); 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/delegatecall_call/B.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | import "./C.sol"; 6 | 7 | contract B { 8 | function main(C c) external returns (address) { 9 | return c.main(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/delegatecall_call/C.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | contract C { 6 | function main() external returns (address) { 7 | return msg.sender; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/delegatecall_delegatecall/C.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | contract C { 6 | function main() external returns (address) { 7 | return msg.sender; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/staticcall_call/B.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | import "./C.sol"; 6 | 7 | contract B { 8 | function main(C c) external { 9 | c.main(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/staticcall_call/C.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | contract C { 6 | uint256 value; 7 | 8 | function main() public { 9 | value += 1; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/nested_calls/staticcall_staticcall/C.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.5.0; 4 | 5 | contract C { 6 | uint256 value; 7 | 8 | function main() public { 9 | value += 1; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/enum/EnumDeclaration.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.0; 4 | // This is saved 'EnumDeclaration.sol' 5 | 6 | enum Status { 7 | Pending, 8 | Shipped, 9 | Accepted, 10 | Rejected, 11 | Canceled 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/enum/main.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.0; 4 | 5 | import "./EnumDeclaration.sol"; 6 | 7 | contract Enum { 8 | Status public status; 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/import/Foo.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.22; 4 | pragma experimental ABIEncoderV2; 5 | 6 | contract Foo { 7 | string public name = "Foo"; 8 | } -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/structs/StructDeclaration.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.0; 4 | 5 | struct Todo { 6 | string text; 7 | bool completed; 8 | } 9 | -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/structs/main.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.6.0; 4 | 5 | import "./StructDeclaration.sol"; 6 | 7 | contract Todos { 8 | // An array of 'Todo' structs 9 | Todo[] public todos; 10 | } 11 | -------------------------------------------------------------------------------- /solidity/complex/solidity_by_example/simple/structs/test.json: -------------------------------------------------------------------------------- 1 | { "modes": [ 2 | "Y >=0.8.1", 3 | "E", "I" 4 | ],"cases": [ { 5 | "name": "entry", 6 | "inputs": [ 7 | ], 8 | "expected": [ 9 | ] 10 | } ], 11 | "contracts": { 12 | "Todos": "main.sol:Todos" 13 | } 14 | } -------------------------------------------------------------------------------- /solidity/complex/sum_of_squares/square.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Square { 6 | function square(uint a) public pure returns(uint) { 7 | return a * a; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/value/delegatecall/TestContract.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT OR Apache-2.0 2 | 3 | pragma solidity ^0.8.0; 4 | 5 | contract TestContract { 6 | function value() public payable returns(uint256) { 7 | return msg.value; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/value/delegatecall_call/Third.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT OR Apache-2.0 2 | 3 | pragma solidity ^0.8.0; 4 | 5 | contract Third { 6 | function value() public payable returns(uint256) { 7 | return msg.value; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/value/delegatecall_delegatecall/Third.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT OR Apache-2.0 2 | 3 | pragma solidity ^0.8.0; 4 | 5 | contract Third { 6 | function value() public payable returns(uint256) { 7 | return msg.value; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/balance/other.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Other { 6 | fallback() external payable {} 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/caller_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract CallerTest { 6 | fallback() external { 7 | assembly { 8 | mstore(0, caller()) 9 | return(0, 32) 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/failure_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract FailureTest { 6 | fallback() external { 7 | assembly { 8 | revert(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/gas_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract GasTest { 6 | fallback() external { 7 | assembly { 8 | mstore(0, gas()) 9 | return(0, 32) 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/log_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract LogTest { 6 | fallback() external { 7 | assembly { 8 | log0(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/sload_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract SloadTest { 6 | fallback() external { 7 | assembly { 8 | mstore(0, sload(0)) 9 | return(0, 32) 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/call/sstore_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract SstoreTest { 6 | fallback() external { 7 | assembly { 8 | sstore(0, 0x42) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/create/value_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract ValueTest { 6 | constructor() public payable {} 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/create2/salt_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract SaltTest {} 6 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/create2/value_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract ValueTest { 6 | constructor() public payable {} 7 | } 8 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/delegatecall/failure_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract FailureTest { 6 | fallback() external { 7 | assembly { 8 | revert(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/delegatecall/gas_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract GasTest { 6 | fallback() external { 7 | assembly { 8 | mstore(0, gas()) 9 | return(0, 32) 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/delegatecall/log_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract LogTest { 6 | fallback() external { 7 | assembly { 8 | log0(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/delegatecall/sstore_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract SstoreTest { 6 | fallback() external { 7 | assembly { 8 | sstore(0, 0x42) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/extcodehash/other.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Other {} 6 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/extcodesize/other.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract Other {} 6 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/staticcall/failure_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract FailureTest { 6 | fallback() external { 7 | assembly { 8 | revert(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/staticcall/gas_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract GasTest { 6 | fallback() external { 7 | assembly { 8 | mstore(0, gas()) 9 | return(0, 32) 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/staticcall/log_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract LogTest { 6 | fallback() external { 7 | assembly { 8 | log0(0, 0) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/complex/yul_instructions/staticcall/sstore_test.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity >=0.4.16; 4 | 5 | contract SstoreTest { 6 | fallback() external { 7 | assembly { 8 | sstore(0, 0x42) 9 | } 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /solidity/ethereum/abiEncoderV1/abi_decode_trivial.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(bytes memory data) public pure returns (uint256) { 3 | return abi.decode(data, (uint256)); 4 | } 5 | } 6 | // ---- 7 | // f(bytes): 0x20, 0x20, 0x21 -> 33 8 | -------------------------------------------------------------------------------- /solidity/ethereum/abiEncoderV1/abi_encode_rational.sol: -------------------------------------------------------------------------------- 1 | // Tests that rational numbers (even negative ones) are encoded properly. 2 | contract C { 3 | function f() public pure returns (bytes memory) { 4 | return abi.encode(1, -2); 5 | } 6 | } 7 | // ---- 8 | // f() -> 0x20, 0x40, 0x1, -2 9 | -------------------------------------------------------------------------------- /solidity/ethereum/abiEncoderV2/calldata_array_short_no_revert_string.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint[] calldata) public {} 3 | } 4 | // ---- 5 | // f(uint256[]): 0x20, 0 -> 6 | // f(uint256[]): 0x20, 1 -> FAILURE 7 | // f(uint256[]): 0x20, 2 -> FAILURE 8 | 9 | -------------------------------------------------------------------------------- /solidity/ethereum/accessor/accessor_for_const_state_variable.sol: -------------------------------------------------------------------------------- 1 | contract Lotto { 2 | uint256 public constant ticketPrice = 555; 3 | } 4 | // ---- 5 | // ticketPrice() -> 555 6 | -------------------------------------------------------------------------------- /solidity/ethereum/accessor/accessor_for_state_variable.sol: -------------------------------------------------------------------------------- 1 | contract Lotto { 2 | uint256 public ticketPrice = 500; 3 | } 4 | // ---- 5 | // ticketPrice() -> 500 6 | -------------------------------------------------------------------------------- /solidity/ethereum/arithmetics/block_inside_unchecked.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint y) { 3 | unchecked{{ 4 | uint max = type(uint).max; 5 | uint x = max + 1; 6 | y = x; 7 | }} 8 | } 9 | } 10 | // ---- 11 | // f() -> 0x00 12 | -------------------------------------------------------------------------------- /solidity/ethereum/array/array_2d_new.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint n) public pure returns (uint) { 3 | uint[][] memory a = new uint[][](2); 4 | for (uint i = 0; i < 2; ++i) 5 | a[i] = new uint[](3); 6 | return a[0][0] = n; 7 | } 8 | } 9 | // ---- 10 | // f(uint256): 42 -> 42 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/array_storage_pop_zero_length.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint[] storageArray; 3 | function popEmpty() public { 4 | storageArray.pop(); 5 | } 6 | } 7 | // ==== 8 | // EVMVersion: >=petersburg 9 | // ---- 10 | // popEmpty() -> FAILURE, hex"4e487b71", 0x31 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/concat/bytes_concat_empty_argument_list.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes memory) { 3 | return bytes.concat(); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x20, 0 8 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/bytes_calldata_to_string_calldata.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(bytes calldata c) public returns (string calldata s) { 3 | return string(c); 4 | } 5 | } 6 | // ---- 7 | // f(bytes): 0x20, 3, "abc" -> 0x20, 3, "abc" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/bytes_memory_to_storage.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bytes s; 3 | function f() external returns (bytes1) { 4 | bytes memory data = "abcd"; 5 | s = data; 6 | return s[0]; 7 | } 8 | } 9 | // ---- 10 | // f() -> "a" 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/bytes_storage_to_memory.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bytes s = "abcd"; 3 | function f() external returns (bytes1) { 4 | bytes memory data = s; 5 | return data[0]; 6 | } 7 | } 8 | // ---- 9 | // f() -> "a" 10 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/calldata_array_static_to_memory.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint256[2] calldata c) public returns (uint256, uint256) { 3 | uint256[2] memory m1 = c; 4 | return (m1[0], m1[1]); 5 | } 6 | } 7 | // ---- 8 | // f(uint256[2]): 43, 57 -> 43, 57 9 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/calldata_bytes_to_storage.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bytes s; 3 | function f(bytes calldata data) external returns (bytes1) { 4 | s = data; 5 | return s[0]; 6 | } 7 | } 8 | // ---- 9 | // f(bytes): 0x20, 0x08, "abcdefgh" -> "a" 10 | -------------------------------------------------------------------------------- /solidity/ethereum/array/copying/string_calldata_to_bytes_calldata.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(string calldata s) public returns (bytes calldata m) { 3 | return bytes(s); 4 | } 5 | } 6 | // ---- 7 | // f(string): 0x20, 3, "abc" -> 0x20, 3, "abc" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/array/create_dynamic_array_with_zero_length.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256) { 3 | uint256[][] memory a = new uint256[][](0); 4 | return 7; 5 | } 6 | } 7 | // ---- 8 | // f() -> 7 9 | -------------------------------------------------------------------------------- /solidity/ethereum/array/create_memory_byte_array.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes1) { 3 | bytes memory x = new bytes(35); 4 | assert(x.length == 35); 5 | x[34] = "A"; 6 | return (x[34]); 7 | } 8 | } 9 | // ---- 10 | // f() -> "A" 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/fixed_bytes_length_access.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bytes1 a; 3 | 4 | function f(bytes32 x) public returns (uint256, uint256, uint256) { 5 | return (x.length, bytes16(uint128(2)).length, a.length + 7); 6 | } 7 | } 8 | // ---- 9 | // f(bytes32): "789" -> 32, 16, 8 10 | -------------------------------------------------------------------------------- /solidity/ethereum/array/indexAccess/inline_array_index_access_ints.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256) { 3 | return ([1, 2, 3, 4][2]); 4 | } 5 | } 6 | // ---- 7 | // f() -> 3 8 | -------------------------------------------------------------------------------- /solidity/ethereum/array/inline_array_singleton.sol: -------------------------------------------------------------------------------- 1 | // This caused a failure since the type was not converted to its mobile type. 2 | contract C { 3 | function f() public returns (uint256) { 4 | return [4][0]; 5 | } 6 | } 7 | // ---- 8 | // f() -> 4 9 | -------------------------------------------------------------------------------- /solidity/ethereum/array/pop/array_pop_empty_exception.sol: -------------------------------------------------------------------------------- 1 | contract c { 2 | uint256[] data; 3 | 4 | function test() public returns (bool) { 5 | data.pop(); 6 | return true; 7 | } 8 | } 9 | // ---- 10 | // test() -> FAILURE, hex"4e487b71", 0x31 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/pop/array_pop_storage_empty.sol: -------------------------------------------------------------------------------- 1 | contract c { 2 | uint[] data; 3 | function test() public { 4 | data.push(7); 5 | data.pop(); 6 | } 7 | } 8 | // ---- 9 | // test() -> 10 | // storageEmpty -> 1 11 | -------------------------------------------------------------------------------- /solidity/ethereum/array/pop/parenthesized.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | int[] data; 3 | function f() public returns (uint) { 4 | data.push(1); 5 | (data.pop)(); 6 | return data.length; 7 | } 8 | } 9 | // ---- 10 | // f() -> 0 11 | -------------------------------------------------------------------------------- /solidity/ethereum/builtinFunctions/blockhash_shadow_resolution.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function blockhash(uint256 blockNumber) public returns(bytes32) { bytes32 x; return x; } 3 | function f() public returns(bytes32) { return blockhash(3); } 4 | } 5 | // ---- 6 | // f() -> 0 7 | -------------------------------------------------------------------------------- /solidity/ethereum/builtinFunctions/keccak256_empty.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes32) { 3 | return keccak256(""); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 8 | -------------------------------------------------------------------------------- /solidity/ethereum/builtinFunctions/msg_sig.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function foo(uint256 a) public returns (bytes4 value) { 3 | return msg.sig; 4 | } 5 | } 6 | // ---- 7 | // foo(uint256): 0x0 -> 0x2fbebd3800000000000000000000000000000000000000000000000000000000 8 | -------------------------------------------------------------------------------- /solidity/ethereum/builtinFunctions/ripemd160_empty.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes20) { 3 | return ripemd160(""); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x9c1185a5c5e9fc54612808977ee8f548b2258d31000000000000000000000000 8 | -------------------------------------------------------------------------------- /solidity/ethereum/builtinFunctions/sha256_empty.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes32) { 3 | return sha256(""); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 8 | -------------------------------------------------------------------------------- /solidity/ethereum/calldata/calldata_bytes_to_memory.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(bytes calldata data) external returns (bytes32) { 3 | return keccak256(bytes(data)); 4 | } 5 | } 6 | // ---- 7 | // f(bytes): 0x20, 0x08, "abcdefgh" -> 0x48624fa43c68d5c552855a4e2919e74645f683f5384f72b5b051b71ea41d4f2d 8 | -------------------------------------------------------------------------------- /solidity/ethereum/cleanup/exp_cleanup.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint x) { 3 | unchecked { 4 | uint8 y = uint8(2)**uint8(8); 5 | return 0**y; 6 | } 7 | } 8 | } 9 | // ---- 10 | // f() -> 0x1 11 | -------------------------------------------------------------------------------- /solidity/ethereum/cleanup/exp_cleanup_direct.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint8 x) { 3 | unchecked { 4 | return uint8(0)**uint8(uint8(2)**uint8(8)); 5 | } 6 | } 7 | } 8 | // ---- 9 | // f() -> 0x1 10 | -------------------------------------------------------------------------------- /solidity/ethereum/cleanup/exp_cleanup_nonzero_base.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint8 x) { 3 | unchecked { 4 | uint16 x = 0x166; 5 | return uint8(x)**uint8(uint8(2)**uint8(8)); 6 | } 7 | } 8 | } 9 | // ---- 10 | // f() -> 0x1 11 | -------------------------------------------------------------------------------- /solidity/ethereum/constantEvaluator/negative_fractional_mod.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (int, int) { 3 | int x = int((-(-5.2 % 3)) * 5); 4 | int t = 5; 5 | return (x, (-(-t % 3)) * 5); 6 | } 7 | } 8 | // ---- 9 | // f() -> 11, 10 10 | -------------------------------------------------------------------------------- /solidity/ethereum/constants/asm_constant_file_level.sol: -------------------------------------------------------------------------------- 1 | address constant e = 0x1212121212121212121212121000002134593163; 2 | 3 | contract C { 4 | function f() public returns (address z) { 5 | assembly { z := e } 6 | } 7 | } 8 | // ---- 9 | // f() -> 0x1212121212121212121212121000002134593163 10 | -------------------------------------------------------------------------------- /solidity/ethereum/constants/constant_variables.sol: -------------------------------------------------------------------------------- 1 | contract Foo { 2 | uint256 constant x = 56; 3 | enum ActionChoices {GoLeft, GoRight, GoStraight, Sit} 4 | ActionChoices constant choices = ActionChoices.GoLeft; 5 | bytes32 constant st = "abc\x00\xff__"; 6 | } 7 | // ---- 8 | // constructor() -> 9 | -------------------------------------------------------------------------------- /solidity/ethereum/constants/simple_constant_variables_test.sol: -------------------------------------------------------------------------------- 1 | contract Foo { 2 | function getX() public returns (uint256 r) { 3 | return x; 4 | } 5 | 6 | uint256 constant x = 56; 7 | } 8 | // ---- 9 | // getX() -> 56 10 | -------------------------------------------------------------------------------- /solidity/ethereum/constructor/payable_constructor.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | constructor() payable {} 3 | } 4 | // ==== 5 | // bytecodeFormat: legacy,>=EOFv1 6 | // ---- 7 | // constructor(), 27 wei -> 8 | -------------------------------------------------------------------------------- /solidity/ethereum/constructor/state_variable_initialization.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint public i = 1; 3 | uint public k = 2; 4 | 5 | constructor() { 6 | i = i + i; 7 | k = k - i; 8 | } 9 | } 10 | // ---- 11 | // i() -> 2 12 | // k() -> 0 13 | -------------------------------------------------------------------------------- /solidity/ethereum/conversions/string_to_bytes.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(string memory s) public pure returns (bytes memory t) { 3 | t = bytes(s); 4 | } 5 | } 6 | // ---- 7 | // f(string): 32, 5, "Hello" -> 32, 5, "Hello" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/enums/constructing_enums_from_ints.sol: -------------------------------------------------------------------------------- 1 | contract c { 2 | enum Truth {False, True} 3 | 4 | function test() public returns (uint256) { 5 | return uint256(Truth(uint8(0x1))); 6 | } 7 | } 8 | // ---- 9 | // test() -> 1 10 | -------------------------------------------------------------------------------- /solidity/ethereum/enums/minmax.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | enum MinMax { A, B, C, D } 3 | 4 | function min() public returns(uint) { return uint(type(MinMax).min); } 5 | function max() public returns(uint) { return uint(type(MinMax).max); } 6 | } 7 | // ---- 8 | // min() -> 0 9 | // max() -> 3 10 | -------------------------------------------------------------------------------- /solidity/ethereum/enums/using_contract_enums_with_explicit_contract_name.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | enum Choice {A, B, C} 3 | 4 | function answer() public returns (test.Choice _ret) { 5 | _ret = test.Choice.B; 6 | } 7 | } 8 | // ---- 9 | // answer() -> 1 10 | -------------------------------------------------------------------------------- /solidity/ethereum/enums/using_inherited_enum.sol: -------------------------------------------------------------------------------- 1 | contract base { 2 | enum Choice {A, B, C} 3 | } 4 | 5 | 6 | contract test is base { 7 | function answer() public returns (Choice _ret) { 8 | _ret = Choice.B; 9 | } 10 | } 11 | // ---- 12 | // answer() -> 1 13 | -------------------------------------------------------------------------------- /solidity/ethereum/enums/using_inherited_enum_excplicitly.sol: -------------------------------------------------------------------------------- 1 | contract base { 2 | enum Choice {A, B, C} 3 | } 4 | 5 | 6 | contract test is base { 7 | function answer() public returns (base.Choice _ret) { 8 | _ret = base.Choice.B; 9 | } 10 | } 11 | // ---- 12 | // answer() -> 1 13 | -------------------------------------------------------------------------------- /solidity/ethereum/errors/revert_conversion.sol: -------------------------------------------------------------------------------- 1 | error E(string a, uint[] b); 2 | contract C { 3 | uint[] x; 4 | function f() public { 5 | x.push(7); 6 | revert E("abc", x); 7 | } 8 | } 9 | // ---- 10 | // f() -> FAILURE, hex"59e4d4df", 0x40, 0x80, 3, "abc", 1, 7 11 | -------------------------------------------------------------------------------- /solidity/ethereum/errors/simple.sol: -------------------------------------------------------------------------------- 1 | error E(uint a, uint b); 2 | contract C { 3 | function f() public pure { 4 | revert E(2, 7); 5 | } 6 | } 7 | // ---- 8 | // f() -> FAILURE, hex"85208890", 2, 7 9 | -------------------------------------------------------------------------------- /solidity/ethereum/errors/weird_name.sol: -------------------------------------------------------------------------------- 1 | error error(uint a); 2 | contract C { 3 | function f() public pure { 4 | revert error(2); 5 | } 6 | } 7 | // ---- 8 | // f() -> FAILURE, hex"b48fb6cf", hex"0000000000000000000000000000000000000000000000000000000000000002" 9 | -------------------------------------------------------------------------------- /solidity/ethereum/events/emit_two_identical_events.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | event Terminated(); 3 | 4 | function terminate() external { 5 | emit Terminated(); 6 | emit Terminated(); 7 | } 8 | } 9 | // ---- 10 | // terminate() -> 11 | // ~ emit Terminated() 12 | // ~ emit Terminated() -------------------------------------------------------------------------------- /solidity/ethereum/events/event_access_through_base_name_emit.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | event x(); 3 | } 4 | contract B is A { 5 | function f() public returns (uint) { 6 | emit A.x(); 7 | return 1; 8 | } 9 | } 10 | // ---- 11 | // f() -> 1 12 | // ~ emit x() 13 | -------------------------------------------------------------------------------- /solidity/ethereum/events/event_anonymous.sol: -------------------------------------------------------------------------------- 1 | contract ClientReceipt { 2 | event Deposit() anonymous; 3 | function deposit() public { 4 | emit Deposit(); 5 | } 6 | } 7 | // ---- 8 | // deposit() -> 9 | // ~ emit 10 | -------------------------------------------------------------------------------- /solidity/ethereum/events/event_emit_from_a_foreign_contract.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | event E(); 3 | } 4 | 5 | contract D { 6 | function test() public { 7 | emit C.E(); 8 | } 9 | } 10 | 11 | // ---- 12 | // test() -> 13 | // ~ emit E() 14 | -------------------------------------------------------------------------------- /solidity/ethereum/events/event_indexed_function.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | event Test(function() external indexed); 3 | function f() public { 4 | emit Test(C(address(0x1234)).f); 5 | } 6 | } 7 | // ---- 8 | // f() -> 9 | // ~ emit Test(function): #0x123426121ff00000000000000000 10 | -------------------------------------------------------------------------------- /solidity/ethereum/events/event_no_arguments.sol: -------------------------------------------------------------------------------- 1 | contract ClientReceipt { 2 | event Deposit(); 3 | function deposit() public { 4 | emit Deposit(); 5 | } 6 | } 7 | // ---- 8 | // deposit() -> 9 | // ~ emit Deposit() 10 | -------------------------------------------------------------------------------- /solidity/ethereum/events/event_string.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | event E(string r); 3 | function deposit() public { 4 | emit E("HELLO WORLD"); 5 | } 6 | } 7 | // ---- 8 | // deposit() -> 9 | // ~ emit E(string): 0x20, 0x0b, "HELLO WORLD" 10 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/bytes_comparison.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns (bool) { 3 | bytes2 a = "a"; 4 | bytes2 x = "aa"; 5 | bytes2 b = "b"; 6 | return a < x && x < b; 7 | } 8 | } 9 | // ---- 10 | // f() -> true 11 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/conditional_expression_false_literal.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(uint d) { 3 | return false ? 5 : 10; 4 | } 5 | } 6 | // ---- 7 | // f() -> 10 8 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/conditional_expression_true_literal.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(uint d) { 3 | return true ? 5 : 10; 4 | } 5 | } 6 | // ---- 7 | // f() -> 5 8 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/conditional_expression_tuples.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f(bool cond) public returns (uint, uint) { 3 | return cond ? (1, 2) : (3, 4); 4 | } 5 | } 6 | // ---- 7 | // f(bool): true -> 1, 2 8 | // f(bool): false -> 3, 4 9 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/exp_operator_const.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(uint d) { return 2 ** 3; } 3 | } 4 | // ---- 5 | // f() -> 8 6 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/exp_operator_const_signed.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(int d) { return (-2) ** 3; } 3 | } 4 | // ---- 5 | // f() -> -8 6 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/exp_zero_literal.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(uint d) { return 0 ** 0; } 3 | } 4 | // ---- 5 | // f() -> 1 6 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/tuple_from_ternary_expression.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (bool){ 3 | bool flag; 4 | ((flag = true) ? (1, 2, 3) : (3, 2, 1)); 5 | return flag; 6 | } 7 | } 8 | // ---- 9 | // f() -> true 10 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/unary_too_long_literal.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bool) { 3 | return 4 | 0 < 5 | ~~84926290883049832306107864558384249403874903260938453235235091622489261765859; 6 | } 7 | } 8 | // ---- 9 | // f() -> true 10 | -------------------------------------------------------------------------------- /solidity/ethereum/expressions/uncalled_address_transfer_send.sol: -------------------------------------------------------------------------------- 1 | contract TransferTest { 2 | fallback() external payable { 3 | // This used to cause an ICE 4 | payable(this).transfer; 5 | } 6 | 7 | function f() pure public {} 8 | } 9 | // ---- 10 | // f() -> 11 | -------------------------------------------------------------------------------- /solidity/ethereum/externalContracts/_prbmath/LICENSE.md: -------------------------------------------------------------------------------- 1 | # WTFPL 2 | 3 | by Paul Razvan Berg (@PaulRBerg) 4 | 5 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 6 | 7 | 0. You just DO WHAT THE FUCK YOU WANT TO. 8 | -------------------------------------------------------------------------------- /solidity/ethereum/externalContracts/_prbmath/README.md: -------------------------------------------------------------------------------- 1 | Imported from https://github.com/hifi-finance/prb-math/commit/62021c1abc3413f20d0bdc8f941cf9f21d5a7d2d 2 | -------------------------------------------------------------------------------- /solidity/ethereum/externalContracts/_stringutils/README.md: -------------------------------------------------------------------------------- 1 | String utilities, originally from 2 | 3 | https://github.com/Arachnid/solidity-stringutils 4 | 5 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/external.sol: -------------------------------------------------------------------------------- 1 | contract External { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/external.sol=sol: -------------------------------------------------------------------------------- 1 | contract External { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/import.sol: -------------------------------------------------------------------------------- 1 | import "external.sol"; 2 | import "other_external.sol"; 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/import_with_subdir.sol: -------------------------------------------------------------------------------- 1 | import "subdir/import.sol"; 2 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/other_external.sol: -------------------------------------------------------------------------------- 1 | contract OtherExternal { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/subdir/import.sol: -------------------------------------------------------------------------------- 1 | import "sub_external.sol"; 2 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_external/subdir/sub_external.sol: -------------------------------------------------------------------------------- 1 | contract SubExternal { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_nonNormalizedPaths/a.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_nonNormalizedPaths/c.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_nonNormalizedPaths/d.sol: -------------------------------------------------------------------------------- 1 | contract D { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/D/d.sol: -------------------------------------------------------------------------------- 1 | contract D { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/c.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/dir/B/b.sol: -------------------------------------------------------------------------------- 1 | import {C} from "../../c.sol"; 2 | contract B { 3 | } 4 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/dir/G/g.sol: -------------------------------------------------------------------------------- 1 | import {B} from "../B/b.sol"; 2 | contract G { 3 | } 4 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/dir/a.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_relativeImports/h.sol: -------------------------------------------------------------------------------- 1 | contract H { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_sourceNameStartingWithDots/b.sol: -------------------------------------------------------------------------------- 1 | contract B { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_sourceNameStartingWithDots/dir/a.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_sourceNameStartingWithDots/dir/contract.sol: -------------------------------------------------------------------------------- 1 | import {A} from "./a.sol"; 2 | import {B} from "../b.sol"; 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_sourceNameStartingWithDots/dot_a.sol: -------------------------------------------------------------------------------- 1 | contract Dot_A { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/_sourceNameStartingWithDots/dot_dot_b.sol: -------------------------------------------------------------------------------- 1 | contract Dot_Dot_B { 2 | } 3 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/multiple_equals_signs.sol: -------------------------------------------------------------------------------- 1 | ==== ExternalSource: a=_external/external.sol=sol ==== 2 | import {External} from "a"; 3 | contract C { 4 | } 5 | // ---- 6 | // constructor() 7 | -------------------------------------------------------------------------------- /solidity/ethereum/externalSource/source.sol: -------------------------------------------------------------------------------- 1 | ==== ExternalSource: _external/external.sol ==== 2 | import {External} from "_external/external.sol"; 3 | contract C { 4 | } 5 | // ---- 6 | // constructor() 7 | -------------------------------------------------------------------------------- /solidity/ethereum/fallback/inherited.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint data; 3 | fallback() external { data = 1; } 4 | function getData() public returns (uint r) { return data; } 5 | } 6 | contract B is A {} 7 | // ---- 8 | // getData() -> 0 9 | // (): 42 -> 10 | // getData() -> 1 11 | -------------------------------------------------------------------------------- /solidity/ethereum/freeFunctions/easy.sol: -------------------------------------------------------------------------------- 1 | function add(uint a, uint b) pure returns (uint) { 2 | return a + b; 3 | } 4 | 5 | contract C { 6 | function f(uint x) public pure returns (uint) { 7 | return add(x, 2); 8 | } 9 | } 10 | // ---- 11 | // f(uint256): 7 -> 9 12 | -------------------------------------------------------------------------------- /solidity/ethereum/freeFunctions/free_namesake_contract_function.sol: -------------------------------------------------------------------------------- 1 | function f() pure returns (uint) { return 1337; } 2 | contract C { 3 | function f() public pure returns (uint) { 4 | return f(); 5 | } 6 | } 7 | // ---- 8 | // f() -> FAILURE 9 | -------------------------------------------------------------------------------- /solidity/ethereum/functionCall/disordered_named_args.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function a(uint a, uint b, uint c) public returns (uint r) { r = a * 100 + b * 10 + c * 1; } 3 | function b() public returns (uint r) { r = a({c: 3, a: 1, b: 2}); } 4 | } 5 | // ---- 6 | // b() -> 123 7 | -------------------------------------------------------------------------------- /solidity/ethereum/functionCall/multiple_return_values.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function run(bool x1, uint x2) public returns(uint y1, bool y2, uint y3) { 3 | y1 = x2; y2 = x1; 4 | } 5 | } 6 | // ---- 7 | // run(bool,uint256): true, 0xcd -> 0xcd, true, 0 8 | -------------------------------------------------------------------------------- /solidity/ethereum/functionCall/transaction_status.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public { } 3 | function g() public { revert(); } 4 | function h() public { assert(false); } 5 | } 6 | // ---- 7 | // f() -> 8 | // g() -> FAILURE 9 | // h() -> FAILURE, hex"4e487b71", 0x01 10 | -------------------------------------------------------------------------------- /solidity/ethereum/functionCall/value_test.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public payable returns (uint) { 3 | return msg.value; 4 | } 5 | } 6 | // ---- 7 | // f(), 1 ether -> 1000000000000000000 8 | // f(), 1 wei -> 1 9 | -------------------------------------------------------------------------------- /solidity/ethereum/functionTypes/duplicated_function_definition_with_same_id_in_internal_dispatcher.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function a() internal {} 3 | function f() public { 4 | function() ptr1 = a; 5 | function() ptr2 = a; 6 | } 7 | } 8 | // ---- 9 | // f() 10 | -------------------------------------------------------------------------------- /solidity/ethereum/functionTypes/selector_assignment_expression.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bool public z; 3 | function f() public { 4 | ((z = true) ? this.f : this.f).selector; 5 | } 6 | } 7 | 8 | // ---- 9 | // f() 10 | // z() -> true 11 | -------------------------------------------------------------------------------- /solidity/ethereum/functionTypes/uninitialized_internal_storage_function_call.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function() internal x; 3 | 4 | function f() public returns (uint256 r) { 5 | x(); 6 | return 2; 7 | } 8 | } 9 | // ---- 10 | // f() -> FAILURE, hex"4e487b71", 0x51 11 | -------------------------------------------------------------------------------- /solidity/ethereum/getters/bytes.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | bytes public b; 3 | constructor() { 4 | b = "abc"; 5 | } 6 | } 7 | // ---- 8 | // b() -> 0x20, 0x03, 0x6162630000000000000000000000000000000000000000000000000000000000 9 | -------------------------------------------------------------------------------- /solidity/ethereum/getters/mapping.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | mapping(uint => mapping(uint => uint)) public x; 3 | constructor() { 4 | x[1][2] = 3; 5 | } 6 | } 7 | // ---- 8 | // x(uint256,uint256): 1, 2 -> 3 9 | // x(uint256,uint256): 0, 0 -> 0 10 | -------------------------------------------------------------------------------- /solidity/ethereum/getters/mapping_with_names.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | mapping(uint a => mapping(uint b => uint c)) public x; 3 | constructor() { 4 | x[1][2] = 3; 5 | } 6 | } 7 | // ---- 8 | // x(uint256,uint256): 1, 2 -> 3 9 | // x(uint256,uint256): 0, 0 -> 0 10 | -------------------------------------------------------------------------------- /solidity/ethereum/immutable/assign_at_declaration.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint8 immutable a = 2; 3 | function f() public view returns (uint) { 4 | return a; 5 | } 6 | } 7 | // ---- 8 | // f() -> 2 9 | -------------------------------------------------------------------------------- /solidity/ethereum/immutable/getter.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint immutable public x = 1; 3 | } 4 | // ---- 5 | // x() -> 1 6 | -------------------------------------------------------------------------------- /solidity/ethereum/immutable/read_in_ctor.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint8 immutable a; 3 | uint8 x; 4 | 5 | constructor() { 6 | a = 3; 7 | x = a; 8 | } 9 | 10 | function readX() public view returns (uint8) { 11 | return x; 12 | } 13 | } 14 | // ---- 15 | // readX() -> 3 16 | -------------------------------------------------------------------------------- /solidity/ethereum/immutable/uninitialized.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint immutable u; 3 | bool immutable b; 4 | address immutable a; 5 | 6 | function get() public returns (uint, bool, address) { 7 | return (u, b, a); 8 | } 9 | } 10 | // ---- 11 | // get() -> 0, false, 0x0 12 | -------------------------------------------------------------------------------- /solidity/ethereum/inheritance/inherited_constant_state_var.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint256 constant x = 7; 3 | } 4 | 5 | 6 | contract B is A { 7 | function f() public returns (uint256) { 8 | return A.x; 9 | } 10 | } 11 | // ---- 12 | // f() -> 7 13 | -------------------------------------------------------------------------------- /solidity/ethereum/inheritance/state_variables_init_order.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint public x = 0; 3 | uint y = f(); 4 | function f() public returns (uint256) { 5 | ++x; 6 | return 42; 7 | } 8 | } 9 | contract B is A { 10 | } 11 | // ---- 12 | // x() -> 1 13 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/calldata_array_assign_static.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint[2][2] calldata x) public returns (uint[2][2] memory r) { 3 | assembly { x := 0x24 } 4 | r = x; 5 | } 6 | } 7 | // ---- 8 | // f(uint256[2][2]): 0x0, 8, 7, 6, 5 -> 8, 7, 6, 5 9 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/chainid.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint id) { 3 | assembly { 4 | id := chainid() 5 | } 6 | } 7 | } 8 | // ==== 9 | // EVMVersion: >=istanbul 10 | // ---- 11 | // f() -> 280 12 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/difficulty.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public view returns (uint ret) { 3 | assembly { 4 | ret := difficulty() 5 | } 6 | } 7 | } 8 | // ==== 9 | // EVMVersion: 2500000000000000 12 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/external_identifier_access_shadowing.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint x) { 3 | assembly { 4 | function g() -> f { f := 2 } 5 | x := g() 6 | } 7 | } 8 | } 9 | // ---- 10 | // f() -> 2 11 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/inline_assembly_write_to_stack.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256 r, bytes32 r2) { 3 | assembly { 4 | r := 7 5 | r2 := "abcdef" 6 | } 7 | } 8 | } 9 | // ---- 10 | // f() -> 7, "abcdef" 11 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/inlineasm_empty_let.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint a, uint b) { 3 | assembly { 4 | let x 5 | let y, z 6 | a := x 7 | b := z 8 | } 9 | } 10 | } 11 | // ---- 12 | // f() -> 0, 0 13 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/prevrandao.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public view returns (uint ret) { 3 | assembly { 4 | ret := prevrandao() 5 | } 6 | } 7 | } 8 | // ==== 9 | // EVMVersion: >=paris 10 | // ---- 11 | // f() -> 2500000000000000 12 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/selfbalance.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public payable returns (uint ret) { 3 | assembly { 4 | ret := selfbalance() 5 | } 6 | } 7 | } 8 | // ==== 9 | // EVMVersion: >=istanbul 10 | // ---- 11 | // f(), 254 wei -> 254 12 | -------------------------------------------------------------------------------- /solidity/ethereum/inlineAssembly/truefalse.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint x, uint y) { 3 | assembly { 4 | x := true 5 | y := false 6 | } 7 | } 8 | } 9 | // ---- 10 | // f() -> 1, 0 11 | -------------------------------------------------------------------------------- /solidity/ethereum/integer/small_signed_types.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function run() public returns(int256 y) { 3 | return -int32(10) * -int64(20); 4 | } 5 | } 6 | // ---- 7 | // run() -> 200 8 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/balance_with_balance.sol: -------------------------------------------------------------------------------- 1 | contract ClientReceipt { 2 | constructor() payable {} 3 | } 4 | // ---- 5 | // constructor(), 1000 wei -> 6 | // balance -> 1000 7 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/balance_with_balance2.sol: -------------------------------------------------------------------------------- 1 | contract ClientReceipt { 2 | constructor() payable {} 3 | } 4 | // ---- 5 | // constructor(), 1 ether -> 6 | // balance -> 1000000000000000000 7 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/balance_without_balance.sol: -------------------------------------------------------------------------------- 1 | contract ClientReceipt { 2 | } 3 | // ---- 4 | // balance -> 0 5 | // balance: 0x0000000000000000000000000000000000000000 -> 0 6 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/builtins.sol: -------------------------------------------------------------------------------- 1 | contract SmokeTest { 2 | } 3 | // ---- 4 | // isoltest_builtin_test -> 0x1234 5 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/empty_contract.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | } 3 | // ==== 4 | // allowNonExistingFunctions: true 5 | // ---- 6 | // i_am_not_there() -> FAILURE 7 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/storage/storage_empty.sol: -------------------------------------------------------------------------------- 1 | contract StorageEmpty { 2 | } 3 | // ---- 4 | // storageEmpty -> 1 5 | -------------------------------------------------------------------------------- /solidity/ethereum/isoltestTesting/storage/storage_nonempty.sol: -------------------------------------------------------------------------------- 1 | contract StorageNotEmpty { 2 | uint256 x; 3 | function set(uint256 _a) public { x = _a; } 4 | } 5 | // ---- 6 | // storageEmpty -> 1 7 | // set(uint256): 1 -> 8 | // storageEmpty -> 0 9 | -------------------------------------------------------------------------------- /solidity/ethereum/libraries/internal_call_unattached_with_parentheses.sol: -------------------------------------------------------------------------------- 1 | library L { 2 | function f() internal returns (uint) { 3 | return 3; 4 | } 5 | } 6 | 7 | contract C { 8 | function foo() public returns (uint) { 9 | return (L.f)(); 10 | } 11 | } 12 | // ---- 13 | // foo() -> 3 14 | -------------------------------------------------------------------------------- /solidity/ethereum/libraries/library_enum_as_an_expression.sol: -------------------------------------------------------------------------------- 1 | library Arst { 2 | enum Foo {Things, Stuff} 3 | } 4 | 5 | 6 | contract Tsra { 7 | function f() public returns (uint256) { 8 | Arst.Foo; 9 | return 1; 10 | } 11 | } 12 | // ---- 13 | // f() -> 1 14 | -------------------------------------------------------------------------------- /solidity/ethereum/literals/denominations.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint constant x = 1 ether + 1 gwei + 1 wei; 3 | 4 | function f() public view returns(uint) { return x; } 5 | } 6 | // ---- 7 | // f() -> 1000000001000000001 8 | -------------------------------------------------------------------------------- /solidity/ethereum/literals/ether.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint constant x = 1 ether; 3 | 4 | function f() public view returns(uint) { return x; } 5 | } 6 | // ---- 7 | // f() -> 1000000000000000000 8 | -------------------------------------------------------------------------------- /solidity/ethereum/literals/gwei.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint constant x = 1 gwei; 3 | 4 | function f() public view returns(uint) { return x; } 5 | } 6 | // ---- 7 | // f() -> 1000000000 8 | -------------------------------------------------------------------------------- /solidity/ethereum/literals/hex_string_with_underscore.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns(bytes memory) { 3 | return hex"12_34_5678_9A"; 4 | } 5 | } 6 | // ---- 7 | // f() -> 32, 5, left(0x123456789A) 8 | -------------------------------------------------------------------------------- /solidity/ethereum/literals/wei.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint constant x = 1 wei; 3 | 4 | function f() public view returns(uint) { return x; } 5 | } 6 | // ---- 7 | // f() -> 1 8 | -------------------------------------------------------------------------------- /solidity/ethereum/modifiers/modifier_in_constructor_ice.sol: -------------------------------------------------------------------------------- 1 | // The IR of this contract used to throw 2 | contract A { modifier m1{_;} } 3 | contract B is A { constructor() A() m1{} } 4 | // ---- 5 | // constructor() -> 6 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_cleanup_garbled.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint8 x) { 3 | assembly { 4 | x := 0xffff 5 | } 6 | x >>= 8; 7 | } 8 | } 9 | // ---- 10 | // f() -> 0x0 11 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_constant_left.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint256 public a = 0x42 << 8; 3 | } 4 | // ---- 5 | // a() -> 0x4200 6 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_constant_left_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256 a) { 3 | a = 0x42; 4 | a <<= 8; 5 | } 6 | } 7 | // ---- 8 | // f() -> 0x4200 9 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_constant_right.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint256 public a = 0x4200 >> 8; 3 | } 4 | // ---- 5 | // a() -> 0x42 6 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_constant_right_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256 a) { 3 | a = 0x4200; 4 | a >>= 8; 5 | } 6 | } 7 | // ---- 8 | // f() -> 0x42 9 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_left_uint8.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint8 a, uint8 b) public returns (uint256) { 3 | return a << b; 4 | } 5 | } 6 | // ---- 7 | // f(uint8,uint8): 0x66, 0x0 -> 0x66 8 | // f(uint8,uint8): 0x66, 0x8 -> 0 9 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_negative_constant_left.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | int256 public a = -0x42 << 8; 3 | } 4 | // ---- 5 | // a() -> -16896 6 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_negative_constant_right.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | int256 public a = -0x4200 >> 8; 3 | } 4 | // ---- 5 | // a() -> -66 6 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shift_right_uint8.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint8 a, uint8 b) public returns (uint256) { 3 | return a >> b; 4 | } 5 | } 6 | // ---- 7 | // f(uint8,uint8): 0x66, 0x0 -> 0x66 8 | // f(uint8,uint8): 0x66, 0x8 -> 0x0 9 | -------------------------------------------------------------------------------- /solidity/ethereum/operators/shifts/shifts.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint x) public returns (uint y) { 3 | assembly { y := shl(2, x) } 4 | } 5 | } 6 | // ==== 7 | // EVMVersion: >=constantinople 8 | // ---- 9 | // f(uint256): 7 -> 28 10 | -------------------------------------------------------------------------------- /solidity/ethereum/receive/ether_and_data.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | receive () payable external { } 3 | } 4 | // ---- 5 | // (), 1 ether 6 | // (), 1 ether: 1 -> FAILURE 7 | -------------------------------------------------------------------------------- /solidity/ethereum/revertStrings/ether_non_payable_function.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public {} 3 | } 4 | // ==== 5 | // EVMVersion: >=byzantium 6 | // revertStrings: debug 7 | // ---- 8 | // f(), 1 ether -> FAILURE 9 | // () -> FAILURE 10 | -------------------------------------------------------------------------------- /solidity/ethereum/revertStrings/function_entry_checks_v2.sol: -------------------------------------------------------------------------------- 1 | pragma abicoder v2; 2 | contract C { 3 | function t(uint) public pure {} 4 | } 5 | // ==== 6 | // EVMVersion: >=byzantium 7 | // revertStrings: debug 8 | // ---- 9 | // t(uint256) -> FAILURE 10 | -------------------------------------------------------------------------------- /solidity/ethereum/revertStrings/unknown_sig_no_fallback.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | receive () external payable {} 3 | } 4 | // ==== 5 | // EVMVersion: >=byzantium 6 | // revertStrings: debug 7 | // ---- 8 | // (): hex"00" -> FAILURE 9 | -------------------------------------------------------------------------------- /solidity/ethereum/reverts/invalid_instruction.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public { 3 | assembly { 4 | invalid() 5 | } 6 | } 7 | } 8 | // ---- 9 | // f() -> FAILURE 10 | -------------------------------------------------------------------------------- /solidity/ethereum/reverts/simple_throw.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function f(uint256 x) public returns (uint256) { 3 | if (x > 10) return x + 10; 4 | else revert(); 5 | return 2; 6 | } 7 | } 8 | // ---- 9 | // f(uint256): 11 -> 21 10 | // f(uint256): 1 -> FAILURE 11 | -------------------------------------------------------------------------------- /solidity/ethereum/shanghai/push0.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function zero() external returns (uint) { 3 | return 0; 4 | } 5 | 6 | } 7 | // ==== 8 | // compileViaYul: also 9 | // EVMVersion: >=shanghai 10 | // ---- 11 | // zero() -> 0 12 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_chainid.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint) { 3 | return block.chainid; 4 | } 5 | } 6 | // ==== 7 | // EVMVersion: >=istanbul 8 | // ---- 9 | // f() -> 280 10 | // f() -> 280 11 | // f() -> 280 12 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_gaslimit.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint) { 3 | return block.gaslimit; 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x40000000 8 | // f() -> 0x40000000 9 | // f() -> 0x40000000 10 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_number.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | constructor() {} 3 | function f() public returns (uint) { 4 | return block.number; 5 | } 6 | } 7 | // ---- 8 | // constructor() 9 | // f() -> 2 10 | // f() -> 2 11 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_prevrandao.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public view returns (uint) { 3 | return block.prevrandao; 4 | } 5 | } 6 | // ==== 7 | // EVMVersion: >=paris 8 | // ---- 9 | // f() -> 2500000000000000 10 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_prevrandao_pre_paris.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public view returns (uint) { 3 | return block.prevrandao; 4 | } 5 | } 6 | // ==== 7 | // EVMVersion: 2500000000000000 10 | -------------------------------------------------------------------------------- /solidity/ethereum/state/block_timestamp.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | constructor() {} 3 | function f() public returns (uint) { 4 | return block.timestamp; 5 | } 6 | } 7 | // ---- 8 | // constructor() 9 | // f() -> 0xdeadbeef 10 | // f() -> 0xdeadbeef 11 | -------------------------------------------------------------------------------- /solidity/ethereum/state/gasleft.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bool) { 3 | return gasleft() > 0; 4 | } 5 | } 6 | // ==== 7 | // bytecodeFormat: legacy 8 | // ---- 9 | // f() -> true 10 | // f() -> true 11 | // f() -> true 12 | -------------------------------------------------------------------------------- /solidity/ethereum/state/msg_sender.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (address) { 3 | return msg.sender; 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x1212121212121212121212121212120000000012 8 | -------------------------------------------------------------------------------- /solidity/ethereum/state/msg_value.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public payable returns (uint) { 3 | return msg.value; 4 | } 5 | } 6 | // ---- 7 | // f() -> 0 8 | // f(), 12 ether -> 12000000000000000000 9 | -------------------------------------------------------------------------------- /solidity/ethereum/state/tx_gasprice.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint) { 3 | return tx.gasprice; 4 | } 5 | } 6 | // ---- 7 | // f() -> 3000000000 8 | // f() -> 3000000000 9 | // f() -> 3000000000 10 | -------------------------------------------------------------------------------- /solidity/ethereum/state/uncalled_blockhash.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes32) { 3 | return (blockhash)(block.number - 1); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x3737373737373737373737373737373737373737373737373737373737373738 8 | -------------------------------------------------------------------------------- /solidity/ethereum/statements/empty_for_loop.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns(uint ret) { 3 | ret = 1; 4 | for (;;) { 5 | ret += 1; 6 | if (ret >= 10) break; 7 | } 8 | } 9 | } 10 | // ---- 11 | // f() -> 10 12 | -------------------------------------------------------------------------------- /solidity/ethereum/storage/simple_accessor.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | uint256 public data; 3 | constructor() { 4 | data = 8; 5 | } 6 | } 7 | // ---- 8 | // data() -> 8 9 | -------------------------------------------------------------------------------- /solidity/ethereum/storageLayoutSpecifier/base_slot_max_value.sol: -------------------------------------------------------------------------------- 1 | contract C layout at 2**256 - 1 { 2 | function f(uint a) public pure returns (uint) { 3 | return a * 2; 4 | } 5 | } 6 | // ---- 7 | // f(uint256): 4 -> 8 8 | -------------------------------------------------------------------------------- /solidity/ethereum/storageLayoutSpecifier/getters.sol: -------------------------------------------------------------------------------- 1 | contract C layout at 7 { 2 | uint public x = 1; 3 | int8 public y = 2; 4 | uint32 public z = 3; 5 | } 6 | // ---- 7 | // x() -> 1 8 | // y() -> 2 9 | // z() -> 3 10 | -------------------------------------------------------------------------------- /solidity/ethereum/storageLayoutSpecifier/last_allowed_storage_slot.sol: -------------------------------------------------------------------------------- 1 | contract C layout at 2**256 - 2 { 2 | uint public x; 3 | function f(uint a) public returns (uint) { 4 | x = a * 2; 5 | return x; 6 | } 7 | } 8 | // ---- 9 | // f(uint256): 4 -> 8 10 | // x() -> 8 11 | -------------------------------------------------------------------------------- /solidity/ethereum/strings/concat/string_concat_empty_argument_list.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (string memory) { 3 | return string.concat(); 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x20, 0 8 | -------------------------------------------------------------------------------- /solidity/ethereum/strings/empty_string.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (string memory) { 3 | return ""; 4 | } 5 | } 6 | // ---- 7 | // f() -> 0x20, 0 8 | -------------------------------------------------------------------------------- /solidity/ethereum/structs/simple_struct_allocation.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | struct S { 3 | uint a; 4 | } 5 | 6 | function f() external returns (uint) { 7 | S memory s = S(1); 8 | return s.a; 9 | } 10 | } 11 | // ---- 12 | // f() -> 1 13 | -------------------------------------------------------------------------------- /solidity/ethereum/structs/struct_named_constructor.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | struct S { 3 | uint256 a; 4 | bool x; 5 | } 6 | S public s; 7 | 8 | constructor() { 9 | s = S({x: true, a: 1}); 10 | } 11 | } 12 | // ---- 13 | // s() -> 1, true 14 | -------------------------------------------------------------------------------- /solidity/ethereum/types/assign_calldata_value_type.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint256 x) public pure returns (uint256, uint256) { 3 | uint256 b = x; 4 | x = 42; 5 | return (x, b); 6 | } 7 | } 8 | // ---- 9 | // f(uint256): 23 -> 42, 23 10 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_fixed_bytes_greater_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToBytes(bytes2 input) public returns (bytes4 ret) { 3 | return bytes4(input); 4 | } 5 | } 6 | // ---- 7 | // bytesToBytes(bytes2): "ab" -> "ab" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_fixed_bytes_same_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToBytes(bytes4 input) public returns (bytes4 ret) { 3 | return bytes4(input); 4 | } 5 | } 6 | // ---- 7 | // bytesToBytes(bytes4): "abcd" -> "abcd" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_fixed_bytes_smaller_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToBytes(bytes4 input) public returns (bytes2 ret) { 3 | return bytes2(input); 4 | } 5 | } 6 | // ---- 7 | // bytesToBytes(bytes4): "abcd" -> "ab" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_uint_greater_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToUint(bytes4 s) public returns (uint64 h) { 3 | return uint64(uint32(s)); 4 | } 5 | } 6 | // ---- 7 | // bytesToUint(bytes4): "abcd" -> 0x61626364 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_uint_same_min_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToUint(bytes1 s) public returns (uint8 h) { 3 | return uint8(s); 4 | } 5 | } 6 | // ---- 7 | // bytesToUint(bytes1): "a" -> 0x61 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_uint_same_type.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToUint(bytes32 s) public returns (uint256 h) { 3 | return uint(s); 4 | } 5 | } 6 | // ---- 7 | // bytesToUint(bytes32): "abc2" -> left(0x61626332) 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_fixed_bytes_to_uint_smaller_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function bytesToUint(bytes4 s) public returns (uint16 h) { 3 | return uint16(uint32(s)); 4 | } 5 | } 6 | // ---- 7 | // bytesToUint(bytes4): "abcd" -> 0x6364 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_uint_to_fixed_bytes_greater_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function UintToBytes(uint16 h) public returns (bytes8 s) { 3 | return bytes8(uint64(h)); 4 | } 5 | } 6 | // ---- 7 | // UintToBytes(uint16): 0x6162 -> "\x00\x00\x00\x00\x00\x00ab" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_uint_to_fixed_bytes_same_min_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function UintToBytes(uint8 h) public returns (bytes1 s) { 3 | return bytes1(h); 4 | } 5 | } 6 | // ---- 7 | // UintToBytes(uint8): 0x61 -> "a" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_uint_to_fixed_bytes_same_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function uintToBytes(uint256 h) public returns (bytes32 s) { 3 | return bytes32(h); 4 | } 5 | } 6 | // ---- 7 | // uintToBytes(uint256): left(0x616263) -> left(0x616263) 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/convert_uint_to_fixed_bytes_smaller_size.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function uintToBytes(uint32 h) public returns (bytes2 s) { 3 | return bytes2(uint16(h)); 4 | } 5 | } 6 | // ---- 7 | // uintToBytes(uint32): 0x61626364 -> "cd" 8 | -------------------------------------------------------------------------------- /solidity/ethereum/types/packing_signed_types.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function run() public returns(int8 y) { 3 | uint8 x = 0xfa; 4 | return int8(x); 5 | } 6 | } 7 | // ---- 8 | // run() -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa 9 | -------------------------------------------------------------------------------- /solidity/ethereum/types/type_conversion_cleanup.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | function test() public returns (uint ret) { return uint(uint160(address(uint160(uint128(type(uint200).max))))); } 3 | } 4 | // ---- 5 | // test() -> 0xffffffffffffffffffffffffffffffff 6 | -------------------------------------------------------------------------------- /solidity/ethereum/userDefinedValueType/wrap_unwrap.sol: -------------------------------------------------------------------------------- 1 | type MyAddress is address; 2 | contract C { 3 | function f() pure public { 4 | MyAddress.wrap; 5 | MyAddress.unwrap; 6 | } 7 | } 8 | // ---- 9 | // f() -> 10 | -------------------------------------------------------------------------------- /solidity/ethereum/variables/delete_local.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function delLocal() public returns (uint res){ 3 | uint v = 5; 4 | delete v; 5 | res = v; 6 | } 7 | } 8 | // ---- 9 | // delLocal() -> 0 10 | -------------------------------------------------------------------------------- /solidity/ethereum/variables/delete_transient_state_variable.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint transient x; 3 | function f() public returns (uint) { 4 | x = 10; 5 | delete x; 6 | return x; 7 | } 8 | } 9 | // ==== 10 | // EVMVersion: >=cancun 11 | // ---- 12 | // f() -> 0 13 | -------------------------------------------------------------------------------- /solidity/ethereum/various/assignment_to_const_var_involving_expression.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | uint256 constant x = 0x123 + 0x456; 3 | 4 | function f() public returns (uint256) { 5 | return x + 1; 6 | } 7 | } 8 | // ---- 9 | // f() -> 0x57a 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/balance.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | constructor() payable {} 3 | 4 | function getBalance() public returns (uint256 balance) { 5 | return address(this).balance; 6 | } 7 | } 8 | // ---- 9 | // constructor(), 23 wei -> 10 | // getBalance() -> 23 11 | -------------------------------------------------------------------------------- /solidity/ethereum/various/decayed_tuple.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (uint256) { 3 | uint256 x = 1; 4 | (x) = 2; 5 | return x; 6 | } 7 | } 8 | // ---- 9 | // f() -> 2 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/empty_name_return_parameter.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f(uint256 k) public returns (uint256) { 3 | return k; 4 | } 5 | } 6 | // ---- 7 | // f(uint256): 9 -> 9 8 | -------------------------------------------------------------------------------- /solidity/ethereum/various/flipping_sign_tests.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | function f() public returns (bool) { 3 | int256 x = -2**255; 4 | unchecked { assert(-x == x); } 5 | return true; 6 | } 7 | } 8 | // ---- 9 | // f() -> true 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/gasleft_shadow_resolution.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function gasleft() public returns (uint256) { 3 | return 0; 4 | } 5 | 6 | function f() public returns (uint256) { 7 | return gasleft(); 8 | } 9 | } 10 | // ---- 11 | // f() -> 0 12 | -------------------------------------------------------------------------------- /solidity/ethereum/various/inline_tuple_with_rational_numbers.sol: -------------------------------------------------------------------------------- 1 | contract c { 2 | function f() public returns (int8) { 3 | int8[5] memory foo3 = [int8(1), -1, 0, 0, 0]; 4 | return foo3[0]; 5 | } 6 | } 7 | // ---- 8 | // f() -> 1 9 | -------------------------------------------------------------------------------- /solidity/ethereum/various/memory_overwrite.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public returns (bytes memory x) { 3 | x = "12345"; 4 | x[3] = 0x61; 5 | x[0] = 0x62; 6 | } 7 | } 8 | // ---- 9 | // f() -> 0x20, 5, "b23a5" 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/positive_integers_to_signed.sol: -------------------------------------------------------------------------------- 1 | contract test { 2 | int8 public x = 2; 3 | int8 public y = 127; 4 | int16 public q = 250; 5 | } 6 | // ---- 7 | // x() -> 2 8 | // y() -> 127 9 | // q() -> 250 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/state_variable_local_variable_mixture.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | uint256 x = 1; 3 | uint256 y = 2; 4 | 5 | function a() public returns (uint256 x) { 6 | x = A.y; 7 | } 8 | } 9 | // ---- 10 | // a() -> 2 11 | -------------------------------------------------------------------------------- /solidity/ethereum/various/state_variable_under_contract_name.sol: -------------------------------------------------------------------------------- 1 | contract Scope { 2 | uint256 stateVar = 42; 3 | 4 | function getStateVar() public view returns (uint256 stateVar) { 5 | stateVar = Scope.stateVar; 6 | } 7 | } 8 | // ---- 9 | // getStateVar() -> 42 10 | -------------------------------------------------------------------------------- /solidity/ethereum/various/storage_string_as_mapping_key_without_variable.sol: -------------------------------------------------------------------------------- 1 | contract Test { 2 | mapping(string => uint256) data; 3 | 4 | function f() public returns (uint256) { 5 | data["abc"] = 2; 6 | return data["abc"]; 7 | } 8 | } 9 | // ---- 10 | // f() -> 2 11 | -------------------------------------------------------------------------------- /solidity/ethereum/various/super_alone.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | function f() public { 3 | super; 4 | } 5 | } 6 | // ---- 7 | // f() -> 8 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/conditional/conditional_multiple.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | function f() public pure returns (uint) { 3 | uint x = 3 < 0 ? 2 > 1 ? 2 : 1 : 7 > 2 ? 7 : 6; 4 | return x; 5 | } 6 | } 7 | // ---- 8 | // f() -> 7 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/conditional/conditional_true_false_literal.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | function f() public pure returns (uint) { 3 | uint x = true ? 1 : 0; 4 | uint y = false ? 0 : 1; 5 | return x + y; 6 | } 7 | } 8 | // ---- 9 | // f() -> 2 10 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/conditional/conditional_tuple.sol: -------------------------------------------------------------------------------- 1 | contract A { 2 | function f(bool cond) public pure returns (uint, uint) { 3 | (uint a, uint b) = cond ? (1, 2) : (3, 4); 4 | return (a, b); 5 | } 6 | } 7 | // ---- 8 | // f(bool): true -> 1, 2 9 | // f(bool): false -> 3, 4 10 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/conversion/explicit_cast_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint16 x) { 3 | uint8 y = uint8(0x78); 4 | x = y; 5 | } 6 | } 7 | // ---- 8 | // f() -> 0x78 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/conversion/explicit_cast_local_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint a) public pure returns (uint8 x) { 3 | uint8 b = uint8(a); 4 | x = b; 5 | } 6 | } 7 | // ---- 8 | // f(uint256): 0x12345678 -> 0x78 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/empty_return_corrupted_free_memory_pointer.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public { 3 | assembly{ mstore(0x40, sub(0, 1)) } 4 | } 5 | } 6 | // ---- 7 | // f() -> 8 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/local_address_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(address a) public pure returns (address x) { 3 | address b = a; 4 | x = b; 5 | } 6 | } 7 | // ---- 8 | // f(address): 0x1234 -> 0x1234 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/local_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint a) public pure returns (uint x) { 3 | uint b = a; 4 | x = b; 5 | } 6 | } 7 | // ---- 8 | // f(uint256): 6 -> 6 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/local_bool_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(bool a) public pure returns (bool x) { 3 | bool b = a; 4 | x = b; 5 | } 6 | } 7 | // ---- 8 | // f(bool): true -> true 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/local_variable_without_init.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint) { 3 | uint x; 4 | return x; 5 | } 6 | } 7 | // ---- 8 | // f() -> 0 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/mapping_string_key.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | mapping (string => uint) map; 3 | function set(string memory s) public { 4 | map[s]; 5 | } 6 | } 7 | // ---- 8 | // set(string): 0x20, 32, "01234567890123456789012345678901" -> 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/msg_sender.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function test() public view returns (bool) { 3 | address x; 4 | assembly { x := caller() } 5 | return x == msg.sender; 6 | } 7 | } 8 | // ---- 9 | // test() -> true 10 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/negation_bug.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure { 3 | -(int8(0)); 4 | unchecked { 5 | // Used to incorrectly use the checked unary negation function and revert. 6 | (-(type(int8).min)); 7 | } 8 | } 9 | } 10 | // ---- 11 | // f() -> 12 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/return.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint x) { 3 | return 7; 4 | x = 3; 5 | } 6 | } 7 | // ---- 8 | // f() -> 7 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/return_and_convert.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f() public pure returns (uint) { 3 | uint8 b; 4 | assembly { b := 0xffff } 5 | return b; 6 | } 7 | } 8 | // ---- 9 | // f() -> 255 10 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/simple_assignment.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | function f(uint a, uint b) public pure returns (uint x, uint y) { 3 | x = a; 4 | y = b; 5 | } 6 | } 7 | // ---- 8 | // f(uint256,uint256): 5, 6 -> 5, 6 9 | -------------------------------------------------------------------------------- /solidity/ethereum/viaYul/smoke_test.sol: -------------------------------------------------------------------------------- 1 | contract C { 2 | } 3 | // ==== 4 | // allowNonExistingFunctions: true 5 | // ---- 6 | // f() -> FAILURE 7 | -------------------------------------------------------------------------------- /solidity/simple/unused/cases.sol: -------------------------------------------------------------------------------- 1 | //! { "cases": [] } 2 | 3 | // SPDX-License-Identifier: MIT 4 | 5 | pragma solidity >=0.4.16; 6 | 7 | contract Test { 8 | function entry() public pure returns(uint64) { 9 | return 1; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /vyper/complex/array_one_element-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(_p1: uint256[1]) -> uint256: 4 | p1: uint256[1] = _p1 5 | return p1[0] 6 | -------------------------------------------------------------------------------- /vyper/complex/array_one_element-0.3/main.vy: -------------------------------------------------------------------------------- 1 | # Report https://linear.app/matterlabs/issue/CPR-269/call-with-calldata-variable-bug 2 | 3 | import callable as Callable 4 | 5 | @external 6 | def main(p1: uint256[1], callable: address) -> uint256: 7 | return Callable(callable).f(p1) 8 | -------------------------------------------------------------------------------- /vyper/complex/array_one_element/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(_p1: uint256[1]) -> uint256: 4 | p1: uint256[1] = _p1 5 | return p1[0] 6 | -------------------------------------------------------------------------------- /vyper/complex/call_by_signature-0.3/main.vy: -------------------------------------------------------------------------------- 1 | import storage as Storage 2 | 3 | @external 4 | def main(_value: uint256, storage_address: address) -> uint256: 5 | raw_call(storage_address, _abi_encode(_value, method_id=method_id("set(uint256)"))) 6 | return Storage(storage_address).get() * 2 7 | -------------------------------------------------------------------------------- /vyper/complex/call_by_signature-0.3/storage.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(_value: uint256): 5 | self.value = _value 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/call_by_signature/storage.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(_value: uint256): 5 | self.value = _value 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/call_chain-0.3/first.vy: -------------------------------------------------------------------------------- 1 | import second as Second 2 | 3 | @external 4 | @pure 5 | def f(p: uint256, second: address, third: address) -> uint256: 6 | return Second(second).f(p, third) 7 | -------------------------------------------------------------------------------- /vyper/complex/call_chain-0.3/second.vy: -------------------------------------------------------------------------------- 1 | import third as Third 2 | 3 | @external 4 | @pure 5 | def f(p: uint256, third: address) -> uint256: 6 | return Third(third).f(p) * 2 7 | -------------------------------------------------------------------------------- /vyper/complex/call_chain-0.3/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/call_chain/first.vy: -------------------------------------------------------------------------------- 1 | interface Second: 2 | def f(p: uint256, third_implementation: address) -> uint256: pure 3 | 4 | @external 5 | @pure 6 | def f(p: uint256, second: address, third: address) -> uint256: 7 | return staticcall Second(second).f(p, third) 8 | -------------------------------------------------------------------------------- /vyper/complex/call_chain/second.vy: -------------------------------------------------------------------------------- 1 | interface Third: 2 | def f(p: uint256) -> uint256: pure 3 | 4 | @external 5 | @pure 6 | def f(p: uint256, third: address) -> uint256: 7 | return staticcall Third(third).f(p) * 2 8 | -------------------------------------------------------------------------------- /vyper/complex/call_chain/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create-0.3/main.vy: -------------------------------------------------------------------------------- 1 | import callable as Callable 2 | 3 | @external 4 | def main(implementation: address) -> uint256: 5 | callee: address = create_from_blueprint(implementation) 6 | 7 | Callable(callee).set(10) 8 | return Callable(callee).get() 9 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2_chain-0.3/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2_chain/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2_with_code_offset-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create2_with_code_offset/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create_chain-0.3/second.vy: -------------------------------------------------------------------------------- 1 | import third as Third 2 | 3 | @external 4 | def f(p: uint256, third_implementation: address) -> uint256: 5 | third: address = create_from_blueprint(third_implementation) 6 | return Third(third).f(p) * 2 7 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create_chain-0.3/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create_chain/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create_with_code_offset-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/create_with_code_offset/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/relayer-0.3/agent.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_from_blueprint/relayer/agent.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create-0.3/main.vy: -------------------------------------------------------------------------------- 1 | import callable as Callable 2 | 3 | @external 4 | def main(implementation: address) -> uint256: 5 | callee: address = create_forwarder_to(implementation) 6 | 7 | Callable(callee).set(10) 8 | return Callable(callee).get() 9 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create2-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create2/callable.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def set(x: uint256): 5 | self.value = x 6 | 7 | @external 8 | @view 9 | def get() -> uint256: 10 | return self.value 11 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create2_chain-0.3/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create2_chain/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create_chain-0.3/second.vy: -------------------------------------------------------------------------------- 1 | import third as Third 2 | 3 | @external 4 | def f(p: uint256, third_implementation: address) -> uint256: 5 | third: address = create_forwarder_to(third_implementation) 6 | return Third(third).f(p) * 2 7 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create_chain-0.3/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/create_minimal_proxy_to/create_chain/third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p: uint256) -> uint256: 4 | return p * 3 5 | -------------------------------------------------------------------------------- /vyper/complex/default-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint256: 4 | return a * 2 5 | -------------------------------------------------------------------------------- /vyper/complex/default-0.3/main.vy: -------------------------------------------------------------------------------- 1 | import callable as Callable 2 | 3 | @external 4 | def main(callable: address) -> uint256: 5 | return Callable(callable).f(5) 6 | -------------------------------------------------------------------------------- /vyper/complex/default/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint256: 4 | return a * 2 5 | -------------------------------------------------------------------------------- /vyper/complex/default/main.vy: -------------------------------------------------------------------------------- 1 | interface Callable: 2 | def f(a: uint256) -> uint256: pure 3 | 4 | @external 5 | def main(callable: address) -> uint256: 6 | return staticcall Callable(callable).f(5) 7 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/arithmetics/check_var_init-0.3/C.vy: -------------------------------------------------------------------------------- 1 | x: public(uint256) 2 | 3 | @external 4 | @payable 5 | def init_(): 6 | self.x = msg.value - 10 7 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/arithmetics/check_var_init/C.vy: -------------------------------------------------------------------------------- 1 | x: public(uint256) 2 | 3 | @external 4 | @payable 5 | def init_(): 6 | self.x = msg.value - 10 7 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/array/copying/copying_bytes_multiassign-0.3/receiver.vy: -------------------------------------------------------------------------------- 1 | received: public(uint256) 2 | 3 | @external 4 | def recv(x: uint256): 5 | self.received += x + 1 6 | 7 | @external 8 | def __default__(): 9 | self.received = convert(0x80, uint256) 10 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/array/copying/copying_bytes_multiassign/receiver.vy: -------------------------------------------------------------------------------- 1 | received: public(uint256) 2 | 3 | @external 4 | def recv(x: uint256): 5 | self.received += x + 1 6 | 7 | @external 8 | def __default__(): 9 | self.received = convert(0x80, uint256) 10 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/array/fixed_arrays_as_return_type-0.3/B.vy: -------------------------------------------------------------------------------- 1 | import A as A 2 | 3 | @external 4 | def f(_a: address) -> (uint16[5], uint16[5]): 5 | a: address = create_forwarder_to(_a) 6 | res: uint16[5] = A(a).f(2) 7 | res2: uint16[5] = A(a).f(1000) 8 | return res, res2 9 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/array/reusing_memory-0.3/Helper.vy: -------------------------------------------------------------------------------- 1 | # Invoke some features that use memory and test that they do not interfere with each other. 2 | flag: public(uint256) 3 | 4 | @external 5 | def init_(x: uint256): 6 | self.flag = x -------------------------------------------------------------------------------- /vyper/complex/ethereum/array/reusing_memory/Helper.vy: -------------------------------------------------------------------------------- 1 | # Invoke some features that use memory and test that they do not interfere with each other. 2 | _flag: public(uint256) 3 | 4 | @external 5 | def init_(x: uint256): 6 | self._flag = x -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/callvalue_check-0.3/B3.vy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matter-labs/era-compiler-tests/7d31408bf8ed5c21b46aebee32cc879b6d2ed262/vyper/complex/ethereum/constructor/callvalue_check-0.3/B3.vy -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/callvalue_check/B3.vy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matter-labs/era-compiler-tests/7d31408bf8ed5c21b46aebee32cc879b6d2ed262/vyper/complex/ethereum/constructor/callvalue_check/B3.vy -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/evm_exceptions_in_constructor_call_fail-0.3/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def __init__(): 3 | raw_call(self, convert("123", Bytes[3])) 4 | 5 | @external 6 | def init_(): 7 | raw_call(self, convert("123", Bytes[3])) 8 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/evm_exceptions_in_constructor_call_fail/A.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | def __init__(): 3 | raw_call(self, convert("123", Bytes[3])) 4 | 5 | @external 6 | def init_(): 7 | raw_call(self, convert("123", Bytes[3])) 8 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/no_callvalue_check-0.3/B3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def init_(): 4 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/constructor/no_callvalue_check/B3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def init_(): 4 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/events/event_emit_from_other_contract-0.3/C.vy: -------------------------------------------------------------------------------- 1 | import D as D 2 | 3 | d: D 4 | 5 | @external 6 | def __init__(_d: address): 7 | self.d = D(create_forwarder_to(_d)) 8 | 9 | @external 10 | @payable 11 | def deposit(_id: bytes32): 12 | self.d.deposit(_id) 13 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/events/event_emit_from_other_contract-0.3/D.vy: -------------------------------------------------------------------------------- 1 | event Deposit: 2 | _from: indexed(address) 3 | _id: indexed(bytes32) 4 | _value: uint256 5 | 6 | @external 7 | @payable 8 | def deposit(_id: bytes32): 9 | log Deposit(msg.sender, _id, msg.value) 10 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/events/event_emit_from_other_contract-0.4.0/D.vy: -------------------------------------------------------------------------------- 1 | event Deposit: 2 | _from: indexed(address) 3 | _id: indexed(bytes32) 4 | _value: uint256 5 | 6 | @external 7 | @payable 8 | def deposit(_id: bytes32): 9 | log Deposit(msg.sender, _id, msg.value) 10 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/events/event_emit_from_other_contract/D.vy: -------------------------------------------------------------------------------- 1 | event Deposit: 2 | _from: indexed(address) 3 | _id: indexed(bytes32) 4 | _value: uint256 5 | 6 | @external 7 | @payable 8 | def deposit(_id: bytes32): 9 | log Deposit(_from=msg.sender, _id=_id, _value=msg.value) 10 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/fallback/call_forward_bytes-0.3/receiver.vy: -------------------------------------------------------------------------------- 1 | received: public(uint256) 2 | 3 | @external 4 | def recv(x: uint256): 5 | self.received += x + 1 6 | 7 | @external 8 | def __default__(): 9 | self.received = convert(0x80, uint256) -------------------------------------------------------------------------------- /vyper/complex/ethereum/fallback/call_forward_bytes/receiver.vy: -------------------------------------------------------------------------------- 1 | received: public(uint256) 2 | 3 | @external 4 | def recv(x: uint256): 5 | self.received += x + 1 6 | 7 | @external 8 | def __default__(): 9 | self.received = convert(0x80, uint256) -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_no_args-0.3/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(): 5 | self.i = 2 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_no_args-0.3/D.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def f(_c: address) -> uint256: 5 | c: address = create_forwarder_to(_c) 6 | C(c).init_() 7 | return C(c).i() 8 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_no_args/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(): 5 | self.i = 2 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_with_args-0.3/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(newI: uint256): 5 | self.i = newI 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_with_args/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(newI: uint256): 5 | self.i = newI 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_with_salt-0.3/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(newI: uint256): 5 | self.i = newI 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/creation_function_call_with_salt/C.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | 3 | @external 4 | def init_(newI: uint256): 5 | self.i = newI 6 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/external_call_at_construction_time-0.3/T.vy: -------------------------------------------------------------------------------- 1 | interface Self: 2 | def f(): nonpayable 3 | 4 | @external 5 | def f(): 6 | pass 7 | 8 | @external 9 | def init_(): 10 | Self(self).f() 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/external_call_at_construction_time-0.3/U.vy: -------------------------------------------------------------------------------- 1 | interface Self: 2 | def f() -> uint256: nonpayable 3 | 4 | @external 5 | def f() -> uint256: 6 | return 0 7 | 8 | @external 9 | def init_(): 10 | Self(self).f() 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/external_call_at_construction_time/T.vy: -------------------------------------------------------------------------------- 1 | interface Self: 2 | def f(): nonpayable 3 | 4 | @external 5 | def f(): 6 | pass 7 | 8 | @external 9 | def init_(): 10 | extcall Self(self).f() 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/external_call_at_construction_time/U.vy: -------------------------------------------------------------------------------- 1 | interface Self: 2 | def f() -> uint256: nonpayable 3 | 4 | @external 5 | def f() -> uint256: 6 | return 0 7 | 8 | @external 9 | def init_(): 10 | extcall Self(self).f() 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/failed_create-0.3/D.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def init_(): 4 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/functionCall/failed_create/D.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def init_(): 4 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/immutable/multi_creation-0.3/A.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint256) 2 | 3 | @external 4 | def __init__(): 5 | a = 7 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return a -------------------------------------------------------------------------------- /vyper/complex/ethereum/immutable/multi_creation-0.3/B.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint256) 2 | 3 | @external 4 | def __init__(): 5 | a = 5 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return a 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/immutable/multi_creation/A.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | a = 7 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return a -------------------------------------------------------------------------------- /vyper/complex/ethereum/immutable/multi_creation/B.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | a = 5 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return a 11 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/isoltestTesting/balance_other_contract-0.3/Other.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | @external 7 | def getAddress() -> address: 8 | return self 9 | 10 | @external 11 | @view 12 | def balance_() -> uint256: 13 | return self.balance 14 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/isoltestTesting/balance_other_contract/Other.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | @external 7 | def getAddress() -> address: 8 | return self 9 | 10 | @external 11 | @view 12 | def balance_() -> uint256: 13 | return self.balance 14 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/bubble-0.3/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def g(): 3 | raise "fail" 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/bubble-0.3/C.vy: -------------------------------------------------------------------------------- 1 | import A as A 2 | 3 | a: A 4 | 5 | @external 6 | def __init__(_a: address): 7 | self.a = A(create_forwarder_to(_a)) 8 | 9 | @external 10 | def f(): 11 | self.a.g() 12 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/bubble/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def g(): 3 | raise "fail" 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/bubble/C.vy: -------------------------------------------------------------------------------- 1 | interface A: 2 | def g(): nonpayable 3 | 4 | a: A 5 | 6 | @deploy 7 | def __init__(_a: address): 8 | self.a = A(create_forwarder_to(_a)) 9 | 10 | @external 11 | def f(): 12 | extcall self.a.g() 13 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/transfer-0.3/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __default__(): 4 | raise "no_receive" 5 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/revertStrings/transfer/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __default__(): 4 | raise "no_receive" 5 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/salted_create/salted_create-0.3/B.vy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matter-labs/era-compiler-tests/7d31408bf8ed5c21b46aebee32cc879b6d2ed262/vyper/complex/ethereum/salted_create/salted_create-0.3/B.vy -------------------------------------------------------------------------------- /vyper/complex/ethereum/salted_create/salted_create/B.vy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/matter-labs/era-compiler-tests/7d31408bf8ed5c21b46aebee32cc879b6d2ed262/vyper/complex/ethereum/salted_create/salted_create/B.vy -------------------------------------------------------------------------------- /vyper/complex/ethereum/salted_create/salted_create_with_value-0.3/B.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | @view 5 | def getBalance() -> uint256: 6 | return self.balance * 1000 + self.x 7 | 8 | @external 9 | @payable 10 | def init_(_x: uint256): 11 | self.x = _x 12 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/salted_create/salted_create_with_value/B.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | @view 5 | def getBalance() -> uint256: 6 | return self.balance * 1000 + self.x 7 | 8 | @external 9 | @payable 10 | def init_(_x: uint256): 11 | self.x = _x 12 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies-0.3/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(_b: address): 3 | _: address = create_forwarder_to(_b) 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies-0.3/B.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(): 3 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies-0.3/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(_b: address): 3 | _: address = create_forwarder_to(_b) 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(_b: address): 3 | _: address = create_forwarder_to(_b) 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies/B.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(): 3 | pass -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/contract_binary_dependencies/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(_b: address): 3 | _: address = create_forwarder_to(_b) 4 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/senders_balance-0.3/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @view 3 | def f() -> uint256: 4 | return msg.sender.balance 5 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/senders_balance-0.3/D.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | c: C 4 | 5 | @external 6 | @payable 7 | def __init__(_c: address): 8 | self.c = C(create_forwarder_to(_c)) 9 | 10 | @external 11 | @view 12 | def f() -> uint256: 13 | return self.c.f() 14 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/senders_balance/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @view 3 | def f() -> uint256: 4 | return msg.sender.balance 5 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/staticcall_for_view_and_pure-0.3/C.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | def f() -> uint256: 5 | self.x = 3 6 | return 1 7 | -------------------------------------------------------------------------------- /vyper/complex/ethereum/various/staticcall_for_view_and_pure/C.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | def f() -> uint256: 5 | self.x = 3 6 | return 1 7 | -------------------------------------------------------------------------------- /vyper/complex/indirect_recursion_fact-0.3/first.vy: -------------------------------------------------------------------------------- 1 | import second as Second 2 | 3 | @external 4 | def fact(n: uint256, first: address, second: address) -> uint256: 5 | if n == 0: 6 | return 1 7 | return Second(second).fact(n - 1, first, second) * n 8 | -------------------------------------------------------------------------------- /vyper/complex/indirect_recursion_fact-0.3/second.vy: -------------------------------------------------------------------------------- 1 | import first as First 2 | 3 | @external 4 | def fact(n: uint256, first: address, second: address) -> uint256: 5 | if n == 0: 6 | return 1 7 | return First(first).fact(n - 1, first, second) * n 8 | -------------------------------------------------------------------------------- /vyper/complex/interface_casting-0.3/c.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | def f() -> uint256: 5 | self.x = 3 6 | return 1 7 | -------------------------------------------------------------------------------- /vyper/complex/interface_casting-0.3/d.vy: -------------------------------------------------------------------------------- 1 | # Report https://linear.app/matterlabs/issue/CPR-413/fix-another-exception-handling-issue 2 | 3 | interface CView: 4 | def f() -> uint256: view 5 | 6 | @external 7 | def fview(c: address) -> uint256: 8 | return CView(c).f() 9 | -------------------------------------------------------------------------------- /vyper/complex/interface_casting/c.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | def f() -> uint256: 5 | self.x = 3 6 | return 1 7 | -------------------------------------------------------------------------------- /vyper/complex/interface_casting/d.vy: -------------------------------------------------------------------------------- 1 | # Report https://linear.app/matterlabs/issue/CPR-413/fix-another-exception-handling-issue 2 | 3 | interface CView: 4 | def f() -> uint256: view 5 | 6 | @external 7 | def fview(c: address) -> uint256: 8 | return staticcall CView(c).f() 9 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/require-0.3/simpleRequire.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def require_short(): 4 | assert False, "short" 5 | 6 | @external 7 | @pure 8 | def wrong_number_of_params(one: uint256, two: uint256) -> uint256: 9 | return one + two 10 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/require/simpleRequire.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def require_short(): 4 | assert False, "short" 5 | 6 | @external 7 | @pure 8 | def wrong_number_of_params(one: uint256, two: uint256) -> uint256: 9 | return one + two 10 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/simple-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint256: 4 | return a * 2 5 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/simple-0.3/main.vy: -------------------------------------------------------------------------------- 1 | interface ICallable: 2 | def f(a: uint256, x: bool) -> uint256: pure 3 | 4 | @external 5 | def main(callable: address) -> uint256: 6 | return ICallable(callable).f(5, False) 7 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/simple/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint256: 4 | return a * 2 5 | -------------------------------------------------------------------------------- /vyper/complex/invalid_signature/simple/main.vy: -------------------------------------------------------------------------------- 1 | interface ICallable: 2 | def f(a: uint256, x: bool) -> uint256: pure 3 | 4 | @external 5 | def main(callable: address) -> uint256: 6 | return staticcall ICallable(callable).f(5, False) 7 | -------------------------------------------------------------------------------- /vyper/complex/many_arguments/simple-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p1: uint256, p2: uint256, p3: uint8, p4: uint256, p5: uint256, p6: uint256, p7: uint256, p8: uint256) -> uint256: 4 | return p1 + p2 + convert(p3, uint256) + p4 + p5 + p6 + p7 + p8 5 | -------------------------------------------------------------------------------- /vyper/complex/many_arguments/simple/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(p1: uint256, p2: uint256, p3: uint8, p4: uint256, p5: uint256, p6: uint256, p7: uint256, p8: uint256) -> uint256: 4 | return p1 + p2 + convert(p3, uint256) + p4 + p5 + p6 + p7 + p8 5 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_call-0.3/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address) -> address: 5 | return C(c).main() 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_call-0.3/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main() -> address: 3 | return msg.sender 4 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_call/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main(b: address, c: address) -> address: 3 | output: Bytes[32] = raw_call(b, abi_encode(c, method_id=method_id("main(address)")), max_outsize=32, is_delegate_call=True) 4 | return convert(convert(output, uint256), address) 5 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_call/B.vy: -------------------------------------------------------------------------------- 1 | interface C: 2 | def main() -> address: nonpayable 3 | 4 | @external 5 | def main(c: address) -> address: 6 | return extcall C(c).main() 7 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_call/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main() -> address: 3 | return msg.sender 4 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_delegatecall-0.3/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address) -> address: 5 | output: Bytes[32] = raw_call(c, method_id("main()"), max_outsize=32, is_delegate_call=True) 6 | return convert(convert(output, uint256), address) 7 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_delegatecall-0.3/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main() -> address: 3 | return msg.sender 4 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_delegatecall/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address) -> address: 5 | output: Bytes[32] = raw_call(c, method_id("main()"), max_outsize=32, is_delegate_call=True) 6 | return convert(convert(output, uint256), address) 7 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/delegatecall_delegatecall/C.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main() -> address: 3 | return msg.sender 4 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call-0.3/A.vy: -------------------------------------------------------------------------------- 1 | import B as B 2 | 3 | @external 4 | def main(b: address, c: address): 5 | raw_call(b, _abi_encode(c, method_id=method_id("main(address)")), is_static_call=True) 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call-0.3/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address): 5 | C(c).main() 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call-0.3/C.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def main(): 5 | self.value += 1 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call/A.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def main(b: address, c: address): 3 | raw_call(b, abi_encode(c, method_id=method_id("main(address)")), is_static_call=True) 4 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call/B.vy: -------------------------------------------------------------------------------- 1 | interface C: 2 | def main(): nonpayable 3 | 4 | @external 5 | def main(c: address): 6 | extcall C(c).main() 7 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_call/C.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def main(): 5 | self.value += 1 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall-0.3/A.vy: -------------------------------------------------------------------------------- 1 | import B as B 2 | 3 | @external 4 | def main(b: address, c: address): 5 | raw_call(b, _abi_encode(c, method_id=method_id("main(address)")), is_static_call=True) 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall-0.3/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address): 5 | raw_call(c, method_id("main()"), is_static_call=True) 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall-0.3/C.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def main(): 5 | self.value += 1 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall/A.vy: -------------------------------------------------------------------------------- 1 | import B as B 2 | 3 | @external 4 | def main(b: address, c: address): 5 | raw_call(b, abi_encode(c, method_id=method_id("main(address)")), is_static_call=True) 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall/B.vy: -------------------------------------------------------------------------------- 1 | import C as C 2 | 3 | @external 4 | def main(c: address): 5 | raw_call(c, method_id("main()"), is_static_call=True) 6 | -------------------------------------------------------------------------------- /vyper/complex/nested_calls/staticcall_staticcall/C.vy: -------------------------------------------------------------------------------- 1 | value: uint256 2 | 3 | @external 4 | def main(): 5 | self.value += 1 6 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/delegate_call-0.3/lib.vy: -------------------------------------------------------------------------------- 1 | owner: public(address) 2 | 3 | @external 4 | def pwn(): 5 | self.owner = msg.sender -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/delegate_call/lib.vy: -------------------------------------------------------------------------------- 1 | owner: public(address) 2 | 3 | @external 4 | def pwn(): 5 | self.owner = msg.sender -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/delegate_call_second-0.3/lib.vy: -------------------------------------------------------------------------------- 1 | someNumber: public(uint256) 2 | 3 | @external 4 | def doSomething(_num: uint256): 5 | self.someNumber = _num 6 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/delegate_call_second/lib.vy: -------------------------------------------------------------------------------- 1 | someNumber: public(uint256) 2 | 3 | @external 4 | def doSomething(_num: uint256): 5 | self.someNumber = _num 6 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/hiding_malicious_code_with_external_contract-0.3/bar.vy: -------------------------------------------------------------------------------- 1 | event Log: 2 | message: String[32] 3 | 4 | @external 5 | def _log(): 6 | log Log("Bar was called") -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/hiding_malicious_code_with_external_contract-0.4.0/bar.vy: -------------------------------------------------------------------------------- 1 | event Log: 2 | message: String[32] 3 | 4 | @external 5 | def _log(): 6 | log Log("Bar was called") -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/hacks/hiding_malicious_code_with_external_contract/bar.vy: -------------------------------------------------------------------------------- 1 | event Log: 2 | message: String[32] 3 | 4 | @external 5 | def _log(): 6 | log Log(message="Bar was called") -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/import-0.3/Foo.vy: -------------------------------------------------------------------------------- 1 | name: public(String[10]) 2 | 3 | @external 4 | def __init__(): 5 | self.name = "Foo" 6 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/import-0.3/Import.vy: -------------------------------------------------------------------------------- 1 | import Foo as Foo 2 | 3 | # Test Foo.sol by getting it's name. 4 | @external 5 | @view 6 | def getFooName(foo: address) -> String[10]: 7 | return Foo(foo).name() 8 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/import/Foo.vy: -------------------------------------------------------------------------------- 1 | name: public(String[10]) 2 | 3 | @deploy 4 | def __init__(): 5 | self.name = "Foo" 6 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/import/IFoo.vyi: -------------------------------------------------------------------------------- 1 | @view 2 | @external 3 | def name() -> String[10]: 4 | ... 5 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/import/Import.vy: -------------------------------------------------------------------------------- 1 | import IFoo as Foo 2 | 3 | # Test Foo.sol by getting it's name. 4 | @external 5 | @view 6 | def getFooName(foo: address) -> String[10]: 7 | return staticcall Foo(foo).name() 8 | -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/interface-0.3/counter.vy: -------------------------------------------------------------------------------- 1 | count: public(uint256) 2 | 3 | @external 4 | def increment(): 5 | self.count += 1 -------------------------------------------------------------------------------- /vyper/complex/solidity_by_example/simple/interface/counter.vy: -------------------------------------------------------------------------------- 1 | count: public(uint256) 2 | 3 | @external 4 | def increment(): 5 | self.count += 1 -------------------------------------------------------------------------------- /vyper/complex/storage-0.3/storage.vy: -------------------------------------------------------------------------------- 1 | s: HashMap[uint256, uint256] 2 | 3 | @external 4 | def set(key: uint256, _value: uint256): 5 | self.s[key] = _value 6 | 7 | @external 8 | @view 9 | def get(key: uint256) -> uint256: 10 | return self.s[key] 11 | -------------------------------------------------------------------------------- /vyper/complex/storage/storage.vy: -------------------------------------------------------------------------------- 1 | s: HashMap[uint256, uint256] 2 | 3 | @external 4 | def set(key: uint256, _value: uint256): 5 | self.s[key] = _value 6 | 7 | @external 8 | @view 9 | def get(key: uint256) -> uint256: 10 | return self.s[key] 11 | -------------------------------------------------------------------------------- /vyper/complex/sum_of_squares-0.3/square.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def square(a: uint256) -> uint256: 4 | return a * a 5 | -------------------------------------------------------------------------------- /vyper/complex/sum_of_squares/square.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def square(a: uint256) -> uint256: 4 | return a * a 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall-0.3/Main.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(testContract: address) -> uint256: 4 | result: Bytes[32] = raw_call(testContract, method_id("value()"), max_outsize = 32, is_delegate_call = True) 5 | return extract32(result, 0, output_type = uint256) 6 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall-0.3/TestContract.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall/Main.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(testContract: address) -> uint256: 4 | result: Bytes[32] = raw_call(testContract, method_id("value()"), max_outsize = 32, is_delegate_call = True) 5 | return extract32(result, 0, output_type = uint256) 6 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall/TestContract.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_call-0.3/Second.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(third: address, value_: uint256) -> uint256: 4 | result: Bytes[32] = raw_call(third, method_id("value()"), max_outsize = 32, value = value_) 5 | return extract32(result, 0, output_type = uint256) 6 | 7 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_call-0.3/Third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_call/Second.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(third: address, value_: uint256) -> uint256: 4 | result: Bytes[32] = raw_call(third, method_id("value()"), max_outsize = 32, value = value_) 5 | return extract32(result, 0, output_type = uint256) 6 | 7 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_call/Third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_delegatecall-0.3/Second.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(third: address) -> uint256: 4 | result: Bytes[32] = raw_call(third, method_id("value()"), max_outsize = 32, is_delegate_call = True) 5 | return extract32(result, 0, output_type = uint256) 6 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_delegatecall-0.3/Third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_delegatecall/Second.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def main(third: address) -> uint256: 4 | result: Bytes[32] = raw_call(third, method_id("value()"), max_outsize = 32, is_delegate_call = True) 5 | return extract32(result, 0, output_type = uint256) 6 | -------------------------------------------------------------------------------- /vyper/complex/value/delegatecall_delegatecall/Third.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def value() -> uint256: 4 | return msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/in_created_contract-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return self.balance*(2**128)+msg.value -------------------------------------------------------------------------------- /vyper/complex/value/in_created_contract/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return self.balance*(2**128)+msg.value 5 | -------------------------------------------------------------------------------- /vyper/complex/value/many_created_contracts-0.3/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return self.balance * msg.value -------------------------------------------------------------------------------- /vyper/complex/value/many_created_contracts/callable.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return self.balance * msg.value 5 | -------------------------------------------------------------------------------- /vyper/ethereum/abiEncoderV2/bool_out_of_bounds.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(b: bool) -> bool: 4 | return b 5 | # ---- 6 | # f(bool): true -> true 7 | # f(bool): false -> false 8 | # f(bool): 0x000000 -> false 9 | # f(bool): 0xffffff -> FAILURE 10 | -------------------------------------------------------------------------------- /vyper/ethereum/abiEncoderV2/calldata_array_short_no_revert_string.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(_: DynArray[uint256, 5]): 3 | pass 4 | # ---- 5 | # f(uint256[]): 0x20, 0 -> 6 | # f(uint256[]): 0x20, 1 -> FAILURE 7 | # f(uint256[]): 0x20, 2 -> FAILURE 8 | 9 | -------------------------------------------------------------------------------- /vyper/ethereum/abiEncoderV2/struct/mediocre_struct.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | c: address 3 | @external 4 | def f(a: uint256, s1: S[2], b: uint256) -> (uint256, address, uint256): 5 | return (a, s1[0].c, b) 6 | # ---- 7 | # f(uint256,(address)[2],uint256): 7, 0, 0, 8 -> 7, 0, 8 8 | -------------------------------------------------------------------------------- /vyper/ethereum/accessor/accessor_for_state_variable-0.3.vy: -------------------------------------------------------------------------------- 1 | ticketPrice: public(uint256) 2 | 3 | @external 4 | def __init__(): 5 | self.ticketPrice = 500 6 | 7 | # ---- 8 | # ticketPrice() -> 500 9 | -------------------------------------------------------------------------------- /vyper/ethereum/accessor/accessor_for_state_variable.vy: -------------------------------------------------------------------------------- 1 | ticketPrice: public(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | self.ticketPrice = 500 6 | 7 | # ---- 8 | # ticketPrice() -> 500 9 | -------------------------------------------------------------------------------- /vyper/ethereum/arithmetics/checked_add_v2.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(a: uint8, b: uint8) -> uint8: 3 | return a + b 4 | 5 | # ---- 6 | # f(uint8,uint8): 254, 0 -> 0xfe 7 | # f(uint8,uint8): 256, 0 -> FAILURE 8 | # f(uint8,uint8): 255, 0 -> 0xff 9 | # f(uint8,uint8): 255, 1 -> FAILURE 10 | -------------------------------------------------------------------------------- /vyper/ethereum/array/calldata_array.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(s: uint256[2]) -> (uint256, uint256): 4 | return (s[0], s[1]) 5 | # ---- 6 | # f(uint256[2]): 42, 23 -> 42, 23 7 | -------------------------------------------------------------------------------- /vyper/ethereum/array/concat/bytes_concat_nested.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(a: Bytes[100], b: Bytes[100], c: Bytes[100]) -> Bytes[300]: 3 | return concat(concat(a, b), c) 4 | # ---- 5 | # f(bytes,bytes,bytes): 0x60, 0xa0, 0xe0, 2, "ab", 2, "ab", 2, "ab" -> 0x20, 6, "ababab" 6 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/array_copy_storage_to_memory.vy: -------------------------------------------------------------------------------- 1 | a: uint256[3] 2 | 3 | @external 4 | def f() -> (uint256, uint256): 5 | self.a[0] = 1 6 | self.a[1] = 0 7 | self.a[2] = 0 8 | b: uint256[3] = self.a 9 | return (b[0], 3) 10 | 11 | # ---- 12 | # f() -> 1, 3 13 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/bytes_calldata_to_string_calldata.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(c: Bytes[100]) -> String[100]: 3 | return convert(c, String[100]) 4 | # ---- 5 | # f(bytes): 0x20, 3, "abc" -> 0x20, 3, "abc" 6 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/bytes_memory_to_storage.vy: -------------------------------------------------------------------------------- 1 | s: Bytes[100] 2 | 3 | @external 4 | def f() -> bytes32: 5 | data: Bytes[100] = convert("abcd", Bytes[100]) 6 | self.s = data 7 | return convert(slice(self.s, 0, 1), bytes32) 8 | # ---- 9 | # f() -> "a" 10 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/calldata_array_static_to_memory.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(c: uint256[2]) -> (uint256, uint256): 3 | m1: uint256[2] = c 4 | return (m1[0], m1[1]) 5 | # ---- 6 | # f(uint256[2]): 43, 57 -> 43, 57 7 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/calldata_bytes_to_storage.vy: -------------------------------------------------------------------------------- 1 | s: Bytes[100] 2 | @external 3 | def f(data: Bytes[100]) -> bytes32: 4 | self.s = data 5 | return convert(slice(self.s, 0, 1), bytes32) 6 | # ---- 7 | # f(bytes): 0x20, 0x08, "abcdefgh" -> "a" 8 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/calldata_dyn_2d_bytes_to_memory.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(c: DynArray[Bytes[2], 2]) -> DynArray[Bytes[2], 2]: 3 | return c 4 | # ---- 5 | # f(bytes[]): 0x20, 2, 0x60, 0x60, 0x20, 2, "ab" -> 0x20, 2, 0x40, 0x80, 2, "ab", 2, "ab" 6 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/storage_memory_packed.vy: -------------------------------------------------------------------------------- 1 | a: uint8[33] 2 | 3 | @external 4 | def f() -> (uint8, uint8, uint8): 5 | self.a[0] = 2 6 | self.a[16] = 3 7 | self.a[32] = 4 8 | m: uint8[33] = self.a 9 | return (m[0], m[16], m[32]) 10 | # ---- 11 | # f() -> 2, 3, 4 12 | -------------------------------------------------------------------------------- /vyper/ethereum/array/copying/string_calldata_to_bytes_calldata.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(s: String[100]) -> Bytes[100]: 3 | return convert(s, Bytes[100]) 4 | # ---- 5 | # f(string): 0x20, 3, "abc" -> 0x20, 3, "abc" 6 | -------------------------------------------------------------------------------- /vyper/ethereum/array/create_dynamic_array_with_zero_length.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | a: DynArray[DynArray[uint256, 1], 1] = [] 4 | return 7 5 | 6 | # ---- 7 | # f() -> 7 8 | -------------------------------------------------------------------------------- /vyper/ethereum/array/delete/delete_bytes_array.vy: -------------------------------------------------------------------------------- 1 | data: Bytes[100] 2 | 3 | @external 4 | def f() -> uint256: 5 | self.data = b"ab" 6 | self.data = empty(Bytes[100]) 7 | return len(self.data) 8 | 9 | # ---- 10 | # f() -> 0 -------------------------------------------------------------------------------- /vyper/ethereum/array/delete/delete_memory_array.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def _len() -> uint256: 3 | data: uint256[2] = empty(uint256[2]) 4 | data[0] = 234 5 | data[1] = 123 6 | data = empty(uint256[2]) 7 | return data[0] 8 | 9 | # ---- 10 | # _len() -> 0 11 | -------------------------------------------------------------------------------- /vyper/ethereum/array/indexAccess/inline_array_index_access_ints.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | return ([1, 2, 3, 4][2]) 4 | 5 | # ---- 6 | # f() -> 3 7 | -------------------------------------------------------------------------------- /vyper/ethereum/array/inline_array_singleton.vy: -------------------------------------------------------------------------------- 1 | # This caused a failure since the type was not converted to its mobile type. 2 | @external 3 | def f() -> uint256: 4 | return [4][0] 5 | # ---- 6 | # f() -> 4 7 | -------------------------------------------------------------------------------- /vyper/ethereum/array/inline_array_storage_to_memory_conversion_ints.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> (uint256, uint256): 3 | x: uint256 = 3 4 | y: uint256 = 6 5 | z: uint256[2] = [x, y] 6 | return (z[0], z[1]) 7 | 8 | # ---- 9 | # f() -> 3, 6 10 | -------------------------------------------------------------------------------- /vyper/ethereum/array/pop/array_pop_empty_exception.vy: -------------------------------------------------------------------------------- 1 | data: DynArray[uint256, 10] 2 | 3 | @external 4 | def test() -> bool: 5 | self.data.pop() 6 | return True 7 | 8 | # ---- 9 | # test() -> FAILURE 10 | -------------------------------------------------------------------------------- /vyper/ethereum/array/pop/array_pop_storage_empty.vy: -------------------------------------------------------------------------------- 1 | data: DynArray[uint256, 1] 2 | 3 | @external 4 | def test(): 5 | self.data.append(7) 6 | self.data.pop() 7 | 8 | # ---- 9 | # test() -> 10 | # storageEmpty -> 0 11 | -------------------------------------------------------------------------------- /vyper/ethereum/array/pop/parenthesized.vy: -------------------------------------------------------------------------------- 1 | data: DynArray[int256, 10] 2 | 3 | @external 4 | def f() -> uint256: 5 | self.data.append(1) 6 | (self.data.pop)() 7 | return len(self.data) 8 | 9 | # ---- 10 | # f() -> 0 11 | -------------------------------------------------------------------------------- /vyper/ethereum/builtinFunctions/assignment_to_const_var_involving_keccak.vy: -------------------------------------------------------------------------------- 1 | x: constant(bytes32) = keccak256("abc") 2 | 3 | @external 4 | def f() -> bytes32: 5 | return x 6 | 7 | # ---- 8 | # f() -> 0x4e03657aea45a94fc7d47ba826c8d667c0d1e6e33a64a036ec44f58fa12d6c45 9 | -------------------------------------------------------------------------------- /vyper/ethereum/builtinFunctions/blockhash_shadow_resolution.vy: -------------------------------------------------------------------------------- 1 | @internal 2 | def blockhash(blockNumber: uint256) -> bytes32: 3 | x: bytes32 = empty(bytes32) 4 | return x 5 | 6 | @external 7 | def f() -> bytes32: 8 | return self.blockhash(3) 9 | 10 | # ---- 11 | # f() -> 0 12 | -------------------------------------------------------------------------------- /vyper/ethereum/builtinFunctions/keccak256_empty.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bytes32: 3 | return keccak256("") 4 | 5 | # ---- 6 | # f() -> 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 7 | -------------------------------------------------------------------------------- /vyper/ethereum/builtinFunctions/keccak256_with_bytes.vy: -------------------------------------------------------------------------------- 1 | data: Bytes[100] 2 | 3 | @external 4 | def foo() -> bool: 5 | self.data = convert("foo", Bytes[100]) 6 | return keccak256(self.data) == keccak256("foo") 7 | 8 | # ---- 9 | # foo() -> true 10 | -------------------------------------------------------------------------------- /vyper/ethereum/builtinFunctions/sha256_empty.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bytes32: 3 | return sha256("") 4 | 5 | # ---- 6 | # f() -> 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 7 | -------------------------------------------------------------------------------- /vyper/ethereum/calldata/calldata_bytes_to_memory.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(data: Bytes[100]) -> bytes32: 3 | data_: Bytes[100] = data 4 | return keccak256(data_) 5 | # ---- 6 | # f(bytes): 0x20, 0x08, "abcdefgh" -> 0x48624fa43c68d5c552855a4e2919e74645f683f5384f72b5b051b71ea41d4f2d 7 | -------------------------------------------------------------------------------- /vyper/ethereum/constantEvaluator/negative_fractional_mod.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> (int128, int128): 4 | x: int128 = convert((-(-5.2 % 3.0)) * 5.0, int128) 5 | t: int128 = 5 6 | return (x, (-(-t % 3)) * 5) 7 | 8 | # ---- 9 | # f() -> 11, 10 10 | -------------------------------------------------------------------------------- /vyper/ethereum/constants/constant_variables.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = 56 2 | st: constant(bytes32) = 0x61626300ff5f5f00000000000000000000000000000000000000000000000000 3 | 4 | # ---- 5 | # constructor() -> 6 | -------------------------------------------------------------------------------- /vyper/ethereum/constants/simple_constant_variables_test.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def getX() -> uint256: 3 | return x 4 | 5 | x: constant(uint256) = 56 6 | 7 | # ---- 8 | # getX() -> 56 9 | -------------------------------------------------------------------------------- /vyper/ethereum/constructor/payable_constructor-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 27 wei -> 8 | -------------------------------------------------------------------------------- /vyper/ethereum/constructor/payable_constructor.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 27 wei -> 8 | -------------------------------------------------------------------------------- /vyper/ethereum/conversions/string_to_bytes.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(s: String[100]) -> Bytes[100]: 4 | return convert(s, Bytes[100]) 5 | 6 | # ---- 7 | # f(string): 32, 5, "Hello" -> 32, 5, "Hello" 8 | -------------------------------------------------------------------------------- /vyper/ethereum/dirty_calldata_bytes.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(b: Bytes[100]) -> bool: 3 | a: bytes1 = convert(slice(b, 3, 1), bytes1) 4 | r: uint256 = convert(convert(a, bytes32), uint256) 5 | return r == convert(0x64, uint256) << 248 6 | 7 | # ---- 8 | # f(bytes): 0x20, 0x04, "dead" -> true 9 | -------------------------------------------------------------------------------- /vyper/ethereum/empty_contract.vy: -------------------------------------------------------------------------------- 1 | 2 | # ---- 3 | # i_am_not_there() -> FAILURE 4 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_no_arguments.vy: -------------------------------------------------------------------------------- 1 | event Deposit: 2 | pass 3 | 4 | @external 5 | def deposit(): 6 | log Deposit() 7 | 8 | # ---- 9 | # deposit() -> 10 | # ~ emit Deposit() 11 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_string-0.4.vy: -------------------------------------------------------------------------------- 1 | event E: 2 | r: String[100] 3 | 4 | @external 5 | def deposit(): 6 | log E("HELLO WORLD") 7 | 8 | # ---- 9 | # deposit() -> 10 | # ~ emit E(string): 0x20, 0x0b, "HELLO WORLD" 11 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_string.vy: -------------------------------------------------------------------------------- 1 | event E: 2 | r: String[100] 3 | 4 | @external 5 | def deposit(): 6 | log E(r="HELLO WORLD") 7 | 8 | # ---- 9 | # deposit() -> 10 | # ~ emit E(string): 0x20, 0x0b, "HELLO WORLD" 11 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_struct_memory_v2-0.3.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | event E: 5 | _: S 6 | 7 | @external 8 | def createEvent(x: uint256): 9 | log E(S({a: x})) 10 | 11 | # ---- 12 | # createEvent(uint256): 42 -> 13 | # ~ emit E((uint256)): 0x2a 14 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_struct_memory_v2-0.4.0.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | event E: 5 | s: S 6 | 7 | @external 8 | def createEvent(x: uint256): 9 | log E(S(a=x)) 10 | 11 | # ---- 12 | # createEvent(uint256): 42 -> 13 | # ~ emit E((uint256)): 0x2a 14 | -------------------------------------------------------------------------------- /vyper/ethereum/events/event_struct_memory_v2.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | event E: 5 | s: S 6 | 7 | @external 8 | def createEvent(x: uint256): 9 | log E(s=S(a=x)) 10 | 11 | # ---- 12 | # createEvent(uint256): 42 -> 13 | # ~ emit E((uint256)): 0x2a 14 | -------------------------------------------------------------------------------- /vyper/ethereum/expressions/exp_operator_const.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | return 2 ** 3 4 | 5 | # ---- 6 | # f() -> 8 7 | -------------------------------------------------------------------------------- /vyper/ethereum/expressions/exp_operator_const_signed.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> int256: 3 | return (-2) ** 3 4 | 5 | # ---- 6 | # f() -> -8 7 | -------------------------------------------------------------------------------- /vyper/ethereum/expressions/exp_zero_literal.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | return 0 ** 0 4 | 5 | # ---- 6 | # f() -> 1 7 | -------------------------------------------------------------------------------- /vyper/ethereum/expressions/unary_too_long_literal.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bool: 3 | return 0 < bitwise_not(bitwise_not(84926290883049832306107864558384249403874903260938453235235091622489261765859)) 4 | # ---- 5 | # f() -> true 6 | -------------------------------------------------------------------------------- /vyper/ethereum/fallback/falback_return.vy: -------------------------------------------------------------------------------- 1 | x: public(uint256) 2 | 3 | @external 4 | def __default__(): 5 | if self.x == 2: 6 | return 7 | self.x += 1 8 | # ---- 9 | # () 10 | # x() -> 1 11 | # () 12 | # x() -> 2 13 | # () 14 | # x() -> 2 15 | # () 16 | # x() -> 2 17 | -------------------------------------------------------------------------------- /vyper/ethereum/functionCall/external_function.vy: -------------------------------------------------------------------------------- 1 | @internal 2 | def f(a: uint256) -> uint256: 3 | return a 4 | 5 | @external 6 | def test(a: uint256, b: uint256) -> (uint256, uint256): 7 | return self.f(a + 7), b 8 | 9 | # ---- 10 | # test(uint256,uint256): 2, 3 -> 9, 3 11 | -------------------------------------------------------------------------------- /vyper/ethereum/functionCall/multiple_return_values.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def run(x1: bool, x2: uint256) -> (uint256, bool, uint256): 3 | return x2, x1, 0 4 | 5 | # ---- 6 | # run(bool,uint256): true, 0xcd -> 0xcd, true, 0 7 | -------------------------------------------------------------------------------- /vyper/ethereum/functionCall/transaction_status.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(): 3 | pass 4 | 5 | @external 6 | def g(): 7 | raise 8 | 9 | @external 10 | def h(_flag: bool): 11 | assert _flag 12 | 13 | # ---- 14 | # f() -> 15 | # g() -> FAILURE 16 | # h(): false -> FAILURE 17 | -------------------------------------------------------------------------------- /vyper/ethereum/functionCall/value_test.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return msg.value 5 | 6 | # ---- 7 | # f(), 1 ether -> 1000000000000000000 8 | # f(), 1 wei -> 1 9 | -------------------------------------------------------------------------------- /vyper/ethereum/getters/bytes-0.3.vy: -------------------------------------------------------------------------------- 1 | b: public(Bytes[10]) 2 | 3 | @external 4 | def __init__(): 5 | self.b = b"abc" 6 | 7 | # ---- 8 | # b() -> 0x20, 0x03, 0x6162630000000000000000000000000000000000000000000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/getters/bytes.vy: -------------------------------------------------------------------------------- 1 | b: public(Bytes[10]) 2 | 3 | @deploy 4 | def __init__(): 5 | self.b = b"abc" 6 | 7 | # ---- 8 | # b() -> 0x20, 0x03, 0x6162630000000000000000000000000000000000000000000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/getters/mapping-0.3.vy: -------------------------------------------------------------------------------- 1 | x: public(HashMap[uint256, HashMap[uint256, uint256]]) 2 | 3 | @external 4 | def __init__(): 5 | self.x[1][2] = 3 6 | 7 | # ---- 8 | # x(uint256,uint256): 1, 2 -> 3 9 | # x(uint256,uint256): 0, 0 -> 0 10 | -------------------------------------------------------------------------------- /vyper/ethereum/getters/mapping.vy: -------------------------------------------------------------------------------- 1 | x: public(HashMap[uint256, HashMap[uint256, uint256]]) 2 | 3 | @deploy 4 | def __init__(): 5 | self.x[1][2] = 3 6 | 7 | # ---- 8 | # x(uint256,uint256): 1, 2 -> 3 9 | # x(uint256,uint256): 0, 0 -> 0 10 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/assign_at_declaration-0.3.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint8) 2 | 3 | @external 4 | def __init__(): 5 | a = 2 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return convert(a, uint256) 11 | 12 | # ---- 13 | # f() -> 2 14 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/assign_at_declaration.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint8) 2 | 3 | @deploy 4 | def __init__(): 5 | a = 2 6 | 7 | @external 8 | @view 9 | def f() -> uint256: 10 | return convert(a, uint256) 11 | 12 | # ---- 13 | # f() -> 2 14 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/read_in_ctor-0.3.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint8) 2 | x: uint8 3 | 4 | @external 5 | def __init__(): 6 | a = 3 7 | self.x = a 8 | 9 | @external 10 | @view 11 | def readX() -> uint8: 12 | return self.x 13 | 14 | # ---- 15 | # readX() -> 3 16 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/read_in_ctor.vy: -------------------------------------------------------------------------------- 1 | a: immutable(uint8) 2 | x: uint8 3 | 4 | @deploy 5 | def __init__(): 6 | a = 3 7 | self.x = a 8 | 9 | @external 10 | @view 11 | def readX() -> uint8: 12 | return self.x 13 | 14 | # ---- 15 | # readX() -> 3 16 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/stub-0.3.vy: -------------------------------------------------------------------------------- 1 | x: immutable(uint256) 2 | y: immutable(uint256) 3 | 4 | @external 5 | def __init__(): 6 | x = 42 7 | y = 23 8 | 9 | @external 10 | @view 11 | def f() -> (uint256, uint256): 12 | return (x+x,y) 13 | 14 | # ---- 15 | # f() -> 84, 23 16 | -------------------------------------------------------------------------------- /vyper/ethereum/immutable/stub.vy: -------------------------------------------------------------------------------- 1 | x: immutable(uint256) 2 | y: immutable(uint256) 3 | 4 | @deploy 5 | def __init__(): 6 | x = 42 7 | y = 23 8 | 9 | @external 10 | @view 11 | def f() -> (uint256, uint256): 12 | return (x+x,y) 13 | 14 | # ---- 15 | # f() -> 84, 23 16 | -------------------------------------------------------------------------------- /vyper/ethereum/integer/small_signed_types.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def run() -> int256: 3 | return -10 * -20 4 | 5 | # ---- 6 | # run() -> 200 7 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/balance_with_balance-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 1000 wei -> 8 | # balance -> 1000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/balance_with_balance.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 1000 wei -> 8 | # balance -> 1000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/balance_with_balance2-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 1 ether -> 8 | # balance -> 1000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/balance_with_balance2.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | # ---- 7 | # constructor(), 1 ether -> 8 | # balance -> 1000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/balance_without_balance.vy: -------------------------------------------------------------------------------- 1 | # ---- 2 | # balance -> 0 3 | # balance: 0x0000000000000000000000000000000000000000 -> 0 4 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/builtins.vy: -------------------------------------------------------------------------------- 1 | # ---- 2 | # isoltest_builtin_test -> 0x1234 3 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/storage/storage_empty.vy: -------------------------------------------------------------------------------- 1 | # ---- 2 | # storageEmpty -> 1 3 | -------------------------------------------------------------------------------- /vyper/ethereum/isoltestTesting/storage/storage_nonempty.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | 3 | @external 4 | def set(_a: uint256): 5 | self.x = _a 6 | 7 | # ---- 8 | # storageEmpty -> 1 9 | # set(uint256): 1 -> 10 | # storageEmpty -> 0 11 | -------------------------------------------------------------------------------- /vyper/ethereum/literals/denominations.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = as_wei_value(1, "ether") + as_wei_value(1, "gwei") + as_wei_value(1, "wei") 2 | 3 | @external 4 | @view 5 | def f() -> uint256: 6 | return x 7 | 8 | # ---- 9 | # f() -> 1000000001000000001 10 | -------------------------------------------------------------------------------- /vyper/ethereum/literals/ether.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = as_wei_value(1, "ether") 2 | 3 | @external 4 | @view 5 | def f() -> uint256: 6 | return x 7 | 8 | # ---- 9 | # f() -> 1000000000000000000 10 | -------------------------------------------------------------------------------- /vyper/ethereum/literals/gwei.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = as_wei_value(1, "gwei") 2 | 3 | @external 4 | @view 5 | def f() -> uint256: 6 | return x 7 | 8 | # ---- 9 | # f() -> 1000000000 10 | -------------------------------------------------------------------------------- /vyper/ethereum/literals/wei.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = as_wei_value(1, "wei") 2 | 3 | @external 4 | @view 5 | def f() -> uint256: 6 | return x 7 | 8 | # ---- 9 | # f() -> 1 10 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_cleanup-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = convert(0x001f000000000000000000000000000000000000000000000000000000000000, uint256) 4 | x = shift(x, 8) 5 | x = shift(x, -256) 6 | return x 7 | 8 | # ---- 9 | # f() -> 0x0 10 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_cleanup.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = convert(0x001f000000000000000000000000000000000000000000000000000000000000, uint256) 4 | x = x << 8 5 | x = x >> 256 6 | return x 7 | 8 | # ---- 9 | # f() -> 0x0 10 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_cleanup_garbled-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = convert(0xff, uint256) 4 | x = shift(x, -8) 5 | return x 6 | 7 | # ---- 8 | # f() -> 0x0 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_cleanup_garbled.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = convert(0xff, uint256) 4 | x = x >> 8 5 | return x 6 | 7 | # ---- 8 | # f() -> 0x0 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_constant_left-0.3.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @external 4 | def __init__(): 5 | self.a = shift(convert(0x42, uint256), 8) 6 | 7 | # ---- 8 | # a() -> 0x4200 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_constant_left.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | self.a = convert(0x42, uint256) << 8 6 | 7 | # ---- 8 | # a() -> 0x4200 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_constant_right-0.3.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @external 4 | def __init__(): 5 | self.a = shift(convert(0x4200, uint256), -8) 6 | 7 | # ---- 8 | # a() -> 0x42 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_constant_right.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | self.a = convert(0x4200, uint256) >> 8 6 | 7 | # ---- 8 | # a() -> 0x42 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_overflow-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def leftU(x: uint256, y: uint16) -> uint256: 3 | return shift(x, convert(y, int16)) 4 | 5 | # ---- 6 | # leftU(uint256,uint16): 255, 256 -> 0 7 | # leftU(uint256,uint16): 255, 249 -> left(254) 8 | # leftU(uint256,uint16): 255, 0 -> 255 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shift_overflow.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def leftU(x: uint256, y: uint16) -> uint256: 3 | return x << y 4 | 5 | # ---- 6 | # leftU(uint256,uint16): 255, 256 -> 0 7 | # leftU(uint256,uint16): 255, 249 -> left(254) 8 | # leftU(uint256,uint16): 255, 0 -> 255 9 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shifts-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(x: uint256) -> uint256: 3 | return shift(x, 2) 4 | 5 | # ---- 6 | # f(uint256): 7 -> 28 7 | -------------------------------------------------------------------------------- /vyper/ethereum/operators/shifts/shifts.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(x: uint256) -> uint256: 3 | return x << 2 4 | 5 | # ---- 6 | # f(uint256): 7 -> 28 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/calldata_array_dynamic_invalid.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(a: DynArray[DynArray[uint256, 5], 5]) -> uint256: 3 | return 42 4 | 5 | # ---- 6 | # f(uint256[][]): 0x20, 1 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/calldata_array_invalid_length.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(x: DynArray[DynArray[uint256, 1208925819614629174706176], 5]) -> uint256: 3 | return len(x[0]) 4 | 5 | # ---- 6 | # f(uint256[][]): 0x20, 1, 0x20, 0x0100000000000000000000 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/calldata_tail_short.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(x: DynArray[DynArray[uint256, 5], 5]): 3 | _: DynArray[uint256, 5] = x[0] 4 | 5 | # ---- 6 | # f(uint256[][]): 0x20, 1, 0x20, 2, 0x42 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/empty_v1.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def g(msg_: String[100]): 3 | raise msg_ 4 | 5 | # ---- 6 | # g(string): 0x20, 0, "" -> FAILURE, hex"08c379a0", 0x20, 0 7 | # g(string): 0x20, 0 -> FAILURE, hex"08c379a0", 0x20, 0 8 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/ether_non_payable_function.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(): 3 | pass 4 | 5 | # ---- 6 | # f(), 1 ether -> FAILURE 7 | # () -> FAILURE 8 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/function_entry_checks_v1.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def t(_: uint256): 4 | pass 5 | 6 | # ---- 7 | # t(uint256) -> FAILURE 8 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/short_input_array.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(a: DynArray[uint256, 5]) -> uint256: 3 | return 7 4 | 5 | # ---- 6 | # f(uint256[]): 0x20, 1 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/short_input_bytes.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def e(a: Bytes[100]) -> uint256: 3 | return 7 4 | 5 | # ---- 6 | # e(bytes): 0x20, 7 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/revertStrings/unknown_sig_no_fallback.vy: -------------------------------------------------------------------------------- 1 | 2 | # ---- 3 | # (): hex"00" -> FAILURE 4 | -------------------------------------------------------------------------------- /vyper/ethereum/reverts/revert-0.3.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @external 4 | def __init__(): 5 | self.a = 42 6 | 7 | @external 8 | def f(): 9 | self.a = 1 10 | raise 11 | 12 | 13 | # ---- 14 | # f() -> FAILURE 15 | # a() -> 42 16 | -------------------------------------------------------------------------------- /vyper/ethereum/reverts/revert.vy: -------------------------------------------------------------------------------- 1 | a: public(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | self.a = 42 6 | 7 | @external 8 | def f(): 9 | self.a = 1 10 | raise 11 | 12 | 13 | # ---- 14 | # f() -> FAILURE 15 | # a() -> 42 16 | -------------------------------------------------------------------------------- /vyper/ethereum/reverts/simple_throw.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(x: uint256) -> uint256: 3 | if x > 10: 4 | return x + 10 5 | else: 6 | raise 7 | 8 | # ---- 9 | # f(uint256): 11 -> 21 10 | # f(uint256): 1 -> FAILURE 11 | -------------------------------------------------------------------------------- /vyper/ethereum/state/gasleft.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bool: 3 | return msg.gas > 0 4 | 5 | # ---- 6 | # f() -> true 7 | # f() -> true 8 | # f() -> true 9 | -------------------------------------------------------------------------------- /vyper/ethereum/state/msg_sender.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> address: 3 | return msg.sender 4 | 5 | # ---- 6 | # f() -> 0x1212121212121212121212121212120000000012 7 | -------------------------------------------------------------------------------- /vyper/ethereum/state/msg_value.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def f() -> uint256: 4 | return msg.value 5 | 6 | # ---- 7 | # f() -> 0 8 | # f(), 12 ether -> 12000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/state_var_initialization-0.3.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | k: public(uint256) 3 | 4 | @external 5 | def __init__(): 6 | self.i = 1 7 | self.k = 2 8 | self.i = self.i + self.i 9 | self.k = self.k - self.i 10 | 11 | # ---- 12 | # i() -> 2 13 | # k() -> 0 14 | -------------------------------------------------------------------------------- /vyper/ethereum/state_var_initialization.vy: -------------------------------------------------------------------------------- 1 | i: public(uint256) 2 | k: public(uint256) 3 | 4 | @deploy 5 | def __init__(): 6 | self.i = 1 7 | self.k = 2 8 | self.i = self.i + self.i 9 | self.k = self.k - self.i 10 | 11 | # ---- 12 | # i() -> 2 13 | # k() -> 0 14 | -------------------------------------------------------------------------------- /vyper/ethereum/storage/simple_accessor-0.3.vy: -------------------------------------------------------------------------------- 1 | data: public(uint256) 2 | 3 | @external 4 | def __init__(): 5 | self.data = 8 6 | 7 | # ---- 8 | # data() -> 8 9 | -------------------------------------------------------------------------------- /vyper/ethereum/storage/simple_accessor.vy: -------------------------------------------------------------------------------- 1 | data: public(uint256) 2 | 3 | @deploy 4 | def __init__(): 5 | self.data = 8 6 | 7 | # ---- 8 | # data() -> 8 9 | -------------------------------------------------------------------------------- /vyper/ethereum/strings/concat/string_concat_nested.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(a: String[100], b: String[100], c: String[100]) -> String[300]: 3 | return concat(concat(a, b), c) 4 | 5 | # ---- 6 | # f(string,string,string): 0x60, 0xa0, 0xe0, 2, "ab", 2, "ab", 2, "ab" -> 0x20, 6, "ababab" 7 | -------------------------------------------------------------------------------- /vyper/ethereum/strings/empty_string.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> String[100]: 4 | return "" 5 | 6 | # ---- 7 | # f() -> 0x20, 0 8 | -------------------------------------------------------------------------------- /vyper/ethereum/strings/string_escapes.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> bytes32: 4 | escapeCharacters: bytes32 = convert(b"\t\n\r\'\"\\", bytes32) 5 | return escapeCharacters 6 | 7 | # ---- 8 | # f() -> 0x090a0d27225c0000000000000000000000000000000000000000000000000000 9 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/calldata/calldata_struct.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | b: uint256 4 | 5 | @external 6 | @pure 7 | def f(s: S) -> (uint256, uint256): 8 | return s.a, s.b 9 | 10 | # ---- 11 | # f((uint256,uint256)): 42, 23 -> 42, 23 12 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/event-0.3.vy: -------------------------------------------------------------------------------- 1 | struct Item: 2 | x: uint256 3 | 4 | event Ev: 5 | _: Item 6 | 7 | @internal 8 | def o(): 9 | log Ev(Item({x: 1})) 10 | 11 | @external 12 | def f(): 13 | self.o() 14 | 15 | # ---- 16 | # f() -> 17 | # ~ emit Ev((uint256)): 0x01 18 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/event-0.4.0.vy: -------------------------------------------------------------------------------- 1 | struct Item: 2 | x: uint256 3 | 4 | event Ev: 5 | i: Item 6 | 7 | @internal 8 | def o(): 9 | log Ev(Item(x=1)) 10 | 11 | @external 12 | def f(): 13 | self.o() 14 | 15 | # ---- 16 | # f() -> 17 | # ~ emit Ev((uint256)): 0x01 18 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/event.vy: -------------------------------------------------------------------------------- 1 | struct Item: 2 | x: uint256 3 | 4 | event Ev: 5 | i: Item 6 | 7 | @internal 8 | def o(): 9 | log Ev(i=Item(x=1)) 10 | 11 | @external 12 | def f(): 13 | self.o() 14 | 15 | # ---- 16 | # f() -> 17 | # ~ emit Ev((uint256)): 0x01 18 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/global.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | b: uint256 4 | 5 | @external 6 | @pure 7 | def f(s: S) -> (uint256, uint256): 8 | return (s.a, s.b) 9 | 10 | # ---- 11 | # f((uint256,uint256)): 42, 23 -> 42, 23 12 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/lone_struct_array_type.vy: -------------------------------------------------------------------------------- 1 | struct s: 2 | a: uint256 3 | b: uint256 4 | 5 | @external 6 | def f() -> uint256: 7 | _: s[7][1] = empty(s[7][1]) # This is only the type, should not have any effect 8 | return 3 9 | 10 | # ---- 11 | # f() -> 3 12 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/memory_struct_named_constructor.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | x: bool 4 | 5 | @external 6 | def s() -> S: 7 | return S(x=True, a=8) 8 | 9 | # ---- 10 | # s() -> 8, true 11 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/multislot_struct_allocation-0.3.vy: -------------------------------------------------------------------------------- 1 | struct I: 2 | b: uint256 3 | c: uint256 4 | 5 | struct S: 6 | a: I 7 | 8 | @external 9 | def f() -> uint256: 10 | s: S = S({a: I({b: 1, c: 2})}) 11 | return s.a.c 12 | 13 | # ---- 14 | # f() -> 2 -------------------------------------------------------------------------------- /vyper/ethereum/structs/multislot_struct_allocation.vy: -------------------------------------------------------------------------------- 1 | struct I: 2 | b: uint256 3 | c: uint256 4 | 5 | struct S: 6 | a: I 7 | 8 | @external 9 | def f() -> uint256: 10 | s: S = S(a=I(b=1, c=2)) 11 | return s.a.c 12 | 13 | # ---- 14 | # f() -> 2 15 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/nested_struct_allocation-0.3.vy: -------------------------------------------------------------------------------- 1 | struct I: 2 | b: uint256 3 | c: uint256 4 | 5 | struct S: 6 | a: I 7 | 8 | @external 9 | def f() -> uint256: 10 | s: S = S({a: I({b: 1, c: 2})}) 11 | return s.a.b 12 | 13 | # ---- 14 | # f() -> 1 15 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/nested_struct_allocation.vy: -------------------------------------------------------------------------------- 1 | struct I: 2 | b: uint256 3 | c: uint256 4 | 5 | struct S: 6 | a: I 7 | 8 | @external 9 | def f() -> uint256: 10 | s: S = S(a=I(b=1, c=2)) 11 | return s.a.b 12 | 13 | # ---- 14 | # f() -> 1 15 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/simple_struct_allocation-0.3.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | @external 5 | def f() -> uint256: 6 | s: S = S({a: 1}) 7 | return s.a 8 | 9 | # ---- 10 | # f() -> 1 11 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/simple_struct_allocation.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | @external 5 | def f() -> uint256: 6 | s: S = S(a=1) 7 | return s.a 8 | 9 | # ---- 10 | # f() -> 1 11 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/struct_named_constructor.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | x: bool 4 | 5 | s: public(S) 6 | 7 | @external 8 | def __init__(): 9 | self.s = S(x=True, a=1) 10 | 11 | # ---- 12 | # s() -> 1, true 13 | -------------------------------------------------------------------------------- /vyper/ethereum/structs/struct_storage_to_mapping.vy: -------------------------------------------------------------------------------- 1 | struct S: 2 | a: uint256 3 | 4 | s: S 5 | m: HashMap[uint256, S] 6 | 7 | @external 8 | def f() -> bool: 9 | self.s.a = 12 10 | self.m[1] = self.s 11 | return self.m[1].a == 12 12 | 13 | # ---- 14 | # f() -> true 15 | -------------------------------------------------------------------------------- /vyper/ethereum/types/assign_calldata_value_type.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(x: uint256) -> (uint256, uint256): 4 | b: uint256 = x 5 | x = 42 6 | return (x, b) 7 | 8 | # ---- 9 | # f(uint256): 23 -> 42, 23 10 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_fixed_bytes_greater_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToBytes(input: bytes2) -> bytes4: 3 | return convert(input, bytes4) 4 | 5 | # ---- 6 | # bytesToBytes(bytes2): "ab" -> "ab" 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_fixed_bytes_smaller_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToBytes(input: bytes4) -> bytes2: 3 | return convert(input, bytes2) 4 | 5 | # ---- 6 | # bytesToBytes(bytes4): "abcd" -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_uint_greater_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToUint(s: bytes4) -> uint64: 3 | return convert(convert(s, uint32), uint64) 4 | 5 | # ---- 6 | # bytesToUint(bytes4): "abcd" -> 0x61626364 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_uint_same_min_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToUint(s: bytes1) -> uint8: 3 | return convert(s, uint8) 4 | 5 | # ---- 6 | # bytesToUint(bytes1): "a" -> 0x61 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_uint_same_type.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToUint(s: bytes32) -> uint256: 3 | return convert(s, uint256) 4 | 5 | # ---- 6 | # bytesToUint(bytes32): "abc2" -> left(0x61626332) 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_fixed_bytes_to_uint_smaller_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def bytesToUint(s: bytes4) -> uint16: 3 | return convert(convert(s, uint32), uint16) 4 | 5 | # ---- 6 | # bytesToUint(bytes4): "abcd" -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_uint_to_fixed_bytes_greater_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def UintToBytes(h: uint16) -> bytes8: 3 | return convert(convert(h, uint64), bytes8) 4 | 5 | # ---- 6 | # UintToBytes(uint16): 0x6162 -> "\x00\x00\x00\x00\x00\x00ab" 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_uint_to_fixed_bytes_same_min_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def UintToBytes(h: uint8) -> bytes1: 3 | return convert(h, bytes1) 4 | 5 | # ---- 6 | # UintToBytes(uint8): 0x61 -> "a" 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_uint_to_fixed_bytes_same_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def uintToBytes(h: uint256) -> bytes32: 3 | return convert(h, bytes32) 4 | 5 | # ---- 6 | # uintToBytes(uint256): left(0x616263) -> left(0x616263) 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/convert_uint_to_fixed_bytes_smaller_size.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def uintToBytes(h: uint256) -> bytes2: 3 | return convert(convert(h, uint16), bytes2) 4 | 5 | # ---- 6 | # uintToBytes(uint32): 0x61626364 -> FAILURE 7 | -------------------------------------------------------------------------------- /vyper/ethereum/types/packing_signed_types.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def run() -> int8: 3 | x: bytes1 = 0xfa 4 | return convert(x, int8) 5 | 6 | # ---- 7 | # run() -> 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa 8 | -------------------------------------------------------------------------------- /vyper/ethereum/variables/delete_local.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def delLocal() -> uint256: 3 | v: uint256 = 5 4 | v = empty(uint256) 5 | return v 6 | 7 | # ---- 8 | # delLocal() -> 0 9 | -------------------------------------------------------------------------------- /vyper/ethereum/variables/delete_locals.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def delLocal() -> (uint256, uint256): 3 | v: uint256 = 5 4 | w: uint256 = 6 5 | x: uint256 = 7 6 | v = empty(uint256) 7 | return w, x 8 | 9 | # ---- 10 | # delLocal() -> 6, 7 11 | -------------------------------------------------------------------------------- /vyper/ethereum/various/assignment_to_const_var_involving_expression.vy: -------------------------------------------------------------------------------- 1 | x: constant(uint256) = 291 + 1110 2 | 3 | @external 4 | def f() -> uint256: 5 | return x + 1 6 | 7 | # ---- 8 | # f() -> 0x57a 9 | -------------------------------------------------------------------------------- /vyper/ethereum/various/balance-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | @external 7 | def getBalance() -> uint256: 8 | return self.balance 9 | 10 | # ---- 11 | # constructor(), 23 wei -> 12 | # getBalance() -> 23 13 | -------------------------------------------------------------------------------- /vyper/ethereum/various/balance.vy: -------------------------------------------------------------------------------- 1 | @deploy 2 | @payable 3 | def __init__(): 4 | pass 5 | 6 | @external 7 | def getBalance() -> uint256: 8 | return self.balance 9 | 10 | # ---- 11 | # constructor(), 23 wei -> 12 | # getBalance() -> 23 13 | -------------------------------------------------------------------------------- /vyper/ethereum/various/decayed_tuple.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | (x) = 2 5 | return x 6 | 7 | # ---- 8 | # f() -> 2 9 | -------------------------------------------------------------------------------- /vyper/ethereum/various/empty_name_return_parameter.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f(k: uint256) -> uint256: 3 | return k 4 | 5 | # ---- 6 | # f(uint256): 9 -> 9 7 | -------------------------------------------------------------------------------- /vyper/ethereum/various/flipping_sign_tests-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bool: 3 | x: int256 = -2**255 4 | assert -x == x 5 | return True 6 | 7 | # ---- 8 | # f() -> FAILURE 9 | -------------------------------------------------------------------------------- /vyper/ethereum/various/flipping_sign_tests.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> bool: 3 | x: int256 = min_value(int256) 4 | assert -x == x 5 | return True 6 | 7 | # ---- 8 | # f() -> FAILURE 9 | -------------------------------------------------------------------------------- /vyper/ethereum/various/inline_tuple_with_rational_numbers.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> int8: 3 | foo3: int8[5] = [1, -1, 0, 0, 0] 4 | return foo3[0] 5 | 6 | # ---- 7 | # f() -> 1 8 | -------------------------------------------------------------------------------- /vyper/ethereum/various/memory_overwrite.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> Bytes[100]: 3 | x: Bytes[100] = b"12345" 4 | x = b"123\x615" 5 | x = b"\x6223\x615" 6 | return x 7 | 8 | # ---- 9 | # f() -> 0x20, 5, "b23a5" 10 | -------------------------------------------------------------------------------- /vyper/ethereum/various/positive_integers_to_signed-0.3.vy: -------------------------------------------------------------------------------- 1 | x: public(int8) 2 | y: public(int8) 3 | q: public(int16) 4 | 5 | @external 6 | def __init__(): 7 | self.x = 2 8 | self.y = 127 9 | self.q = 250 10 | 11 | # ---- 12 | # x() -> 2 13 | # y() -> 127 14 | # q() -> 250 15 | -------------------------------------------------------------------------------- /vyper/ethereum/various/positive_integers_to_signed.vy: -------------------------------------------------------------------------------- 1 | x: public(int8) 2 | y: public(int8) 3 | q: public(int16) 4 | 5 | @deploy 6 | def __init__(): 7 | self.x = 2 8 | self.y = 127 9 | self.q = 250 10 | 11 | # ---- 12 | # x() -> 2 13 | # y() -> 127 14 | # q() -> 250 15 | -------------------------------------------------------------------------------- /vyper/ethereum/various/state_variable_local_variable_mixture.vy: -------------------------------------------------------------------------------- 1 | x: uint256 2 | y: uint256 3 | 4 | @deploy 5 | def __init__(): 6 | self.x = 1 7 | self.y = 2 8 | 9 | @external 10 | def a() -> uint256: 11 | x: uint256 = self.y 12 | return x 13 | 14 | # ---- 15 | # a() -> 2 16 | -------------------------------------------------------------------------------- /vyper/ethereum/various/storage_string_as_mapping_key_without_variable.vy: -------------------------------------------------------------------------------- 1 | data: HashMap[String[100], uint256] 2 | 3 | @external 4 | def f() -> uint256: 5 | self.data["abc"] = 2 6 | return self.data["abc"] 7 | 8 | # ---- 9 | # f() -> 2 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/array_2d_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(n: uint256) -> uint256: 4 | a: uint256[3][2] = empty(uint256[3][2]) 5 | a[1][1] = n 6 | b: uint256[3] = a[1] 7 | return b[1] 8 | 9 | # ---- 10 | # f(uint256): 42 -> 42 11 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/array_2d_new.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(n: uint256) -> uint256: 4 | a: uint256[3][2] = empty(uint256[3][2]) 5 | a[0][0] = n 6 | return a[0][0] 7 | 8 | # ---- 9 | # f(uint256): 42 -> 42 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/array_3d_new.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(n: uint256) -> uint256: 4 | a: uint256[4][3][2] = empty(uint256[4][3][2]) 5 | a[1][1][1] = n 6 | return a[1][1][1] 7 | 8 | # ---- 9 | # f(uint256): 42 -> 42 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/array_memory_create.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def create_() -> uint256: 3 | array: uint256[7] = empty(uint256[7]) 4 | return 7 5 | 6 | # ---- 7 | # create_() -> 7 8 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/array_storage_pop_zero_length.vy: -------------------------------------------------------------------------------- 1 | storageArray: DynArray[uint256, 5] 2 | 3 | @external 4 | def popEmpty(): 5 | self.storageArray.pop() 6 | 7 | # ---- 8 | # popEmpty() -> FAILURE 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/assert_and_require.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: bool) -> bool: 4 | b: bool = a 5 | x: bool = b 6 | assert b 7 | return x 8 | 9 | # ---- 10 | # f(bool): true -> true 11 | # f(bool): false -> FAILURE 12 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/conversion/explicit_cast_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> uint16: 4 | y: uint8 = convert(0x78, uint8) 5 | return convert(y, uint16) 6 | 7 | # ---- 8 | # f() -> 0x78 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/conversion/explicit_cast_local_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint8: 4 | b: uint8 = convert(a, uint8) 5 | return b 6 | 7 | # ---- 8 | # f(uint256): 0x12345678 -> FAILURE 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/local_address_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: address) -> address: 4 | b: address = a 5 | return b 6 | 7 | # ---- 8 | # f(address): 0x1234 -> 0x1234 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/local_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256) -> uint256: 4 | b: uint256 = a 5 | return b 6 | 7 | # ---- 8 | # f(uint256): 6 -> 6 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/local_bool_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: bool) -> bool: 4 | b: bool = a 5 | return b 6 | 7 | # ---- 8 | # f(bool): true -> true 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/local_variable_without_init.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> uint256: 4 | x: uint256 = empty(uint256) 5 | return x 6 | 7 | # ---- 8 | # f() -> 0 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/break-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a in range(10): 5 | x = x + x 6 | break 7 | return x 8 | 9 | # ---- 10 | # f() -> 2 11 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/break.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a: uint256 in range(10): 5 | x = x + x 6 | break 7 | return x 8 | 9 | # ---- 10 | # f() -> 2 11 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/continue-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a in range(10): 5 | continue 6 | x = x + x 7 | x = x + 10 8 | return x 9 | 10 | # ---- 11 | # f() -> 11 12 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/continue.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a: uint256 in range(10): 5 | continue 6 | x = x + 10 7 | return x 8 | 9 | # ---- 10 | # f() -> 11 11 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/return-0.3.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a in range(10): 5 | return x 6 | x = x + x 7 | x = x + 10 8 | return x 9 | 10 | # ---- 11 | # f() -> 1 12 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/loops/return.vy: -------------------------------------------------------------------------------- 1 | @external 2 | def f() -> uint256: 3 | x: uint256 = 1 4 | for a: uint256 in range(10): 5 | return x 6 | x = x + 10 7 | return x 8 | 9 | # ---- 10 | # f() -> 1 11 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/mapping_string_key.vy: -------------------------------------------------------------------------------- 1 | map: HashMap[String[100], uint256] 2 | 3 | @external 4 | def set(s: String[100]): 5 | _: uint256 = self.map[s] 6 | 7 | # ---- 8 | # set(string): 0x20, 32, "01234567890123456789012345678901" -> 9 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/msg_sender.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @view 3 | def test() -> bool: 4 | x: address = empty(address) 5 | x = msg.sender 6 | return x == msg.sender 7 | 8 | # ---- 9 | # test() -> true 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/negation_bug.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(): 4 | _: int8 = -0 5 | # Used to incorrectly use the checked unary negation function and revert. 6 | __: int16 = (-(-128)) 7 | 8 | # ---- 9 | # f() -> 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/return.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> uint256: 4 | return 7 5 | 6 | # ---- 7 | # f() -> 7 8 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/return_and_convert.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f() -> uint256: 4 | b: uint8 = 0 5 | b = convert(0xff, uint8) 6 | return convert(b, uint256) 7 | 8 | # ---- 9 | # f() -> 255 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/simple_assignment.vy: -------------------------------------------------------------------------------- 1 | @external 2 | @pure 3 | def f(a: uint256, b: uint256) -> (uint256, uint256): 4 | x: uint256 = a 5 | y: uint256 = b 6 | return x, y 7 | 8 | # ---- 9 | # f(uint256,uint256): 5, 6 -> 5, 6 10 | -------------------------------------------------------------------------------- /vyper/ethereum/viaYul/smoke_test.vy: -------------------------------------------------------------------------------- 1 | 2 | # ---- 3 | # f() -> FAILURE 4 | -------------------------------------------------------------------------------- /vyper/simple/unused/cases-0.3.vy: -------------------------------------------------------------------------------- 1 | #! { "cases": [] } 2 | 3 | @external 4 | @pure 5 | def entry() -> uint256: 6 | return 1 7 | -------------------------------------------------------------------------------- /vyper/simple/unused/cases.vy: -------------------------------------------------------------------------------- 1 | #! { "cases": [] } 2 | 3 | @external 4 | @pure 5 | def entry() -> uint256: 6 | return 1 7 | --------------------------------------------------------------------------------