0xba12222222228d8ba445958a75a0704d566bf2c8

deployer: unknown relevance score: 0 status: partially_identified bytecode: 24512 bytes

DECOMPILED SOLIDITY (Heimdall) 

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant getProtocolFeesCollector = 1179094094293835215229020967184532635351614791583;
    uint256 public constant WETH = 1097077688018008265106216665536940668749033598146;
    
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_e;
    bytes32 store_c;
    mapping(bytes32 => bytes32) storage_map_b;
    mapping(bytes32 => bytes32) storage_map_d;
    bool public getPausedState;
    
    event AuthorizerChanged(address);
    event PausedStateChanged(bool);
    
    /// @custom:selector    0x0f5a6efa
    /// @custom:signature   getInternalBalance(address arg0, address[] arg1) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getInternalBalance(address arg0, address[] arg1) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        uint256 var_a = var_a + ((0x20 * (arg1)) + 0x20);
        require(!0 < (arg1));
        require((0x20 + (arg1)) == (address(0x20 + (arg1))));
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length);
        var_d = msg.data[4:4];
        var_e = address(var_d);
        return abi.encodePacked(0x20, var_a.length);
    }
    
    /// @custom:selector    0x945bcec9
    /// @custom:signature   Unresolved_945bcec9(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_945bcec9(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg0 < 0x02);
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        uint256 var_a = var_a + ((0x20 * (arg1)) + 0x20);
        require(!0 < (arg1));
        require(!((var_a + 0xa0) < var_a) | ((var_a + 0xa0) > 0xffffffffffffffff));
        var_a = var_a + 0xa0;
        require(!(arg1 + (0x20 + (arg1)) + 0xa0) > 0xffffffffffffffff);
        require(!(arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) > 0xffffffffffffffff);
        require(!((var_a + (0x20 + (uint248((arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) + 0x1f)))) < var_a) | ((var_a + (0x20 + (uint248((arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) + 0x1f)))) > 0xffffffffffffffff));
        require(!arg2 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0x52bbbe29
    /// @custom:signature   Unresolved_52bbbe29(uint256 arg0, uint256 arg1, address arg2, address arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_52bbbe29(uint256 arg0, uint256 arg1, address arg2, address arg3, uint256 arg4, uint256 arg5) public pure {
        require(!arg0 > 0xffffffffffffffff);
        require(!((var_a + 0xc0) < var_a) | ((var_a + 0xc0) > 0xffffffffffffffff));
        uint256 var_a = var_a + 0xc0;
        require((arg0 + 0x20) < 0x02);
        require((arg0 + 0x40) == (address(arg0 + 0x40)));
        require((arg0 + 0x60) == (address(arg0 + 0x60)));
        require(!(arg0 + 0xa0) > 0xffffffffffffffff);
        require(!(arg0 + (arg0 + 0xa0)) > 0xffffffffffffffff);
        require(!((var_a + (0x20 + (uint248(arg0 + (arg0 + 0xa0) + 0x1f)))) < var_a) | ((var_a + (0x20 + (uint248(arg0 + (arg0 + 0xa0) + 0x1f)))) > 0xffffffffffffffff));
        var_a = var_a + (0x20 + (uint248(arg0 + (arg0 + 0xa0) + 0x1f)));
        require(!(msg.data.length - 0x24) < 0x80);
    }
    
    /// @custom:selector    0xb05f8e48
    /// @custom:signature   getPoolTokenInfo(bytes32 arg0, address arg1) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function getPoolTokenInfo(bytes32 arg0, address arg1) public view returns (bytes memory) {
        require(arg1 == (address(arg1)));
        uint256 var_a = arg0;
        require(bytes1(storage_map_a[var_a]), "BAL#500");
        require(uint16(arg0 >> 0x50) < 0x03, "BAL#500");
        require(!(uint16(arg0 >> 0x50) > 0x02), "BAL#526");
        require(!(uint16(arg0 >> 0x50) == 0x02), "BAL#526");
        var_a = arg0;
        var_a = keccak256(var_j);
        require(uint112(storage_map_b[var_a]) + (uint112(storage_map_a[var_a])) < (uint112(storage_map_a[var_a])), "BAL#526");
        require(!(uint112(storage_map_b[var_a]) + (uint112(storage_map_a[var_a])) < (uint112(storage_map_a[var_a]))), "BAL#526");
        require(!(uint16(arg0 >> 0x50) > 0x02), "BAL#500");
        require(!(uint16(arg0 >> 0x50) == 0x01), "BAL#500");
        var_a = address(arg1);
        require(!(!uint224(storage_map_a[var_a])), "BAL#500");
        require(!(!uint224(storage_map_a[var_a])), "BAL#500");
        var_a = address(arg1);
        return abi.encodePacked(uint112(storage_map_a[var_a]), uint112(storage_map_a[var_a] >> 0x70), storage_map_a[var_a] >> 0xe0, address(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0x8bdb3913
    /// @custom:signature   Unresolved_8bdb3913(uint256 arg0, address arg1) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_8bdb3913(uint256 arg0, address arg1) public pure {
        require(arg1 == (address(arg1)));
    }
    
    /// @custom:selector    0x7d3aeb96
    /// @custom:signature   deregisterTokens(bytes32 arg0, address[] arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function deregisterTokens(bytes32 arg0, address[] arg1) public {
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        require(!0 < (arg1));
        require((0x20 + (arg1)) == (address(0x20 + (arg1))));
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        if (block.timestamp > 0x611c01bf) {
        }
    }
    
    /// @custom:selector    0x90193b7c
    /// @custom:signature   getNextNonce(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getNextNonce(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x66a9c7d2
    /// @custom:signature   registerTokens(bytes32 arg0, address[] arg1, address[] arg2) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function registerTokens(bytes32 arg0, address[] arg1, address[] arg2) public pure {
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        require(!0 < (arg1));
        require((0x20 + (arg1)) == (address(0x20 + (arg1))));
        require(!arg2 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0x5c38449e
    /// @custom:signature   Unresolved_5c38449e(address arg0, uint256 arg1, uint256 arg2) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_5c38449e(address arg0, uint256 arg1, uint256 arg2) public pure {
        require(arg0 == (address(arg0)));
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        require(!0 < (arg1));
        require((0x20 + (arg1)) == (address(0x20 + (arg1))));
        require(!arg2 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0xe6c46092
    /// @custom:signature   Unresolved_e6c46092(uint256 arg0, uint256 arg1, uint256 arg2, address arg3) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_e6c46092(uint256 arg0, uint256 arg1, uint256 arg2, address arg3) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg0)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg0)) + 0x20)) > 0xffffffffffffffff));
        uint256 var_a = var_a + ((0x20 * (arg0)) + 0x20);
        require(!0 < (arg0));
        require(!((var_a + 0x80) < var_a) | ((var_a + 0x80) > 0xffffffffffffffff));
        require((0x20 + (arg0)) < 0x03);
        require(((0x20 + (arg0)) + 0x40) == (address((0x20 + (arg0)) + 0x40)));
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        if (block.timestamp > 0x611c01bf) {
        }
    }
    
    /// @custom:selector    0xf6c00927
    /// @custom:signature   getPool(bytes32 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getPool(bytes32 arg0) public view returns (bytes memory) {
        uint256 var_a = arg0;
        require(bytes1(storage_map_a[var_a]), "BAL#500");
        require(uint16(arg0 >> 0x50) < 0x03, "BAL#500");
        require(uint16(arg0 >> 0x50) < 0x03, "BAL#500");
        return abi.encodePacked(address(arg0 >> 0x60), uint16(arg0 >> 0x50));
    }
    
    /// @custom:selector    0xed24911d
    /// @custom:signature   getDomainSeparator() public view returns (uint256)
    function getDomainSeparator() public view returns (uint256) {
        return keccak256(var_i);
    }
    
    /// @custom:selector    0xb95cac28
    /// @custom:signature   Unresolved_b95cac28(uint256 arg0, address arg1) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b95cac28(uint256 arg0, address arg1) public pure {
        require(arg1 == (address(arg1)));
    }
    
    /// @custom:selector    0xf84d066e
    /// @custom:signature   Unresolved_f84d066e(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_f84d066e(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg0 < 0x02);
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg1)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg1)) + 0x20)) > 0xffffffffffffffff));
        uint256 var_a = var_a + ((0x20 * (arg1)) + 0x20);
        require(!0 < (arg1));
        require(!((var_a + 0xa0) < var_a) | ((var_a + 0xa0) > 0xffffffffffffffff));
        var_a = var_a + 0xa0;
        require(!(arg1 + (0x20 + (arg1)) + 0xa0) > 0xffffffffffffffff);
        require(!(arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) > 0xffffffffffffffff);
        require(!((var_a + (0x20 + (uint248((arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) + 0x1f)))) < var_a) | ((var_a + (0x20 + (uint248((arg1 + (0x20 + (arg1)) + (arg1 + (0x20 + (arg1)) + 0xa0) + 0x20) + 0x1f)))) > 0xffffffffffffffff));
        require(!arg2 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0xf94d4668
    /// @custom:signature   getPoolTokens(bytes32 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getPoolTokens(bytes32 arg0) public view returns (bytes memory) {
        uint256 var_a = arg0;
        require(bytes1(storage_map_a[var_a]), "BAL#500");
        require(uint16(arg0 >> 0x50) < 0x03, "BAL#500");
        require(!(uint16(arg0 >> 0x50) > 0x02), "BAL#526");
        require(!(uint16(arg0 >> 0x50) == 0x02), "BAL#526");
        var_a = arg0;
        var_a = keccak256(var_j);
        require(uint112(storage_map_b[var_a]) + (uint112(storage_map_a[var_a])) < (uint112(storage_map_a[var_a])), "BAL#526");
        require(!(uint112(storage_map_b[var_a]) + (uint112(storage_map_a[var_a])) < (uint112(storage_map_a[var_a]))), "BAL#526");
        require(!(uint16(arg0 >> 0x50)) > 0x02);
        require(!(uint16(arg0 >> 0x50)) == 0x01);
        var_a = arg0;
        require(!storage_map_a[var_a] > 0xffffffffffffffff);
        var_i = var_i + (0x20 + (0x20 * storage_map_a[var_a]));
        require(!storage_map_a[var_a]);
        require(!var_i.length > 0xffffffffffffffff);
        var_i = var_i + (0x20 + (0x20 * var_i.length));
        require(!var_i.length);
        require(0 < (storage_map_d[var_a]));
        var_a = 0 + keccak256(var_a);
        var_a = address(storage_map_e[var_a]);
        require(!var_i.length > 0xffffffffffffffff);
        var_i = var_i + (0x20 + (0x20 * var_i.length));
        if (!var_i.length) {
            var_j = msg.data[4:4];
            require(!var_i.length);
        }
        return abi.encodePacked(0x60, ((var_i + 0x60) + 0x20) - var_i, 0, var_i.length, var_i.length);
        var_a = arg0;
        require(!storage_map_a[var_a] > 0xffffffffffffffff);
        var_i = var_i + (0x20 + (0x20 * storage_map_a[var_a]));
        require(!storage_map_a[var_a]);
        require(!var_i.length > 0xffffffffffffffff);
        var_i = var_i + (0x20 + (0x20 * var_i.length));
        require(!var_i.length, "BAL#500");
        var_a = 0;
    }
    
    /// @custom:selector    0x058a628f
    /// @custom:signature   setAuthorizer(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setAuthorizer(address arg0) public {
        require(arg0 == (address(arg0)));
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        var_j = keccak256(var_k);
        require(address(getPausedState / 0x0100).code.length);
        (bool success, bytes memory ret0) = address(getPausedState / 0x0100).Unresolved_9be2a884(var_j); // staticcall
        var_h = var_h + (uint248(ret0.length + 0x1f));
        require(!(((var_h + ret0.length) - var_h) < 0x20), "BAL#401");
        require(var_h.length == var_h.length, "BAL#401");
        require(var_h.length, "BAL#401");
        emit AuthorizerChanged(address(arg0));
        getPausedState = (uint96(getPausedState)) | (0x0100 * (address(arg0)));
        store_c = 0x01;
    }
    
    /// @custom:selector    0x09b2760f
    /// @custom:signature   Unresolved_09b2760f(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_09b2760f(uint256 arg0) public {
        require(arg0 < 0x03);
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        if (block.timestamp > 0x611c01bf) {
        }
    }
    
    /// @custom:selector    0xfec90d72
    /// @custom:signature   Unresolved_fec90d72(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_fec90d72(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x0e8e3e84
    /// @custom:signature   Unresolved_0e8e3e84(uint256 arg0, uint256 arg1, address arg2, uint256 arg3, address arg4) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_0e8e3e84(uint256 arg0, uint256 arg1, address arg2, uint256 arg3, address arg4) public payable {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!((var_a + ((0x20 * (arg0)) + 0x20)) < var_a) | ((var_a + ((0x20 * (arg0)) + 0x20)) > 0xffffffffffffffff));
        uint256 var_a = var_a + ((0x20 * (arg0)) + 0x20);
        require(!0 < (arg0));
        require(!((var_a + 0xa0) < var_a) | ((var_a + 0xa0) > 0xffffffffffffffff));
        require((0x20 + (arg0)) < 0x04);
        require(((0x20 + (arg0)) + 0x20) == (address((0x20 + (arg0)) + 0x20)));
        require(((0x20 + (arg0)) + 0x60) == (address((0x20 + (arg0)) + 0x60)));
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        require(!(msg.value < 0), "BAL#516");
        require(!(msg.value - 0), "BAL#419");
        require(!(address(this).balance < (msg.value - 0)), "BAL#419");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(msg.value - 0);
        require(ret0.length == 0, "BAL#420");
        store_c = 0x01;
        store_c = 0x01;
    }
    
    /// @custom:selector    0x851c1bb3
    /// @custom:signature   getActionId(bytes4 arg0) public pure returns (uint256)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function getActionId(bytes4 arg0) public pure returns (uint256) {
        require(arg0 == (uint32(arg0)));
        return keccak256(var_f);
    }
    
    /// @custom:selector    0xfa6e671d
    /// @custom:signature   Unresolved_fa6e671d(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_fa6e671d(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x16c38b3c
    /// @custom:signature   Unresolved_16c38b3c(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_16c38b3c(uint256 arg0) public {
        require(arg0 == arg0);
        require(!(store_c == 0x02), "BAL#400");
        store_c = 0x02;
        var_j = keccak256(var_k);
        require(address(getPausedState / 0x0100).code.length);
        (bool success, bytes memory ret0) = address(getPausedState / 0x0100).Unresolved_9be2a884(var_j); // staticcall
        var_h = var_h + (uint248(ret0.length + 0x1f));
        require(!(((var_h + ret0.length) - var_h) < 0x20), "BAL#401");
        require(var_h.length == var_h.length, "BAL#401");
        require(var_h.length, "BAL#401");
        require(!arg0, "BAL#403");
        require(block.timestamp < 0x60f474bf, "BAL#403");
        getPausedState = arg0 | (uint248(getPausedState));
        emit PausedStateChanged(arg0);
        store_c = 0x01;
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_09b2760f",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_0e8e3e84",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_16c38b3c",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_52bbbe29",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "address"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_5c38449e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_8bdb3913",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_945bcec9",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_b95cac28",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_e6c46092",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_f84d066e",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_fa6e671d",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_fec90d72",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "WETH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "deregisterTokens",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address[]"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "getActionId",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "getAuthorizer",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getDomainSeparator",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getInternalBalance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address[]"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getNextNonce",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPausedState",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPool",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPoolTokenInfo",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPoolTokens",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getProtocolFeesCollector",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "registerTokens",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address[]"
      },
      {
        "name": "arg2",
        "type": "address[]"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "setAuthorizer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "AuthorizerChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "PausedStateChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "bool",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (1)

0xfa61cc12unknown
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)