ETH Price: $2,989.15 (+0.52%)

Transaction Decoder

Block:
22704642 at Jun-14-2025 06:39:59 PM +UTC
Transaction Fee:
0.000060336694021728 ETH $0.18
Gas Used:
114,284 Gas / 0.527953992 Gwei

Emitted Events:

135 DSToken.Transfer( src=[Sender] 0x9260b8321f7e8dfa7b3dfebb0167058d7eec1966, dst=UniswapV2Pair, wad=10000000000000000000000 )
136 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x000000000000000000000000dae6e55d4aadc3cc7dd35c3e23245974535bea46, 0x0000000000000000000000009260b8321f7e8dfa7b3dfebb0167058d7eec1966, 000000000000000000000000000000000000000000000015b333413522a28bd9 )
137 UniswapV2Pair.Sync( reserve0=70746672734888700850026, reserve1=1772064107007183641149576 )
138 UniswapV2Pair.Swap( sender=[Receiver] ZeroEx, amount0In=0, amount1In=10000000000000000000000, amount0Out=400294361800972078041, amount1Out=0, to=[Sender] 0x9260b8321f7e8dfa7b3dfebb0167058d7eec1966 )

Account State Difference:

  Address   Before After State Difference Code
0x0a5E677a...31d2fDEc8
0x431ad2ff...8d6f7DBe0
(MEV Builder: 0x7dbf...c6c)
1.08712759796621365 Eth1.087139192065670978 Eth0.000011594099457328
0x9260B832...D7eec1966
0.045909305855825309 Eth
Nonce: 595
0.045848969161803581 Eth
Nonce: 596
0.000060336694021728
0xdAE6E55D...4535BEA46

Execution Trace

ZeroEx.d9627aa4( )
  • UniswapFeature.sellToUniswap( tokens=[0x431ad2ff6a9C365805eBaD47Ee021148d6f7DBe0, 0x0a5E677a6A24b2F1A2Bf4F3bFfC443231d2fDEc8], sellAmount=10000000000000000000000, minBuyAmount=396291418182962357260, isSushi=False ) => ( buyAmount=400294361800972078041 )
    • DSToken.transferFrom( src=0x9260B8321F7e8dfa7B3dfebB0167058D7eec1966, dst=0xdAE6E55D4AaDc3cC7Dd35c3E23245974535BEA46, wad=10000000000000000000000 ) => ( True )
    • UniswapV2Pair.STATICCALL( )
    • UniswapV2Pair.swap( amount0Out=400294361800972078041, amount1Out=0, to=0x9260B8321F7e8dfa7B3dfebB0167058D7eec1966, data=0x )
      • TransparentUpgradeableProxy.a9059cbb( )
        • MSD.transfer( recipient=0x9260B8321F7e8dfa7B3dfebB0167058D7eec1966, amount=400294361800972078041 ) => ( True )
        • TransparentUpgradeableProxy.70a08231( )
          • MSD.balanceOf( 0xdAE6E55D4AaDc3cC7Dd35c3E23245974535BEA46 ) => ( 70746672734888700850026 )
          • DSToken.balanceOf( src=0xdAE6E55D4AaDc3cC7Dd35c3E23245974535BEA46 ) => ( 1772064107007183641149576 )
            File 1 of 6: ZeroEx
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            /*
            Copyright 2020 ZeroEx Intl.
            Licensed under the Apache License, Version 2.0 (the "License");
            you may not use this file except in compliance with the License.
            You may obtain a copy of the License at
            http://www.apache.org/licenses/LICENSE-2.0
            Unless required by applicable law or agreed to in writing, software
            distributed under the License is distributed on an "AS IS" BASIS,
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
            */
            pragma solidity ^0.6.5;
            pragma experimental ABIEncoderV2;
            import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
            import "./migrations/LibBootstrap.sol";
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

            File 2 of 6: UniswapV2Pair
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            // File: contracts/interfaces/IUniswapV2Pair.sol
            pragma solidity >=0.5.0;
            interface IUniswapV2Pair {
            event Approval(address indexed owner, address indexed spender, uint value);
            event Transfer(address indexed from, address indexed to, uint value);
            function name() external pure returns (string memory);
            function symbol() external pure returns (string memory);
            function decimals() external pure returns (uint8);
            function totalSupply() external view returns (uint);
            function balanceOf(address owner) external view returns (uint);
            function allowance(address owner, address spender) external view returns (uint);
            function approve(address spender, uint value) external returns (bool);
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

            File 3 of 6: DSToken
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            pragma solidity ^0.5.2;
            contract DSMath {
            function add(uint x, uint y) internal pure returns (uint z) {
            require((z = x + y) >= x, "ds-math-add-overflow");
            }
            function sub(uint x, uint y) internal pure returns (uint z) {
            require((z = x - y) <= x, "ds-math-sub-underflow");
            }
            function mul(uint x, uint y) internal pure returns (uint z) {
            require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
            }
            function div(uint x, uint y) internal pure returns (uint z) {
            require(y > 0, "ds-math-div-overflow");
            z = x / y;
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

            File 4 of 6: TransparentUpgradeableProxy
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            // SPDX-License-Identifier: MIT
            pragma solidity >=0.6.0 <0.8.0;
            import "./UpgradeableProxy.sol";
            /**
            * @dev This contract implements a proxy that is upgradeable by an admin.
            *
            * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
            * clashing], which can potentially be used in an attack, this contract uses the
            * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
            * things that go hand in hand:
            *
            * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
            * that call matches one of the admin functions exposed by the proxy itself.
            * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
            * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
            * "admin cannot fallback to proxy target".
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

            File 5 of 6: UniswapFeature
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            // SPDX-License-Identifier: Apache-2.0
            /*
            Copyright 2020 ZeroEx Intl.
            Licensed under the Apache License, Version 2.0 (the "License");
            you may not use this file except in compliance with the License.
            You may obtain a copy of the License at
            http://www.apache.org/licenses/LICENSE-2.0
            Unless required by applicable law or agreed to in writing, software
            distributed under the License is distributed on an "AS IS" BASIS,
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
            */
            pragma solidity ^0.6.5;
            pragma experimental ABIEncoderV2;
            import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

            File 6 of 6: MSD
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            // SPDX-License-Identifier: MIT
            pragma solidity 0.6.12;
            import "@openzeppelin/contracts-upgradeable/utils/EnumerableSetUpgradeable.sol";
            import "../library/Initializable.sol";
            import "../library/Ownable.sol";
            import "../library/ERC20.sol";
            /**
            * @title dForce's Multi-currency Stable Debt Token
            * @author dForce
            */
            contract MSD is Initializable, Ownable, ERC20 {
            using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
            bytes32 public DOMAIN_SEPARATOR;
            // keccak256("Permit(address owner,address spender,uint256 chainId, uint256 value,uint256 nonce,uint256 deadline)");
            bytes32 public constant PERMIT_TYPEHASH =
            0x576144ed657c8304561e56ca632e17751956250114636e8c01f64a7f2c6d98cf;
            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX