test: dualVMToken uniswap test

solidity_contracts/src/CairoPrecompiles/DualVmToken.sol

@@ -99,9 +99,9 @@ contract DualVmToken {
         starknetToken = _starknetToken;
     }
 
-    //     /*//////////////////////////////////////////////////////////////
-    //                                ERC20 LOGIC
-    //     //////////////////////////////////////////////////////////////*/
+    /*//////////////////////////////////////////////////////////////
+                               ERC20 LOGIC
+    //////////////////////////////////////////////////////////////*/
 
     function approve(address spender, uint256 amount) external returns (bool) {
         uint256[] memory spenderAddressCalldata = new uint256[](1);
@@ -139,6 +139,8 @@ contract DualVmToken {
         transferCallData[2] = uint256(amountHigh);
 
         starknetToken.delegatecallCairo("transfer", transferCallData);
+
+        emit Transfer(msg.sender, to, amount);
         return true;
     }
 
@@ -165,7 +167,6 @@ contract DualVmToken {
         starknetToken.delegatecallCairo("transfer_from", transferFromCallData);
 
         emit Transfer(from, to, amount);
-
         return true;
     }
 }

solidity_contracts/src/CairoPrecompiles/SubContextPrecompile.sol

@@ -12,6 +12,7 @@ contract SubContextPrecompile {
 
     function exploitLowLevelCall() public {
         (bool success,) = address(revertingSubContext).call(abi.encodeWithSignature("reverting()"));
+        require(success == false);
     }
 
     function exploitChildContext() public {

tests/end_to_end/CairoPrecompiles/test_dual_vm_token.py

@@ -81,7 +81,15 @@ async def test_should_transfer(
             amount = 1
             balance_owner_before = await dual_vm_token.balanceOf(owner.address)
             balance_other_before = await dual_vm_token.balanceOf(other.address)
-            await dual_vm_token.transfer(other.address, amount)
+            receipt = (await dual_vm_token.transfer(other.address, amount))["receipt"]
+            events = dual_vm_token.events.parse_events(receipt)
+            assert events["Transfer"] == [
+                {
+                    "from": str(owner.address),
+                    "to": str(other.address),
+                    "amount": amount,
+                }
+            ]
             balance_owner_after = await dual_vm_token.balanceOf(owner.address)
             balance_other_after = await dual_vm_token.balanceOf(other.address)
 
@@ -95,7 +103,15 @@ async def test_should_approve(
             allowance_before = await dual_vm_token.allowance(
                 owner.address, other.address
             )
-            await dual_vm_token.approve(other.address, amount)
+            receipt = (await dual_vm_token.approve(other.address, amount))["receipt"]
+            events = dual_vm_token.events.parse_events(receipt)
+            assert events["Approval"] == [
+                {
+                    "owner": str(owner.address),
+                    "spender": str(other.address),
+                    "amount": amount,
+                }
+            ]
             allowance_after = await dual_vm_token.allowance(
                 owner.address, other.address
             )
@@ -108,9 +124,22 @@ async def test_should_transfer_from(
             balance_owner_before = await dual_vm_token.balanceOf(owner.address)
             balance_other_before = await dual_vm_token.balanceOf(other.address)
             await dual_vm_token.approve(other.address, amount)
-            await dual_vm_token.transferFrom(
-                owner.address, other.address, amount, caller_eoa=other.starknet_contract
-            )
+            receipt = (
+                await dual_vm_token.transferFrom(
+                    owner.address,
+                    other.address,
+                    amount,
+                    caller_eoa=other.starknet_contract,
+                )
+            )["receipt"]
+            events = dual_vm_token.events.parse_events(receipt)
+            assert events["Transfer"] == [
+                {
+                    "from": str(owner.address),
+                    "to": str(other.address),
+                    "amount": amount,
+                }
+            ]
             balance_owner_after = await dual_vm_token.balanceOf(owner.address)
             balance_other_after = await dual_vm_token.balanceOf(other.address)
 
@@ -126,3 +155,60 @@ async def test_should_revert_tx_cairo_precompiles(
                 await dual_vm_token.transfer(
                     other.address, 1, gas_limit=45_000
                 )  # fails with out of gas
+
+    class TestIntegrationUniswap:
+        async def test_should_add_liquidity_and_swap(
+            starknet_token, dual_vm_token, token_a, router, owner, other
+        ):
+            amount_a_desired = 1000 * await token_a.decimals()
+            amount_dual_vm_token_desired = 500 * await dual_vm_token.decimals()
+
+            await token_a.mint(owner.address, amount_a_desired)
+            await token_a.approve(
+                router.address, amount_a_desired * 2, caller_eoa=owner.starknet_contract
+            )
+            await dual_vm_token.approve(
+                router.address,
+                amount_dual_vm_token_desired * 2,
+                caller_eoa=owner.starknet_contract,
+            )
+
+            deadline = 99999999999
+            to_address = owner.address
+            success = (
+                await router.addLiquidity(
+                    token_a.address,
+                    dual_vm_token.address,
+                    amount_a_desired,
+                    amount_dual_vm_token_desired,
+                    0,
+                    0,
+                    to_address,
+                    deadline,
+                    caller_eoa=owner.starknet_contract,
+                )
+            )["success"]
+
+            assert success == 1
+
+            amount_dual_vm_token_desired = 5 * await dual_vm_token.decimals()
+
+            balance_other_before = await dual_vm_token.balanceOf(other.address)
+            amount_in_max = 2**128
+            success = (
+                await router.swapTokensForExactTokens(
+                    amount_dual_vm_token_desired,
+                    amount_in_max,
+                    [token_a.address, dual_vm_token.address],
+                    other.address,
+                    deadline,
+                    caller_eoa=owner.starknet_contract,
+                )
+            )["success"]
+            assert success == 1
+
+            balance_other_after = await dual_vm_token.balanceOf(other.address)
+            assert (
+                balance_other_before + amount_dual_vm_token_desired
+                == balance_other_after
+            )

tests/end_to_end/conftest.py

@@ -9,6 +9,7 @@
 from starknet_py.net.account.account import Account
 
 from kakarot_scripts.constants import NETWORK, RPC_CLIENT, NetworkType
+from kakarot_scripts.utils.kakarot import deploy as deploy_kakarot
 from kakarot_scripts.utils.kakarot import eth_balance_of
 from kakarot_scripts.utils.kakarot import get_contract as get_solidity_contract
 from kakarot_scripts.utils.kakarot import get_eoa
@@ -195,3 +196,35 @@ def relayers(worker_id):
     except ValueError:
         logger.info(f"Error while setting relayer index to {worker_id}")
     return
+
+
+# Uniswap fixtures
+
+TOTAL_SUPPLY = 10000 * 10**18
+
+
+@pytest_asyncio.fixture(scope="function")
+async def token_a(owner):
+    return await deploy_kakarot(
+        "UniswapV2",
+        "ERC20",
+        TOTAL_SUPPLY,
+        caller_eoa=owner.starknet_contract,
+    )
+
+
+@pytest_asyncio.fixture(scope="module")
+async def weth(owner):
+    return await deploy_kakarot("WETH", "WETH9")
+
+
+@pytest_asyncio.fixture(scope="module")
+async def factory(owner):
+    return await deploy_kakarot("UniswapV2", "UniswapV2Factory", owner.address)
+
+
+@pytest_asyncio.fixture(scope="module")
+async def router(owner, factory, weth):
+    return await deploy_kakarot(
+        "UniswapV2Router", "UniswapV2Router02", factory.address, weth.address
+    )