ETH Price: $3,739.30 (+2.93%)

Transaction Decoder

Block:
19206936 at Feb-11-2024 07:36:35 PM +UTC
Transaction Fee:
0.0051985263602309 ETH $19.44
Gas Used:
138,650 Gas / 37.493879266 Gwei

Account State Difference:

  Address   Before After State Difference Code
(Titan Builder)
91.048954064958303577 Eth91.048957018498489427 Eth0.00000295354018585
0xAE3642A0...f1BFdddd3
0.226342658794746925 Eth
Nonce: 42
0.221144132434516025 Eth
Nonce: 43
0.0051985263602309

Execution Trace

PendleRouterV3.12599ac6( )
  • ActionAddRemoveLiqV3.addLiquiditySingleToken( receiver=0xAE3642A03a1e4bd7AB7D919d14C54ECf1BFdddd3, market=0xF32e58F92e60f4b0A37A69b95d642A471365EAe8, minLpOut=252761242784261445, guessPtReceivedFromSy=[{name:guessMin, type:uint256, order:1, indexed:false, value:304612049412574139, valueString:304612049412574139}, {name:guessMax, type:uint256, order:2, indexed:false, value:313796026166672442, valueString:313796026166672442}, {name:guessOffchain, type:uint256, order:3, indexed:false, value:306142763228717728, valueString:306142763228717728}, {name:maxIteration, type:uint256, order:4, indexed:false, value:12, valueString:12}, {name:eps, type:uint256, order:5, indexed:false, value:100000000000000, valueString:100000000000000}], input=[{name:tokenIn, type:address, order:1, indexed:false, value:0x35fA164735182de50811E8e2E824cFb9B6118ac2, valueString:0x35fA164735182de50811E8e2E824cFb9B6118ac2}, {name:netTokenIn, type:uint256, order:2, indexed:false, value:499999999999999999, valueString:499999999999999999}, {name:tokenMintSy, type:address, order:3, indexed:false, value:0x35fA164735182de50811E8e2E824cFb9B6118ac2, valueString:0x35fA164735182de50811E8e2E824cFb9B6118ac2}, {name:pendleSwap, type:address, order:4, indexed:false, value:0x0000000000000000000000000000000000000000, valueString:0x0000000000000000000000000000000000000000}, {name:swapData, type:tuple, order:5, indexed:false, value:[{name:swapType, type:uint8, order:1, indexed:false, value:0, valueString:0}, {name:extRouter, type:address, order:2, indexed:false, value:0x0000000000000000000000000000000000000000, valueString:0x0000000000000000000000000000000000000000}, {name:extCalldata, type:bytes, order:3, indexed:false, value:0x, valueString:0x}, {name:needScale, type:bool, order:4, indexed:false, value:false, valueString:False}], valueString:[{name:swapType, type:uint8, order:1, indexed:false, value:0, valueString:0}, {name:extRouter, type:address, order:2, indexed:false, value:0x0000000000000000000000000000000000000000, valueString:0x0000000000000000000000000000000000000000}, {name:extCalldata, type:bytes, order:3, indexed:false, value:0x, valueString:0x}, {name:needScale, type:bool, order:4, indexed:false, value:false, valueString:False}]}], limit=[{name:limitRouter, type:address, order:1, indexed:false, value:0x0000000000000000000000000000000000000000, valueString:0x0000000000000000000000000000000000000000}, {name:epsSkipMarket, type:uint256, order:2, indexed:false, value:0, valueString:0}, {name:normalFills, type:tuple[], order:3, indexed:false}, {name:flashFills, type:tuple[], order:4, indexed:false}, {name:optData, type:bytes, order:5, indexed:false, value:0x, valueString:0x}] )
    • PendleMarketV3.STATICCALL( )
    • UUPSProxy.23b872dd( )
      • EETH.transferFrom( _sender=0xAE3642A03a1e4bd7AB7D919d14C54ECf1BFdddd3, _recipient=0x00000000005BBB0EF59571E58418F9a4357b68A0, _amount=499999999999999999 ) => ( True )
        • UUPSProxy.3a53acb0( )
          • LiquidityPool.sharesForAmount( _amount=499999999999999999 ) => ( 484959100663541747 )
            • UUPSProxy.STATICCALL( )
            • UUPSProxy.dd62ed3e( )
              • EETH.allowance( _owner=0x00000000005BBB0EF59571E58418F9a4357b68A0, _spender=0xAC0047886a985071476a1186bE89222659970d65 ) => ( 115792089237316195423570985008687907853269984665640563895316522684044516221924 )
              • PendleWEEthSY.deposit( receiver=0xF32e58F92e60f4b0A37A69b95d642A471365EAe8, tokenIn=0x35fA164735182de50811E8e2E824cFb9B6118ac2, amountTokenToDeposit=499999999999999999, minSharesOut=1 )
                • UUPSProxy.23b872dd( )
                  • EETH.transferFrom( _sender=0x00000000005BBB0EF59571E58418F9a4357b68A0, _recipient=0xAC0047886a985071476a1186bE89222659970d65, _amount=499999999999999999 ) => ( True )
                    • UUPSProxy.3a53acb0( )
                      • LiquidityPool.sharesForAmount( _amount=499999999999999999 ) => ( 484959100663541747 )
                      • UUPSProxy.70a08231( )
                        • EETH.balanceOf( _user=0xAC0047886a985071476a1186bE89222659970d65 ) => ( 499999999999999999 )
                          • UUPSProxy.51199700( )
                            • LiquidityPool.getTotalEtherClaimOf( _user=0xAC0047886a985071476a1186bE89222659970d65 ) => ( 499999999999999999 )
                              File 1 of 8: PendleRouterV3
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
                              pragma solidity ^0.8.0;
                              /**
                              * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
                              * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
                              * be specified by overriding the virtual {_implementation} function.
                              *
                              * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
                              * different contract through the {_delegate} function.
                              *
                              * The success and return data of the delegated call will be returned back to the caller of the proxy.
                              */
                              abstract contract Proxy {
                              /**
                              * @dev Delegates the current call to `implementation`.
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 2 of 8: ActionAddRemoveLiqV3
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
                              pragma solidity ^0.8.0;
                              import "../IERC20.sol";
                              /**
                              * @dev Interface for the optional metadata functions from the ERC20 standard.
                              *
                              * _Available since v4.1._
                              */
                              interface IERC20Metadata is IERC20 {
                              /**
                              * @dev Returns the name of the token.
                              */
                              function name() external view returns (string memory);
                              /**
                              * @dev Returns the symbol of the token.
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 3 of 8: PendleMarketV3
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)
                              pragma solidity ^0.8.0;
                              interface IERC5267 {
                              /**
                              * @dev MAY be emitted to signal that the domain could have changed.
                              */
                              event EIP712DomainChanged();
                              /**
                              * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
                              * signature.
                              */
                              function eip712Domain()
                              external
                              view
                              returns (
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 4 of 8: UUPSProxy
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              pragma solidity 0.8.13;
                              import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
                              contract UUPSProxy is ERC1967Proxy {
                              constructor(
                              address _implementation,
                              bytes memory _data
                              ) ERC1967Proxy(_implementation, _data) {}
                              }
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
                              pragma solidity ^0.8.0;
                              import "../Proxy.sol";
                              import "./ERC1967Upgrade.sol";
                              /**
                              * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 5 of 8: EETH
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              pragma solidity 0.8.13;
                              import "@openzeppelin-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/utils/cryptography/EIP712Upgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/utils/CountersUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/utils/cryptography/ECDSAUpgradeable.sol";
                              import "./interfaces/IeETH.sol";
                              import "./interfaces/ILiquidityPool.sol";
                              contract EETH is IERC20Upgradeable, UUPSUpgradeable, OwnableUpgradeable, IERC20PermitUpgradeable, IeETH {
                              using CountersUpgradeable for CountersUpgradeable.Counter;
                              ILiquidityPool public liquidityPool;
                              uint256 public totalShares;
                              mapping (address => uint256) public shares;
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 6 of 8: UUPSProxy
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              pragma solidity 0.8.13;
                              import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
                              contract UUPSProxy is ERC1967Proxy {
                              constructor(
                              address _implementation,
                              bytes memory _data
                              ) ERC1967Proxy(_implementation, _data) {}
                              }
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
                              pragma solidity ^0.8.0;
                              import "../Proxy.sol";
                              import "./ERC1967Upgrade.sol";
                              /**
                              * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 7 of 8: LiquidityPool
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              pragma solidity 0.8.13;
                              import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                              import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
                              import "@openzeppelin-upgradeable/contracts/token/ERC20/IERC20Upgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/token/ERC721/IERC721ReceiverUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/proxy/utils/Initializable.sol";
                              import "@openzeppelin-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol";
                              import "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";
                              import "./interfaces/IRegulationsManager.sol";
                              import "./interfaces/IStakingManager.sol";
                              import "./interfaces/IEtherFiNodesManager.sol";
                              import "./interfaces/IeETH.sol";
                              import "./interfaces/IStakingManager.sol";
                              import "./interfaces/IMembershipManager.sol";
                              import "./interfaces/ITNFT.sol";
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                              File 8 of 8: PendleWEEthSY
                              1
                              2
                              3
                              4
                              5
                              6
                              7
                              8
                              9
                              10
                              11
                              12
                              13
                              14
                              15
                              16
                              // SPDX-License-Identifier: MIT
                              // OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)
                              pragma solidity ^0.8.2;
                              import "../../utils/AddressUpgradeable.sol";
                              /**
                              * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                              * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                              * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                              * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                              *
                              * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                              * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                              * case an upgrade adds a module that needs to be initialized.
                              *
                              * For example:
                              *
                              XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX