ETH Price: $4,263.56 (+0.89%)

Transaction Decoder

Block:
17420770 at Jun-06-2023 10:18:11 AM +UTC
Transaction Fee:
0.004295123600725701 ETH $18.31
Gas Used:
211,851 Gas / 20.274266351 Gwei

Emitted Events:

41 WETH9.Deposit( dst=ZeroEx, wad=110027341794440000 )
42 WETH9.Transfer( src=ZeroEx, dst=UniswapV2Pair, wad=110027341794440000 )
43 FiatTokenProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x000000000000000000000000b4e16d0168e52d35cacd2c6185b44281ec28c9dc, 0x0000000000000000000000005083b16da538c5022744526122243cf3bddb3bf2, 000000000000000000000000000000000000000000000000000000000be37cf3 )
44 UniswapV2Pair.Sync( reserve0=27561887626113, reserve1=15158504328247597461449 )
45 UniswapV2Pair.Swap( sender=ZeroEx, amount0In=0, amount1In=110027341794440000, amount0Out=199458035, amount1Out=0, to=UniswapV2Pair )
46 AliERC20v2.Transfer( by=UniswapV2Pair, from=UniswapV2Pair, to=[Receiver] ZeroExProxy, value=7648990390651603741659 )
47 AliERC20v2.Transfer( from=UniswapV2Pair, to=[Receiver] ZeroExProxy, value=7648990390651603741659 )
48 UniswapV2Pair.Sync( reserve0=5137919082390177767273651, reserve1=133775890250 )
49 UniswapV2Pair.Swap( sender=ZeroEx, amount0In=0, amount1In=199458035, amount0Out=7648990390651603741659, amount1Out=0, to=[Receiver] ZeroExProxy )
50 AliERC20v2.Transfer( by=[Receiver] ZeroExProxy, from=[Receiver] ZeroExProxy, to=[Sender] 0xb003c5004fbdb952cf49efba22ae6dcac56ffb94, value=7648990390651603741659 )
51 AliERC20v2.Transfer( from=[Receiver] ZeroExProxy, to=[Sender] 0xb003c5004fbdb952cf49efba22ae6dcac56ffb94, value=7648990390651603741659 )

Account State Difference:

  Address   Before After State Difference Code
0x5083b16d...3BDDb3bF2
0x6B0b3a98...1cE324181
0xA0b86991...E3606eB48
0xB003c500...Ac56ffB94
0.332176031490842675 Eth
Nonce: 660
0.217853566095676974 Eth
Nonce: 661
0.114322465395165701
0xB4e16d01...1Ec28C9Dc
0xC02aaA39...83C756Cc2 3,353,390.378181564125614221 Eth3,353,390.488208905920054221 Eth0.11002734179444
0.385616995669930081 Eth0.386040697669930081 Eth0.000423702

Execution Trace

ETH 0.11002734179444 ZeroExProxy.proxiedSwap( msgData=0xD9627AA400000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000186E548CF3CF34000000000000000000000000000000000000000000000019236889B2EF235A43000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000A0B86991C6218B36C1D19D4A2E9EB0CE3606EB480000000000000000000000006B0B3A982B4634AC68DD83A4DBF02311CE324181869584CD000000000000000000000000382FFCE2287252F930E1C8DC9328DAC5BF282BA10000000000000000000000000000000000000000000000917A16A261647F07D2, feeToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE, inputToken=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE, inputAmount=110027341794440000, outputToken=0x6B0b3a982b4634aC68dD83a4DBF02311cE324181, fee=0 )
  • ETH 0.11002734179444 ZeroEx.d9627aa4( )
    • ETH 0.11002734179444 UniswapFeature.sellToUniswap( tokens=[0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE, 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48, 0x6B0b3a982b4634aC68dD83a4DBF02311cE324181], sellAmount=110027341794440000, minBuyAmount=7419520678932054910000, isSushi=False ) => ( buyAmount=7648990390651603741659 )
      • ETH 0.11002734179444 WETH9.CALL( )
      • WETH9.transfer( dst=0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc, wad=110027341794440000 ) => ( True )
      • UniswapV2Pair.STATICCALL( )
      • UniswapV2Pair.swap( amount0Out=199458035, amount1Out=0, to=0x5083b16dA538c5022744526122243cF3BDDb3bF2, data=0x )
        • FiatTokenProxy.a9059cbb( )
          • FiatTokenV2_1.transfer( to=0x5083b16dA538c5022744526122243cF3BDDb3bF2, value=199458035 ) => ( True )
          • FiatTokenProxy.70a08231( )
            • FiatTokenV2_1.balanceOf( account=0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc ) => ( 27561887626113 )
            • WETH9.balanceOf( 0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc ) => ( 15158504328247597461449 )
            • UniswapV2Pair.STATICCALL( )
            • UniswapV2Pair.swap( amount0Out=7648990390651603741659, amount1Out=0, to=0xe66B31678d6C16E9ebf358268a790B763C133750, data=0x )
              • AliERC20v2.transfer( _to=0xe66B31678d6C16E9ebf358268a790B763C133750, _value=7648990390651603741659 ) => ( success=True )
              • AliERC20v2.balanceOf( _owner=0x5083b16dA538c5022744526122243cF3BDDb3bF2 ) => ( balance=5137919082390177767273651 )
              • FiatTokenProxy.70a08231( )
                • FiatTokenV2_1.balanceOf( account=0x5083b16dA538c5022744526122243cF3BDDb3bF2 ) => ( 133775890250 )
                • AliERC20v2.balanceOf( _owner=0xe66B31678d6C16E9ebf358268a790B763C133750 ) => ( balance=7648990390651603741659 )
                • AliERC20v2.transfer( _to=0xB003c5004fBDB952cf49efBa22ae6DCAc56ffB94, _value=7648990390651603741659 ) => ( success=True )
                  File 1 of 9: ZeroExProxy
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: GPL-3.0
                  pragma solidity 0.6.12;
                  interface IZeroEx {
                  function getFunctionImplementation(bytes4 _signature) external returns (address);
                  }// SPDX-License-Identifier: GPL-3.0
                  pragma solidity 0.6.12;
                  pragma experimental ABIEncoderV2;
                  import "./IZeroEx.sol";
                  import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
                  import "@0x/contracts-zero-ex/contracts/src/errors/LibProxyRichErrors.sol";
                  import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                  import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
                  import "@openzeppelin/contracts/access/Ownable.sol";
                  /// @title Coinbase proxy contract for 0x proxy
                  /// @dev A generic proxy contract which extracts a fee before delegation
                  contract ZeroExProxy is Ownable {
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 2 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 3 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 4 of 9: 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 5 of 9: FiatTokenProxy
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  pragma solidity ^0.4.24;
                  // File: zos-lib/contracts/upgradeability/Proxy.sol
                  /**
                  * @title Proxy
                  * @dev Implements delegation of calls to other contracts, with proper
                  * forwarding of return values and bubbling of failures.
                  * It defines a fallback function that delegates all calls to the address
                  * returned by the abstract _implementation() internal function.
                  */
                  contract Proxy {
                  /**
                  * @dev Fallback function.
                  * Implemented entirely in `_fallback`.
                  */
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 6 of 9: AliERC20v2
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // SPDX-License-Identifier: MIT
                  pragma solidity 0.8.7;
                  import "../interfaces/ERC1363Spec.sol";
                  import "../interfaces/EIP2612.sol";
                  import "../interfaces/EIP3009.sol";
                  import "../utils/AccessControl.sol";
                  import "../lib/AddressUtils.sol";
                  import "../lib/ECDSA.sol";
                  /**
                  * @title Artificial Liquid Intelligence ERC20 Token (Alethea, ALI)
                  *
                  * @notice ALI is the native utility token of the Alethea AI Protocol.
                  * It serves as protocol currency, participates in iNFTs lifecycle,
                  * (locked when iNFT is created, released when iNFT is destroyed,
                  * consumed when iNFT is upgraded).
                  * ALI token powers up the governance protocol (Alethea DAO)
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

                  File 7 of 9: 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 8 of 9: 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 9 of 9: FiatTokenV2_1
                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  16
                  // File: @openzeppelin/contracts/math/SafeMath.sol
                  // SPDX-License-Identifier: MIT
                  pragma solidity ^0.6.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.
                  *
                  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX