Problem: missing internal tx when debug trace tx

Author: mmsqe

tests/integration_tests/expected_constants.py

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "./BonusMultiplier.sol";
+
+contract BonusDistributor {
+    using SafeERC20 for ERC20;
+
+    ERC20 public bonusToken;
+    address public bonusMultiplier;
+
+    constructor(address _bonusToken) {
+        bonusToken = ERC20(_bonusToken);
+    }
+
+    function setBonusMultiplier(address _bonusMultiplier) public {
+        bonusMultiplier = _bonusMultiplier;
+    }
+
+    function distributeBonusWithEther(address recipient, uint256 amount, uint256 etherValue) public {
+        require(address(this).balance >= etherValue, "Insufficient Ether in distributor");
+        uint256 bonusAmount = amount / 10;
+
+        if (bonusMultiplier != address(0)) {
+            payable(bonusMultiplier).transfer(etherValue);
+            BonusMultiplier(payable(bonusMultiplier)).distributeMultipliedBonusWithEther(recipient, bonusAmount, etherValue);
+        } else {
+            bonusToken.safeTransfer(recipient, bonusAmount);
+        }
+    }
+
+    receive() external payable {}
+}

tests/integration_tests/hardhat/contracts/BonusDistributor.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+contract BonusMultiplier {
+    using SafeERC20 for ERC20;
+
+    ERC20 public bonusToken;
+    uint256 public multiplier;
+
+    constructor(address _bonusToken) {
+        bonusToken = ERC20(_bonusToken);
+        multiplier = 2;
+    }
+
+    function setMultiplier(uint256 _multiplier) public {
+        multiplier = _multiplier;
+    }
+
+    function distributeMultipliedBonusWithEther(address recipient, uint256 amount, uint256 etherValue) public {
+        require(address(this).balance >= etherValue, "Insufficient Ether in multiplier");
+        bonusToken.safeTransfer(recipient, amount * multiplier);
+        payable(recipient).transfer(etherValue);
+    }
+
+    receive() external payable {}
+}

tests/integration_tests/hardhat/contracts/BonusMultiplier.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "./BonusDistributor.sol";
+
+contract TokenDistributor {
+    using SafeERC20 for ERC20;
+
+    ERC20 public token;
+    address public bonusDistributor;
+
+    constructor(address _token) {
+        token = ERC20(_token);
+    }
+
+    function setBonusDistributor(address _bonusDistributor) public {
+        bonusDistributor = _bonusDistributor;
+    }
+
+    function distributeTokens(address[] memory recipients, uint256[] memory amounts) public payable {
+        require(recipients.length == amounts.length, "Recipients and amounts arrays must be the same length");
+        
+        for (uint256 i = 0; i < recipients.length; i++) {
+            token.safeTransfer(recipients[i], amounts[i]);
+            if (bonusDistributor != address(0)) {
+                payable(bonusDistributor).transfer(msg.value);
+                BonusDistributor(payable(bonusDistributor)).distributeBonusWithEther(recipients[i], amounts[i], msg.value);
+            }
+        }
+    }
+}

tests/integration_tests/hardhat/contracts/TokenDistributor.sol

@@ -12,6 +12,7 @@
     EXPECTED_DEFAULT_GASCAP,
     EXPECTED_JS_TRACERS,
     EXPECTED_STRUCT_TRACER,
+    EXPECTED_TRACE_INTERNAL_TX,
 )
 from .utils import (
     ADDRS,
@@ -243,6 +244,74 @@ def wait_balance():
         assert "insufficient funds" not in res, res
 
 
+def test_trace_internal_tx(ethermint):
+    method = "debug_traceTransaction"
+    tracer = {"tracer": "callTracer"}
+    receiver = "0x0F0cb39319129BA867227e5Aae1abe9e7dd5f861"
+    acc = derive_new_account(12)
+    w3 = ethermint.w3
+    fund_acc(w3, acc, fund=100000000000000000000)
+    sender = acc.address
+    erc20, _ = deploy_contract(w3, CONTRACTS["TestERC20A"], key=acc.key)
+    bonus_token, _ = deploy_contract(w3, CONTRACTS["TestERC20A"], key=acc.key)
+    token_distributor, _ = deploy_contract(
+        w3, CONTRACTS["TokenDistributor"], (erc20.address,), key=acc.key
+    )
+    bonus_distributor, _ = deploy_contract(
+        w3, CONTRACTS["BonusDistributor"], (bonus_token.address,), key=acc.key
+    )
+    bonus_multiplier, _ = deploy_contract(
+        w3, CONTRACTS["BonusMultiplier"], (bonus_token.address,), key=acc.key
+    )
+    data = {"from": sender}
+    tx = token_distributor.functions.setBonusDistributor(
+        bonus_distributor.address
+    ).build_transaction(data)
+    receipt = send_transaction(w3, tx, acc.key)
+    assert receipt.status == 1
+    tx = bonus_distributor.functions.setBonusMultiplier(
+        bonus_multiplier.address
+    ).build_transaction(data)
+    receipt = send_transaction(w3, tx, acc.key)
+    assert receipt.status == 1
+
+    token_amt = 100
+    tx = erc20.functions.transfer(
+        token_distributor.address, token_amt
+    ).build_transaction(data)
+    receipt = send_transaction(w3, tx, acc.key)
+    assert receipt.status == 1
+    tx = bonus_token.functions.transfer(
+        bonus_multiplier.address, token_amt
+    ).build_transaction(data)
+    receipt = send_transaction(w3, tx, acc.key)
+    assert receipt.status == 1
+    balance = w3.eth.get_balance(receiver)
+    balance_erc20 = erc20.caller.balanceOf(receiver)
+    balance_bonus = bonus_token.caller.balanceOf(receiver)
+    amt = 25000000000000000000
+    tx = token_distributor.functions.distributeTokens(
+        [receiver], [token_amt]
+    ).build_transaction(
+        {
+            "from": sender,
+            "nonce": w3.eth.get_transaction_count(sender),
+            "gas": 1705533,
+            "gasPrice": 5001500000000,
+            "value": amt,
+        }
+    )
+    receipt = send_transaction(w3, tx, acc.key)
+    res = w3.provider.make_request(
+        method,
+        [receipt["transactionHash"], tracer],
+    )
+    assert res["result"] == EXPECTED_TRACE_INTERNAL_TX
+    assert w3.eth.get_balance(receiver) == balance + amt
+    assert erc20.caller.balanceOf(receiver) == balance_erc20 + token_amt
+    assert bonus_token.caller.balanceOf(receiver) == balance_bonus + token_amt * 0.2
+
+
 def test_tracecall_insufficient_funds(ethermint, geth):
     method = "debug_traceCall"
     acc = derive_random_account()

tests/integration_tests/test_tracers.py

@@ -46,6 +46,9 @@
     "TestBlockTxProperties": "TestBlockTxProperties.sol",
     "FeeCollector": "FeeCollector.sol",
     "SelfDestruct": "SelfDestruct.sol",
+    "TokenDistributor": "TokenDistributor.sol",
+    "BonusDistributor": "BonusDistributor.sol",
+    "BonusMultiplier": "BonusMultiplier.sol"
 }