ETH Price: $3,889.48 (+1.91%)

Transaction Decoder

Block:
20924145 at Oct-08-2024 11:27:59 PM +UTC
Transaction Fee:
0.00299512266152688 ETH $11.65
Gas Used:
184,302 Gas / 16.25116744 Gwei

Emitted Events:

365 RocketTokenRETH.Transfer( from=[Sender] 0x1b882b1a34f1cecc0b0ba7379678a0984efd0bf7, to=ERC20Router, value=50871455237259476 )
366 RocketTokenRETH.Approval( owner=[Sender] 0x1b882b1a34f1cecc0b0ba7379678a0984efd0bf7, spender=[Receiver] ApprovalProxy, value=0 )
367 RocketTokenRETH.Approval( owner=ERC20Router, spender=ZeroEx, value=50871455237259476 )
368 WETH9.Transfer( src=UniswapV3Pool, dst=ZeroEx, wad=56896971067015993 )
369 RocketTokenRETH.Transfer( from=ERC20Router, to=UniswapV3Pool, value=50871455237259476 )
370 RocketTokenRETH.Approval( owner=ERC20Router, spender=ZeroEx, value=0 )
371 UniswapV3Pool.Swap( sender=ZeroEx, recipient=ZeroEx, amount0=50871455237259476, amount1=-56896971067015993, sqrtPriceX96=83793197613825412567944262437, liquidity=406617776828528397924974, tick=1120 )
372 WETH9.Withdrawal( src=ZeroEx, wad=56896971067015993 )

Account State Difference:

  Address   Before After State Difference Code
0x1B882b1A...84EFd0bf7
0.012274024855634365 Eth
Nonce: 207
0.009278902194107485 Eth
Nonce: 208
0.00299512266152688
(Titan Builder)
8.09507976065562938 Eth8.095432934486172074 Eth0.000353173830542694
0x553e9C49...2110Df823
(Uniswap V3: rETH 4)
0xae78736C...E74Fc6393
0xC02aaA39...83C756Cc2 2,964,484.907745345817664099 Eth2,964,484.850848374750648106 Eth0.056896971067015993
0xf70da978...8dfA3dbEF
(Relay: Solver)
330.482065521502309558 Eth330.538962492569325551 Eth0.056896971067015993

Execution Trace

ApprovalProxy.transferAndMulticall( tokens=[0xae78736Cd615f374D3085123A210448E74Fc6393], amounts=[50871455237259476], targets=[0xae78736Cd615f374D3085123A210448E74Fc6393, 0xDef1C0ded9bec7F1a1670819833240f027b25EfF], datas=[CV6nswAAAAAAAAAAAAAAAN7xwN7ZvsfxoWcIGYMyQPAnsl7/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQ=, gDuibQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyB4Ez8CxrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuueHNs1hXzdNMIUSOiEESOdPxjkwAAZMAqqjmyI/6NCg5cTyfq2Qg8dWzCAAAAAAAAAAAAAAAAAAAAAAAAAAAAhpWEzQAAAAAAAAAAAAAAAJTTJaazGue7ePQ/uX2kN8HD9C+WAAAAAAAAAAAAAAAAAAAAAAAAAAC0TyTd9YCGFxaNsOM=], values=[0, 0], refundTo=0xf70da97812CB96acDF810712Aa562db8dfA3dbEF ) => ( 0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000CA237E653EC339 )
  • RocketTokenRETH.transferFrom( sender=0x1B882b1A34F1CEcc0b0BA7379678a0984EFd0bf7, recipient=0xA1BEa5fe917450041748Dbbbe7E9AC57A4bBEBaB, amount=50871455237259476 ) => ( True )
    • RocketStorage.getUint( _key=04ADA4BD763F5E5A77200A6FD209F6BD95ACC84E44172EC7B5EAF3E04475C1C9 ) => ( r=0 )
    • ERC20Router.delegatecallMulticall( targets=[0xae78736Cd615f374D3085123A210448E74Fc6393, 0xDef1C0ded9bec7F1a1670819833240f027b25EfF], datas=[CV6nswAAAAAAAAAAAAAAAN7xwN7ZvsfxoWcIGYMyQPAnsl7/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQ=, gDuibQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyB4Ez8CxrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuueHNs1hXzdNMIUSOiEESOdPxjkwAAZMAqqjmyI/6NCg5cTyfq2Qg8dWzCAAAAAAAAAAAAAAAAAAAAAAAAAAAAhpWEzQAAAAAAAAAAAAAAAJTTJaazGue7ePQ/uX2kN8HD9C+WAAAAAAAAAAAAAAAAAAAAAAAAAAC0TyTd9YCGFxaNsOM=], values=[0, 0], refundTo=0xf70da97812CB96acDF810712Aa562db8dfA3dbEF ) => ( 0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000CA237E653EC339 )
      • Multicaller.aggregate( targets=[0xae78736Cd615f374D3085123A210448E74Fc6393, 0xDef1C0ded9bec7F1a1670819833240f027b25EfF], data=[CV6nswAAAAAAAAAAAAAAAN7xwN7ZvsfxoWcIGYMyQPAnsl7/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQ=, gDuibQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALS7UaqfwNQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyB4Ez8CxrgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuueHNs1hXzdNMIUSOiEESOdPxjkwAAZMAqqjmyI/6NCg5cTyfq2Qg8dWzCAAAAAAAAAAAAAAAAAAAAAAAAAAAAhpWEzQAAAAAAAAAAAAAAAJTTJaazGue7ePQ/uX2kN8HD9C+WAAAAAAAAAAAAAAAAAAAAAAAAAAC0TyTd9YCGFxaNsOM=], values=[0, 0], refundTo=0xf70da97812CB96acDF810712Aa562db8dfA3dbEF ) => ( [AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAE=, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMojfmU+wzk=] )
        • RocketTokenRETH.approve( spender=0xDef1C0ded9bec7F1a1670819833240f027b25EfF, amount=50871455237259476 ) => ( True )
        • ZeroEx.803ba26d( )
          • UniswapV3Feature.sellTokenForEthToUniswapV3( encodedPath=0xAE78736CD615F374D3085123A210448E74FC6393000064C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC2, sellAmount=50871455237259476, minBuyAmount=56328001356345774, recipient=0x0000000000000000000000000000000000000000 ) => ( buyAmount=56896971067015993 )
            • UniswapV3Pool.swap( recipient=0xDef1C0ded9bec7F1a1670819833240f027b25EfF, zeroForOne=True, amountSpecified=50871455237259476, sqrtPriceLimitX96=4295128740, data=0x000000000000000000000000AE78736CD615F374D3085123A210448E74FC6393000000000000000000000000C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC20000000000000000000000000000000000000000000000000000000000000064000000000000000000000000A1BEA5FE917450041748DBBBE7E9AC57A4BBEBAB ) => ( amount0=50871455237259476, amount1=-56896971067015993 )
              • WETH9.transfer( dst=0xDef1C0ded9bec7F1a1670819833240f027b25EfF, wad=56896971067015993 ) => ( True )
              • RocketTokenRETH.balanceOf( account=0x553e9C493678d8606d6a5ba284643dB2110Df823 ) => ( 535329004069603894801 )
              • ZeroEx.fa461e33( )
              • RocketTokenRETH.balanceOf( account=0x553e9C493678d8606d6a5ba284643dB2110Df823 ) => ( 535379875524841154277 )
              • WETH9.withdraw( wad=56896971067015993 )
                • ETH 0.056896971067015993 ZeroEx.CALL( )
                • ETH 0.056896971067015993 ERC20Router.CALL( )
                • ETH 0.056896971067015993 Relay: Solver.CALL( )
                  transferAndMulticall[ApprovalProxy (ln:37)]
                  File 1 of 9: ApprovalProxy
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: MIT
                  pragma solidity ^0.8.23;
                  import {Ownable} from "solady/src/auth/Ownable.sol";
                  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                  import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
                  import {IERC20Router} from "../src/types/interfaces/IERC20Router.sol";
                  contract ApprovalProxy is Ownable {
                  using SafeERC20 for IERC20;
                  error ArrayLengthsMismatch();
                  error ERC20TransferFromFailed();
                  error NativeTransferFailed();
                  event RouterUpdated(address newRouter);
                  address public router;
                  receive() external payable {}
                  constructor(address _owner, address _router) {
                  _initializeOwner(_owner);
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 2 of 9: ERC20Router
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: MIT
                  pragma solidity ^0.8.25;
                  import {Ownable} from "solady/src/auth/Ownable.sol";
                  import {Tstorish} from "tstorish/src/Tstorish.sol";
                  import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                  import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
                  import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
                  import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
                  import {IAllowanceTransfer} from "permit2-relay/src/interfaces/IAllowanceTransfer.sol";
                  import {ISignatureTransfer} from "permit2-relay/src/interfaces/ISignatureTransfer.sol";
                  import {IPermit2} from "permit2-relay/src/interfaces/IPermit2.sol";
                  import {RelayerWitness} from "./types/lib/RelayStructs.sol";
                  import {IMulticaller} from "./types/interfaces/IMulticaller.sol";
                  contract ERC20Router is Ownable, Tstorish {
                  using SafeERC20 for IERC20;
                  // --- Errors --- //
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 3 of 9: RocketTokenRETH
                  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;
                  /**
                  * @dev Wrappers over Solidity's arithmetic operations with added overflow
                  * checks.
                  *
                  * Arithmetic operations in Solidity wrap on overflow. This can easily result
                  * in bugs, because programmers usually assume that an overflow raises an
                  * error, which is the standard behavior in high level programming languages.
                  * `SafeMath` restores this intuition by reverting the transaction when an
                  * operation overflows.
                  *
                  * Using this library instead of the unchecked operations eliminates an entire
                  * class of bugs, so it's recommended to use it always.
                  */
                  library SafeMath {
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 4 of 9: UniswapV3Pool
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: BUSL-1.1
                  pragma solidity =0.7.6;
                  import './interfaces/IUniswapV3Pool.sol';
                  import './NoDelegateCall.sol';
                  import './libraries/LowGasSafeMath.sol';
                  import './libraries/SafeCast.sol';
                  import './libraries/Tick.sol';
                  import './libraries/TickBitmap.sol';
                  import './libraries/Position.sol';
                  import './libraries/Oracle.sol';
                  import './libraries/FullMath.sol';
                  import './libraries/FixedPoint128.sol';
                  import './libraries/TransferHelper.sol';
                  import './libraries/TickMath.sol';
                  import './libraries/LiquidityMath.sol';
                  import './libraries/SqrtPriceMath.sol';
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 5 of 9: 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 6 of 9: WETH9
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // Copyright (C) 2015, 2016, 2017 Dapphub
                  // This program is free software: you can redistribute it and/or modify
                  // it under the terms of the GNU General Public License as published by
                  // the Free Software Foundation, either version 3 of the License, or
                  // (at your option) any later version.
                  // This program is distributed in the hope that it will be useful,
                  // but WITHOUT ANY WARRANTY; without even the implied warranty of
                  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
                  // GNU General Public License for more details.
                  // You should have received a copy of the GNU General Public License
                  // along with this program. If not, see <http://www.gnu.org/licenses/>.
                  pragma solidity ^0.4.18;
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 7 of 9: RocketStorage
                  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;
                  /**
                  * @dev Wrappers over Solidity's arithmetic operations with added overflow
                  * checks.
                  *
                  * Arithmetic operations in Solidity wrap on overflow. This can easily result
                  * in bugs, because programmers usually assume that an overflow raises an
                  * error, which is the standard behavior in high level programming languages.
                  * `SafeMath` restores this intuition by reverting the transaction when an
                  * operation overflows.
                  *
                  * Using this library instead of the unchecked operations eliminates an entire
                  * class of bugs, so it's recommended to use it always.
                  */
                  library SafeMath {
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 8 of 9: Multicaller
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: MIT
                  pragma solidity ^0.8.4;
                  /**
                  * @title Multicaller
                  * @author vectorized.eth
                  * @notice Contract that allows for efficient aggregation
                  * of multiple calls in a single transaction.
                  */
                  contract Multicaller {
                  // =============================================================
                  // ERRORS
                  // =============================================================
                  /**
                  * @dev The lengths of the input arrays are not the same.
                  */
                  error ArrayLengthsMismatch();
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 9 of 9: UniswapV3Feature
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: Apache-2.0
                  /*
                  Copyright 2023 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 <0.9;
                  interface IERC20Token {
                  event Transfer(address indexed from, address indexed to, uint256 value);
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX