Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

import "contract-evm/src/interface/IVault.sol";
import "contract-evm/src/library/types/VaultTypes.sol";
import "contract-evm/src/library/types/EventTypes.sol";
import "contract-evm/src/library/types/RebalanceTypes.sol";
import "contract-evm/src/library/Utils.sol";

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

import "./interface/IVaultCrossChainManager.sol";
import "./interface/IOrderlyCrossChain.sol";
import "./utils/OrderlyCrossChainMessage.sol";

contract VaultCrossChainManagerDatalayout {
    // src chain id
    uint256 public chainId;
    // ledger chain id
    uint256 public ledgerChainId;
    // vault interface
    IVault public vault;
    // crosschain relay interface
    IOrderlyCrossChain public crossChainRelay;
    // map of chainId => LedgerCrossChainManager
    mapping(uint256 => address) public ledgerCrossChainManagers;

    // only vault
    modifier onlyVault() {
        require(msg.sender == address(vault), "VaultCrossChainManager: only vault can call");
        _;
    }

    // only relay
    modifier onlyRelay() {
        require(msg.sender == address(crossChainRelay), "VaultCrossChainManager: only crossChainRelay can call");
        _;
    }
}

contract VaultCrossChainManagerUpgradeable is
    IVaultCrossChainManager,
    IOrderlyCrossChainReceiver,
    OwnableUpgradeable,
    UUPSUpgradeable,
    VaultCrossChainManagerDatalayout
{
    /// @notice Initializes the contract.
    function initialize() public initializer {
        __Ownable_init();
        __UUPSUpgradeable_init();
    }

    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}

    function upgradeTo(address newImplementation) public override onlyOwner {
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /// @notice Sets the chain ID.
    /// @param _chainId ID of the chain.
    function setChainId(uint256 _chainId) public onlyOwner {
        chainId = _chainId;
    }

    /// @notice Sets the vault address.
    /// @param _vault Address of the new vault.
    function setVault(address _vault) public onlyOwner {
        vault = IVault(_vault);
    }

    /// @notice Sets the cross-chain relay address.
    /// @param _crossChainRelay Address of the new cross-chain relay.
    function setCrossChainRelay(address _crossChainRelay) public onlyOwner {
        crossChainRelay = IOrderlyCrossChain(_crossChainRelay);
    }

    /// @notice Sets the ledger chain ID.
    /// @param _chainId ID of the ledger chain.
    function setLedgerCrossChainManager(uint256 _chainId, address _ledgerCrossChainManager) public onlyOwner {
        ledgerChainId = _chainId;
        ledgerCrossChainManagers[_chainId] = _ledgerCrossChainManager;
    }

    /// @notice receive message from relay, relay will call this function to send messages
    /// @param message message
    /// @param payload payload
    function receiveMessage(OrderlyCrossChainMessage.MessageV1 memory message, bytes memory payload)
        external
        override
        onlyRelay
    {
        require(message.dstChainId == chainId, "VaultCrossChainManager: dstChainId not match");

        if (message.payloadDataType == uint8(OrderlyCrossChainMessage.PayloadDataType.EventTypesWithdrawData)) {
            EventTypes.WithdrawData memory data = abi.decode(payload, (EventTypes.WithdrawData));
            // if token is CrossChainManagerTest
            if (keccak256(bytes(data.tokenSymbol)) == keccak256(bytes("CrossChainManagerTest"))) {
                _sendTestWithdrawBack();
            } else {
                VaultTypes.VaultWithdraw memory withdrawData = VaultTypes.VaultWithdraw({
                    accountId: data.accountId,
                    sender: data.sender,
                    receiver: data.receiver,
                    brokerHash: Utils.calculateStringHash(data.brokerId),
                    tokenHash: Utils.calculateStringHash(data.tokenSymbol),
                    tokenAmount: data.tokenAmount,
                    fee: data.fee,
                    withdrawNonce: data.withdrawNonce
                });
                _sendWithdrawToVault(withdrawData);
            }
        } else if (message.payloadDataType == uint8(OrderlyCrossChainMessage.PayloadDataType.RebalanceBurnCCData)) {
            RebalanceTypes.RebalanceBurnCCData memory data = abi.decode(payload, (RebalanceTypes.RebalanceBurnCCData));
            // call vault burn
            // TODO @zion
            vault.rebalanceBurn(data);
        } else if (message.payloadDataType == uint8(OrderlyCrossChainMessage.PayloadDataType.RebalanceMintCCData)) {
            RebalanceTypes.RebalanceMintCCData memory data = abi.decode(payload, (RebalanceTypes.RebalanceMintCCData));
            // call vault mint
            // TODO @zion
            vault.rebalanceMint(data);
        } else {
            revert("VaultCrossChainManager: payloadDataType not match");
        }
    }

    /// @notice Triggers a withdrawal from the ledger.
    /// @param data Struct containing withdrawal data.
    function _sendWithdrawToVault(VaultTypes.VaultWithdraw memory data) internal {
        vault.withdraw(data);
    }

    /// @notice Fetches the deposit fee based on deposit data.
    /// @param data Struct containing deposit data.
    function getDepositFee(VaultTypes.VaultDeposit memory data) public view override returns (uint256) {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.Deposit),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultDeposit),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        bytes memory payload = abi.encode(data);

        return crossChainRelay.estimateGasFee(message, payload);
    }

    /// @notice Initiates a deposit to the vault.
    /// @param data Struct containing deposit data.
    function deposit(VaultTypes.VaultDeposit memory data) external override onlyVault {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.Deposit),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultDeposit),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessage(message, payload);
    }

    /// @notice Initiates a deposit to the vault along with native fees.
    /// @param data Struct containing deposit data.
    function depositWithFee(VaultTypes.VaultDeposit memory data) external payable override onlyVault {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.Deposit),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultDeposit),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessageWithFee{value: msg.value}(message, payload);
    }

    /// @notice Initiates a deposit to the vault along with native fees.
    /// @param refundReceiver Address of the receiver of the deposit fee refund.
    /// @param data Struct containing deposit data.
    function depositWithFeeRefund(address refundReceiver, VaultTypes.VaultDeposit memory data)
        external
        payable
        override
        onlyVault
    {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.Deposit),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultDeposit),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessageWithFeeRefund{value: msg.value}(refundReceiver, message, payload);
    }

    /// @notice Approves a cross-chain withdrawal from the ledger to the vault.
    /// @param data Struct containing withdrawal data.
    function withdraw(VaultTypes.VaultWithdraw memory data) external override onlyVault {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.WithdrawFinish),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultWithdraw),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessage(message, payload);
    }

    /// @notice send burn finish back to ledger
    /// @param data Struct containing burn data.
    function burnFinish(RebalanceTypes.RebalanceBurnCCFinishData memory data) external override onlyVault {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.RebalanceBurnFinish),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.RebalanceBurnCCFinishData),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessage(message, payload);
    }

    /// @notice send mint finish back to ledger
    /// @param data Struct containing mint data.
    function mintFinish(RebalanceTypes.RebalanceMintCCFinishData memory data) external override onlyVault {
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.RebalanceMintFinish),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.RebalanceMintCCFinishData),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessage(message, payload);
    }

    /// @notice send test withdraw back
    function _sendTestWithdrawBack() internal {
        VaultTypes.VaultWithdraw memory data = VaultTypes.VaultWithdraw({
            accountId: bytes32(0),
            sender: address(0),
            receiver: address(0),
            brokerHash: bytes32(0),
            tokenHash: Utils.calculateStringHash("CrossChainManagerTest"),
            tokenAmount: 0,
            fee: 0,
            withdrawNonce: 0
        });
        OrderlyCrossChainMessage.MessageV1 memory message = OrderlyCrossChainMessage.MessageV1({
            method: uint8(OrderlyCrossChainMessage.CrossChainMethod.WithdrawFinish),
            option: uint8(OrderlyCrossChainMessage.CrossChainOption.LayerZero),
            payloadDataType: uint8(OrderlyCrossChainMessage.PayloadDataType.VaultTypesVaultWithdraw),
            srcCrossChainManager: address(this),
            dstCrossChainManager: ledgerCrossChainManagers[ledgerChainId],
            srcChainId: chainId,
            dstChainId: ledgerChainId
        });
        // encode message
        bytes memory payload = abi.encode(data);

        crossChainRelay.sendMessage(message, payload);
    }

    /// @notice get role
    function getRole() external pure returns (string memory) {
        return "vault";
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

import "./../library/types/VaultTypes.sol";
import "./../library/types/RebalanceTypes.sol";

interface IVault {
    error OnlyCrossChainManagerCanCall();
    error AccountIdInvalid();
    error TokenNotAllowed();
    error BrokerNotAllowed();
    error BalanceNotEnough(uint256 balance, uint128 amount);
    error AddressZero();
    error EnumerableSetError();
    error ZeroDepositFee();
    error ZeroDeposit();
    error ZeroCodeLength();
    error NotZeroCodeLength();

    // @deprecated
    event AccountDeposit(
        bytes32 indexed accountId,
        address indexed userAddress,
        uint64 indexed depositNonce,
        bytes32 tokenHash,
        uint128 tokenAmount
    );

    event AccountDepositTo(
        bytes32 indexed accountId,
        address indexed userAddress,
        uint64 indexed depositNonce,
        bytes32 tokenHash,
        uint128 tokenAmount
    );

    event AccountWithdraw(
        bytes32 indexed accountId,
        uint64 indexed withdrawNonce,
        bytes32 brokerHash,
        address sender,
        address receiver,
        bytes32 tokenHash,
        uint128 tokenAmount,
        uint128 fee
    );

    event AccountDelegate(
        address indexed delegateContract,
        bytes32 indexed brokerHash,
        address indexed delegateSigner,
        uint256 chainId,
        uint256 blockNumber
    );

    event SetAllowedToken(bytes32 indexed _tokenHash, bool _allowed);
    event SetAllowedBroker(bytes32 indexed _brokerHash, bool _allowed);
    event ChangeTokenAddressAndAllow(bytes32 indexed _tokenHash, address _tokenAddress);
    event ChangeCrossChainManager(address oldAddress, address newAddress);
    event WithdrawFailed(address indexed token, address indexed receiver, uint256 amount);

    function initialize() external;

    function deposit(VaultTypes.VaultDepositFE calldata data) external payable;
    function depositTo(address receiver, VaultTypes.VaultDepositFE calldata data) external payable;
    function getDepositFee(address recevier, VaultTypes.VaultDepositFE calldata data) external view returns (uint256);
    function enableDepositFee(bool _enabled) external;
    function withdraw(VaultTypes.VaultWithdraw calldata data) external;
    function delegateSigner(VaultTypes.VaultDelegate calldata data) external;

    // CCTP: functions for receive rebalance msg
    function rebalanceMint(RebalanceTypes.RebalanceMintCCData calldata data) external;
    function rebalanceBurn(RebalanceTypes.RebalanceBurnCCData calldata data) external;
    function setTokenMessengerContract(address _tokenMessengerContract) external;
    function setRebalanceMessengerContract(address _rebalanceMessengerContract) external;

    // admin call
    function setCrossChainManager(address _crossChainManagerAddress) external;
    function emergencyPause() external;
    function emergencyUnpause() external;

    // whitelist
    function setAllowedToken(bytes32 _tokenHash, bool _allowed) external;
    function setAllowedBroker(bytes32 _brokerHash, bool _allowed) external;
    function changeTokenAddressAndAllow(bytes32 _tokenHash, address _tokenAddress) external;
    function getAllowedToken(bytes32 _tokenHash) external view returns (address);
    function getAllowedBroker(bytes32 _brokerHash) external view returns (bool);
    function getAllAllowedToken() external view returns (bytes32[] memory);
    function getAllAllowedBroker() external view returns (bytes32[] memory);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

/// @title VaultTypes library
/// @author Orderly_Rubick
library VaultTypes {
    struct VaultDepositFE {
        bytes32 accountId;
        bytes32 brokerHash;
        bytes32 tokenHash;
        uint128 tokenAmount;
    }

    struct VaultDeposit {
        bytes32 accountId;
        address userAddress;
        bytes32 brokerHash;
        bytes32 tokenHash;
        uint128 tokenAmount;
        uint64 depositNonce; // deposit nonce
    }

    struct VaultWithdraw {
        bytes32 accountId;
        bytes32 brokerHash;
        bytes32 tokenHash;
        uint128 tokenAmount;
        uint128 fee;
        address sender;
        address receiver;
        uint64 withdrawNonce; // withdraw nonce
    }

    struct VaultDelegate {
        bytes32 brokerHash;
        address delegateSigner;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

/// @title EventTypes library
/// @author Orderly_Rubick
library EventTypes {
    // EventUpload
    struct EventUpload {
        EventUploadData[] events;
        bytes32 r;
        bytes32 s;
        uint8 v;
        uint8 count;
        uint64 batchId;
    }

    struct EventUploadData {
        uint8 bizType; // 1 - withdraw, 2 - settlement, 3 - adl, 4 - liquidation, 5 - fee distribution, 6 - delegate signer, 7 - delegate withdraw
        uint64 eventId;
        bytes data;
    }

    // WithdrawData
    struct WithdrawData {
        uint128 tokenAmount;
        uint128 fee;
        uint256 chainId; // target withdraw chain
        bytes32 accountId;
        bytes32 r; // String to bytes32, big endian?
        bytes32 s;
        uint8 v;
        address sender;
        uint64 withdrawNonce;
        address receiver;
        uint64 timestamp;
        string brokerId; // only this field is string, others should be bytes32 hashedBrokerId
        string tokenSymbol; // only this field is string, others should be bytes32 hashedTokenSymbol
    }

    struct Settlement {
        bytes32 accountId;
        bytes32 settledAssetHash;
        bytes32 insuranceAccountId;
        int128 settledAmount;
        uint128 insuranceTransferAmount;
        uint64 timestamp;
        SettlementExecution[] settlementExecutions;
    }

    struct SettlementExecution {
        bytes32 symbolHash;
        uint128 markPrice;
        int128 sumUnitaryFundings;
        int128 settledAmount;
    }

    struct Adl {
        bytes32 accountId;
        bytes32 insuranceAccountId;
        bytes32 symbolHash;
        int128 positionQtyTransfer;
        int128 costPositionTransfer;
        uint128 adlPrice;
        int128 sumUnitaryFundings;
        uint64 timestamp;
    }

    struct Liquidation {
        bytes32 liquidatedAccountId;
        bytes32 insuranceAccountId;
        bytes32 liquidatedAssetHash;
        uint128 insuranceTransferAmount;
        uint64 timestamp;
        LiquidationTransfer[] liquidationTransfers;
    }

    struct LiquidationTransfer {
        bytes32 liquidatorAccountId;
        bytes32 symbolHash;
        int128 positionQtyTransfer;
        int128 costPositionTransfer;
        int128 liquidatorFee;
        int128 insuranceFee;
        int128 liquidationFee;
        uint128 markPrice;
        int128 sumUnitaryFundings;
        uint64 liquidationTransferId;
    }

    struct FeeDistribution {
        bytes32 fromAccountId;
        bytes32 toAccountId;
        uint128 amount;
        bytes32 tokenHash;
    }

    struct DelegateSigner {
        address delegateSigner;
        address delegateContract;
        bytes32 brokerHash;
        uint256 chainId;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

/// @title RebalanceTypes library
/// @author Orderly_Rubick
library RebalanceTypes {
    enum RebalanceStatusEnum {
        None,
        Pending,
        Succ,
        Fail
    }

    // RebalanceStatus
    struct RebalanceStatus {
        uint64 rebalanceId; // Because the mapping key rebalanceId is mod, so we need to record the real rebalanceId
        RebalanceStatusEnum burnStatus;
        RebalanceStatusEnum mintStatus;
    }
    // RebalanceBurnUploadData

    struct RebalanceBurnUploadData {
        bytes32 r;
        bytes32 s;
        uint8 v;
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
    }

    struct RebalanceBurnCCData {
        uint32 dstDomain;
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
        address dstVaultAddress;
    }

    struct RebalanceBurnCCFinishData {
        bool success;
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
    }

    // RebalanceMintUploadData
    struct RebalanceMintUploadData {
        bytes32 r;
        bytes32 s;
        uint8 v;
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
        bytes messageBytes;
        bytes messageSignature;
    }

    struct RebalanceMintCCData {
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
        bytes messageBytes;
        bytes messageSignature;
    }

    struct RebalanceMintCCFinishData {
        bool success;
        uint64 rebalanceId;
        uint128 amount;
        bytes32 tokenHash;
        uint256 burnChainId;
        uint256 mintChainId;
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

/// @title Utils library
/// @author Orderly_Rubick Orderly_Zion
library Utils {
    function getAccountId(address _userAddr, string memory _brokerId) internal pure returns (bytes32) {
        return keccak256(abi.encode(_userAddr, calculateStringHash(_brokerId)));
    }

    function calculateAccountId(address _userAddr, bytes32 _brokerHash) internal pure returns (bytes32) {
        return keccak256(abi.encode(_userAddr, _brokerHash));
    }

    function calculateStringHash(string memory _str) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(_str));
    }

    function validateAccountId(bytes32 _accountId, bytes32 _brokerHash, address _userAddress)
        internal
        pure
        returns (bool)
    {
        return keccak256(abi.encode(_userAddress, _brokerHash)) == _accountId;
    }

    function toBytes32(address addr) internal pure returns (bytes32) {
        return bytes32(abi.encode(addr));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../ERC1967/ERC1967UpgradeUpgradeable.sol";
import "./Initializable.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
    function __UUPSUpgradeable_init() internal onlyInitializing {
    }

    function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
    }
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeTo(address newImplementation) public virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// 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:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

// Importing necessary utility libraries and types
import "../utils/OrderlyCrossChainMessage.sol";
import "contract-evm/src/library/types/AccountTypes.sol";
import "contract-evm/src/library/types/VaultTypes.sol";
import "contract-evm/src/library/types/RebalanceTypes.sol";

/// @title IVaultCrossChainManager Interface
/// @notice Interface for managing cross-chain activities related to the vault.
interface IVaultCrossChainManager {
    /// @notice Triggers a withdrawal from the ledger.
    /// @param withdraw Struct containing withdrawal data.
    function withdraw(VaultTypes.VaultWithdraw memory withdraw) external;

    /// @notice Triggers a finish msg from vault to ledger to inform the status of burn
    /// @param data Struct containing burn data.
    function burnFinish(RebalanceTypes.RebalanceBurnCCFinishData memory data) external;

    /// @notice Triggers a finish msg from vault to ledger to inform the status of mint
    /// @param data Struct containing mint data.
    function mintFinish(RebalanceTypes.RebalanceMintCCFinishData memory data) external;

    /// @notice Initiates a deposit to the vault.
    /// @param data Struct containing deposit data.
    function deposit(VaultTypes.VaultDeposit memory data) external;

    /// @notice Initiates a deposit to the vault along with native fees.
    /// @param data Struct containing deposit data.
    function depositWithFee(VaultTypes.VaultDeposit memory data) external payable;

    /// @notice Initiates a deposit to the vault along with native fees.
    /// @param refundReceiver Address of the receiver of the deposit fee refund.
    /// @param data Struct containing deposit data.
    function depositWithFeeRefund(address refundReceiver, VaultTypes.VaultDeposit memory data) external payable;

    /// @notice Fetches the deposit fee based on deposit data.
    /// @param data Struct containing deposit data.
    /// @return fee The calculated deposit fee.
    function getDepositFee(VaultTypes.VaultDeposit memory data) external view returns (uint256);

    /// @notice Sets the vault address.
    /// @param vault Address of the new vault.
    function setVault(address vault) external;

    /// @notice Sets the cross-chain relay address.
    /// @param crossChainRelay Address of the new cross-chain relay.
    function setCrossChainRelay(address crossChainRelay) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "../utils/OrderlyCrossChainMessage.sol";

// Interface for the Cross Chain Operations
interface IOrderlyCrossChain {
    // Event to be emitted when a message is sent
    event MessageSent(OrderlyCrossChainMessage.MessageV1 message, bytes payload);

    // Event to be emitted when a message is received
    event MessageReceived(OrderlyCrossChainMessage.MessageV1 message, bytes payload);

    /// @notice estimate gas fee
    /// @param data message data
    /// @param payload payload
    function estimateGasFee(OrderlyCrossChainMessage.MessageV1 memory data, bytes memory payload)
        external
        view
        returns (uint256);

    /// @notice send message
    /// @param message message
    /// @param payload payload
    function sendMessage(OrderlyCrossChainMessage.MessageV1 memory message, bytes memory payload) external payable;

    /// @notice send message with fee, so no estimate gas fee will not run
    /// @param message message
    /// @param payload payload
    function sendMessageWithFee(OrderlyCrossChainMessage.MessageV1 memory message, bytes memory payload)
        external
        payable;

    /// @notice send message with fee, so no estimate gas fee will not run
    /// @param refundReceiver receiver of the refund
    /// @param message message
    /// @param payload payload
    function sendMessageWithFeeRefund(
        address refundReceiver,
        OrderlyCrossChainMessage.MessageV1 memory message,
        bytes memory payload
    ) external payable;

    /// @notice receive message after decoding the message
    /// @param message message
    /// @param payload payload
    function receiveMessage(OrderlyCrossChainMessage.MessageV1 memory message, bytes memory payload) external payable;
}

// Interface for the Cross Chain Receiver
interface IOrderlyCrossChainReceiver {
    /// @notice receive message from relay, relay will call this function to send messages
    /// @param message message
    /// @param payload payload
    function receiveMessage(OrderlyCrossChainMessage.MessageV1 memory message, bytes memory payload) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

// Library to handle the conversion of the message structure to bytes array and vice versa
library OrderlyCrossChainMessage {
    // List of methods that can be called cross-chain
    enum CrossChainOption {LayerZero}

    enum CrossChainMethod {
        Deposit, // from vault to ledger
        Withdraw, // from ledger to vault
        WithdrawFinish, // from vault to ledger
        Ping, // for message testing
        PingPong, // ABA message testing
        RebalanceBurn, // burn request from ledger to vault
        RebalanceBurnFinish, // burn request finish from vault to ledger
        RebalanceMint, // mint request from ledger to vault
        RebalanceMintFinish //  mint request finish from vault to ledger
    }

    enum PayloadDataType {
        EventTypesWithdrawData,
        AccountTypesAccountDeposit,
        AccountTypesAccountWithdraw,
        VaultTypesVaultDeposit,
        VaultTypesVaultWithdraw,
        RebalanceBurnCCData,
        RebalanceBurnCCFinishData,
        RebalanceMintCCData,
        RebalanceMintCCFinishData
    }

    // The structure of the message
    struct MessageV1 {
        uint8 method; // enum CrossChainMethod to uint8
        uint8 option; // enum CrossChainOption to uint8
        uint8 payloadDataType; // enum PayloadDataType to uint8
        address srcCrossChainManager; // Source cross-chain manager address
        address dstCrossChainManager; // Target cross-chain manager address
        uint256 srcChainId; // Source blockchain ID
        uint256 dstChainId; // Target blockchain ID
    }

    // Encode the message structure to bytes array
    function encodeMessageV1AndPayload(MessageV1 memory message, bytes memory payload)
        internal
        pure
        returns (bytes memory)
    {
        return abi.encode(message, payload);
    }

    // Decode the bytes array to message structure
    function decodeMessageV1AndPayload(bytes memory data) internal pure returns (MessageV1 memory, bytes memory) {
        (MessageV1 memory message, bytes memory payload) = abi.decode(data, (MessageV1, bytes));
        return (message, payload);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822ProxiableUpgradeable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeaconUpgradeable.sol";
import "../../interfaces/IERC1967Upgradeable.sol";
import "../../interfaces/draft-IERC1822Upgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/StorageSlotUpgradeable.sol";
import "../utils/Initializable.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 */
abstract contract ERC1967UpgradeUpgradeable is Initializable, IERC1967Upgradeable {
    function __ERC1967Upgrade_init() internal onlyInitializing {
    }

    function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
    }
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            AddressUpgradeable.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            AddressUpgradeable.functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
        }
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.18;

/// @title AccountTypes library
/// @author Orderly_Rubick
library AccountTypes {
    struct PerpPosition {
        int128 positionQty;
        int128 costPosition;
        int128 lastSumUnitaryFundings;
        uint128 lastExecutedPrice;
        uint128 lastSettledPrice;
        uint128 averageEntryPrice;
        int128 openingCost;
        uint128 lastAdlPrice;
    }

    // account id, unique for each account, should be accountId -> {addr, brokerId}
    // and keccak256(addr, brokerID) == accountId
    struct Account {
        // user's broker id
        bytes32 brokerHash;
        // primary address
        address userAddress;
        // mapping symbol => balance
        mapping(bytes32 => uint128) balances;
        // mapping symbol => totalFrozenBalance
        mapping(bytes32 => uint128) totalFrozenBalances;
        // mapping withdrawNonce => symbol => balance
        mapping(uint64 => mapping(bytes32 => uint128)) frozenBalances;
        // perp position
        mapping(bytes32 => PerpPosition) perpPositions;
        // lastwithdraw nonce
        uint64 lastWithdrawNonce;
        // last perp trade id
        uint64 lastPerpTradeId;
        // last engine event id
        uint64 lastEngineEventId;
        // last deposit event id
        uint64 lastDepositEventId;
    }

    struct AccountDeposit {
        bytes32 accountId;
        bytes32 brokerHash;
        address userAddress;
        bytes32 tokenHash;
        uint256 srcChainId;
        uint128 tokenAmount;
        uint64 srcChainDepositNonce;
    }

    // for accountWithdrawFinish
    struct AccountWithdraw {
        bytes32 accountId;
        address sender;
        address receiver;
        bytes32 brokerHash;
        bytes32 tokenHash;
        uint128 tokenAmount;
        uint128 fee;
        uint256 chainId;
        uint64 withdrawNonce;
    }

    struct AccountTokenBalances {
        // token hash
        bytes32 tokenHash;
        // balance & frozenBalance
        uint128 balance;
        uint128 frozenBalance;
    }

    struct AccountPerpPositions {
        // symbol hash
        bytes32 symbolHash;
        // perp position
        int128 positionQty;
        int128 costPosition;
        int128 lastSumUnitaryFundings;
        uint128 lastExecutedPrice;
        uint128 lastSettledPrice;
        uint128 averageEntryPrice;
        int128 openingCost;
        uint128 lastAdlPrice;
    }

    // for batch get
    struct AccountSnapshot {
        bytes32 accountId;
        bytes32 brokerHash;
        address userAddress;
        uint64 lastWithdrawNonce;
        uint64 lastPerpTradeId;
        uint64 lastEngineEventId;
        uint64 lastDepositEventId;
        AccountTokenBalances[] tokenBalances;
        AccountPerpPositions[] perpPositions;
    }

    struct AccountDelegateSigner {
        uint256 chainId;
        address signer;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeaconUpgradeable {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967Upgradeable {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlotUpgradeable {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

{
  "remappings": [
    "@openzeppelin/=node_modules/@openzeppelin/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "eth-gas-reporter/=node_modules/eth-gas-reporter/",
    "forge-std/=lib/forge-std/src/",
    "hardhat-deploy/=node_modules/hardhat-deploy/",
    "hardhat/=node_modules/hardhat/",
    "contract-evm/=lib/contract-evm/",
    "evm-cross-chain/=/",
    "safe/=lib/safe-contracts/contracts/",
    "@axelar-network/=node_modules/@axelar-network/",
    "erc4626-tests/=lib/contract-evm/lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
    "openzeppelin-contracts-upgradeable/=lib/contract-evm/lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/contract-evm/lib/openzeppelin-contracts/",
    "openzeppelin/=lib/contract-evm/lib/openzeppelin-contracts-upgradeable/contracts/",
    "safe-contracts/=lib/safe-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"uint64","name":"rebalanceId","type":"uint64"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint256","name":"burnChainId","type":"uint256"},{"internalType":"uint256","name":"mintChainId","type":"uint256"}],"internalType":"struct RebalanceTypes.RebalanceBurnCCFinishData","name":"data","type":"tuple"}],"name":"burnFinish","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"chainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"crossChainRelay","outputs":[{"internalType":"contract IOrderlyCrossChain","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes32","name":"brokerHash","type":"bytes32"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint128","name":"tokenAmount","type":"uint128"},{"internalType":"uint64","name":"depositNonce","type":"uint64"}],"internalType":"struct VaultTypes.VaultDeposit","name":"data","type":"tuple"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes32","name":"brokerHash","type":"bytes32"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint128","name":"tokenAmount","type":"uint128"},{"internalType":"uint64","name":"depositNonce","type":"uint64"}],"internalType":"struct VaultTypes.VaultDeposit","name":"data","type":"tuple"}],"name":"depositWithFee","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"refundReceiver","type":"address"},{"components":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes32","name":"brokerHash","type":"bytes32"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint128","name":"tokenAmount","type":"uint128"},{"internalType":"uint64","name":"depositNonce","type":"uint64"}],"internalType":"struct VaultTypes.VaultDeposit","name":"data","type":"tuple"}],"name":"depositWithFeeRefund","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes32","name":"brokerHash","type":"bytes32"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint128","name":"tokenAmount","type":"uint128"},{"internalType":"uint64","name":"depositNonce","type":"uint64"}],"internalType":"struct VaultTypes.VaultDeposit","name":"data","type":"tuple"}],"name":"getDepositFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRole","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ledgerChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"ledgerCrossChainManagers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"uint64","name":"rebalanceId","type":"uint64"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint256","name":"burnChainId","type":"uint256"},{"internalType":"uint256","name":"mintChainId","type":"uint256"}],"internalType":"struct RebalanceTypes.RebalanceMintCCFinishData","name":"data","type":"tuple"}],"name":"mintFinish","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"method","type":"uint8"},{"internalType":"uint8","name":"option","type":"uint8"},{"internalType":"uint8","name":"payloadDataType","type":"uint8"},{"internalType":"address","name":"srcCrossChainManager","type":"address"},{"internalType":"address","name":"dstCrossChainManager","type":"address"},{"internalType":"uint256","name":"srcChainId","type":"uint256"},{"internalType":"uint256","name":"dstChainId","type":"uint256"}],"internalType":"struct OrderlyCrossChainMessage.MessageV1","name":"message","type":"tuple"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"receiveMessage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_chainId","type":"uint256"}],"name":"setChainId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_crossChainRelay","type":"address"}],"name":"setCrossChainRelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_chainId","type":"uint256"},{"internalType":"address","name":"_ledgerCrossChainManager","type":"address"}],"name":"setLedgerCrossChainManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"contract IVault","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"bytes32","name":"brokerHash","type":"bytes32"},{"internalType":"bytes32","name":"tokenHash","type":"bytes32"},{"internalType":"uint128","name":"tokenAmount","type":"uint128"},{"internalType":"uint128","name":"fee","type":"uint128"},{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint64","name":"withdrawNonce","type":"uint64"}],"internalType":"struct VaultTypes.VaultWithdraw","name":"data","type":"tuple"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

1427:11904:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5510:784;;;;;;;;;;-1:-1:-1;5510:784:0;;;;;:::i;:::-;;:::i;:::-;;;3201:25:20;;;3189:2;3174:18;5510:784:0;;;;;;;;7316:823;;;;;;:::i;:::-;;:::i;:::-;;1868:150;;;;;;;;;;-1:-1:-1;1868:150:0;;;;;:::i;:::-;;:::i;10299:818::-;;;;;;;;;;-1:-1:-1;10299:818:0;;;;;:::i;:::-;;:::i;8351:911::-;;;;;;:::i;:::-;;:::i;2502:142::-;;;;;;;;;;-1:-1:-1;2502:142:0;;;;;:::i;:::-;;:::i;3901:220:16:-;;;;;;:::i;:::-;;:::i;3006:131::-;;;;;;;;;;;;;:::i;11220:818:0:-;;;;;;;;;;-1:-1:-1;11220:818:0;;;;;:::i;:::-;;:::i;817:28::-;;;;;;;;;;;;;;;;2284:90;;;;;;;;;;-1:-1:-1;2284:90:0;;;;;:::i;:::-;;:::i;2064:101:10:-;;;;;;;;;;;;;:::i;3116:2043:0:-;;;;;;;;;;-1:-1:-1;3116:2043:0;;;;;:::i;:::-;;:::i;933:41::-;;;;;;;;;;-1:-1:-1;933:41:0;;;;-1:-1:-1;;;;;933:41:0;;;;;;-1:-1:-1;;;;;8079:32:20;;;8061:51;;8049:2;8034:18;933:41:0;7889:229:20;1664:108:0;;;;;;;;;;;;;:::i;1441:85:10:-;;;;;;;;;;-1:-1:-1;1513:6:10;;-1:-1:-1;;;;;1513:6:10;1441:85;;9403:793:0;;;;;;;;;;-1:-1:-1;9403:793:0;;;;;:::i;:::-;;:::i;766:22::-;;;;;;;;;;;;;;;;6402:783;;;;;;;;;;-1:-1:-1;6402:783:0;;;;;:::i;:::-;;:::i;1029:59::-;;;;;;;;;;-1:-1:-1;1029:59:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;1029:59:0;;;2100:90;;;;;;;;;;-1:-1:-1;2100:90:0;;;;;:::i;:::-;;:::i;2314:198:10:-;;;;;;;;;;-1:-1:-1;2314:198:10;;;;;:::i;:::-;;:::i;874:19:0:-;;;;;;;;;;-1:-1:-1;874:19:0;;;;-1:-1:-1;;;;;874:19:0;;;13241:88;;;;;;;;;;-1:-1:-1;13308:14:0;;;;;;;;;;;-1:-1:-1;;;13308:14:0;;;;13241:88;;;;13308:14;13241:88;:::i;2740:217::-;;;;;;;;;;-1:-1:-1;2740:217:0;;;;;:::i;:::-;;:::i;5510:784::-;5600:7;5619:49;5671:501;;;;;;;;5734:49;5728:56;;;;;;;;:::i;:::-;5671:501;;;;5812:51;5671:501;;;;;;;5901:63;5671:501;;;;;;;;6009:4;5671:501;;;;6075:13;;6050:39;;;:24;:39;;;;;;-1:-1:-1;;;;;6050:39:0;5671:501;;;;6115:7;;5671:501;;;;;;;;;;;;6205:16;;5619:553;;-1:-1:-1;5812:51:0;6205:16;;6216:4;;6205:16;;:::i;:::-;;;;-1:-1:-1;;6205:16:0;;;;;;;;;;6239:15;;-1:-1:-1;;;6239:48:0;;6205:16;;-1:-1:-1;;;;;;6239:15:0;;:30;;:48;;6270:7;;6205:16;;6239:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6232:55;5510:784;-1:-1:-1;;;;5510:784:0:o;7316:823::-;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;;;;;;;;;7475:501:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;7475:501:0;;;::::1;::::0;;::::1;::::0;;;7705:63:::1;7475:501:::0;;;;7813:4:::1;7475:501:::0;;;;7879:13:::1;::::0;7854:39;;;:24:::1;:39:::0;;;;;;-1:-1:-1;;;;;7854:39:0::1;7475:501:::0;;;;7919:7:::1;::::0;7475:501;;;;;;;;8035:16;;7475:501;;-1:-1:-1;;8035:16:0::1;::::0;8046:4;;8035:16:::1;;:::i;:::-;;::::0;;-1:-1:-1;;8035:16:0;;::::1;::::0;;;;;;;8062:15:::1;::::0;-1:-1:-1;;;8062:70:0;;8035:16;;-1:-1:-1;;;;;;8062:15:0::1;::::0;:34:::1;::::0;8104:9:::1;::::0;8062:70:::1;::::0;8115:7;;8035:16;;8062:70:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;7413:726;;7316:823:::0;:::o;1868:150::-;1334:13:10;:11;:13::i;:::-;1991:12:0::1;::::0;;2001:1:::1;1991:12:::0;;;::::1;::::0;::::1;::::0;;;1950:61:::1;::::0;1972:17;;1991:12;1950:21:::1;:61::i;:::-;1868:150:::0;:::o;10299:818::-;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;10463:516:::1;::::0;;::::1;::::0;::::1;::::0;;10526:61:::1;10463:516:::0;;;-1:-1:-1;10463:516:0::1;::::0;::::1;::::0;;;-1:-1:-1;10463:516:0;;;10699:73:::1;10463:516;;::::0;;10816:4:::1;10463:516;::::0;;::::1;::::0;;;;10882:13:::1;::::0;-1:-1:-1;10857:39:0;;;:24:::1;:39:::0;;10463:516;10857:39;;;;-1:-1:-1;;;;;10857:39:0::1;10463:516:::0;;;;10922:7:::1;::::0;10463:516;;;;;;;;;;;;11038:16;;10411:568;;-1:-1:-1;;;11038:16:0::1;::::0;11049:4;;11038:16:::1;;:::i;:::-;;::::0;;-1:-1:-1;;11038:16:0;;::::1;::::0;;;;;;;11065:15:::1;::::0;-1:-1:-1;;;11065:45:0;;11038:16;;-1:-1:-1;;;;;;11065:15:0::1;::::0;:27:::1;::::0;:45:::1;::::0;11093:7;;11038:16;;11065:45:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;10401:716;;10299:818:::0;:::o;8351:911::-;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;8576:501:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;8576:501:0;;;::::1;::::0;;::::1;::::0;;;8806:63:::1;8576:501:::0;;;;8914:4:::1;8576:501:::0;;;;8980:13:::1;::::0;8955:39;;;:24:::1;:39:::0;;;;;;-1:-1:-1;;;;;8955:39:0::1;8576:501:::0;;;;9020:7:::1;::::0;8576:501;;;;;;;;9136:16;;8576:501;;-1:-1:-1;;9136:16:0::1;::::0;9147:4;;9136:16:::1;;:::i;:::-;;::::0;;-1:-1:-1;;9136:16:0;;::::1;::::0;;;;;;;9163:15:::1;::::0;-1:-1:-1;;;9163:92:0;;9136:16;;-1:-1:-1;;;;;;9163:15:0::1;::::0;:40:::1;::::0;9211:9:::1;::::0;9163:92:::1;::::0;9222:14;;9238:7;;9136:16;;9163:92:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;8514:748;;8351:911:::0;;:::o;2502:142::-;1334:13:10;:11;:13::i;:::-;2583:15:0::1;:54:::0;;-1:-1:-1;;;;;;2583:54:0::1;-1:-1:-1::0;;;;;2583:54:0;;;::::1;::::0;;;::::1;::::0;;2502:142::o;3901:220:16:-;-1:-1:-1;;;;;1898:6:16;1881:23;1889:4;1881:23;1873:80;;;;-1:-1:-1;;;1873:80:16;;14667:2:20;1873:80:16;;;14649:21:20;14706:2;14686:18;;;14679:30;14745:34;14725:18;;;14718:62;-1:-1:-1;;;14796:18:20;;;14789:42;14848:19;;1873:80:16;14465:408:20;1873:80:16;1995:6;-1:-1:-1;;;;;1971:30:16;:20;-1:-1:-1;;;;;;;;;;;1536:65:13;-1:-1:-1;;;;;1536:65:13;;1457:151;1971:20:16;-1:-1:-1;;;;;1971:30:16;;1963:87;;;;-1:-1:-1;;;1963:87:16;;15080:2:20;1963:87:16;;;15062:21:20;15119:2;15099:18;;;15092:30;15158:34;15138:18;;;15131:62;-1:-1:-1;;;15209:18:20;;;15202:42;15261:19;;1963:87:16;14878:408:20;1963:87:16;4016:36:::1;4034:17;4016;:36::i;:::-;4062:52;4084:17;4103:4;4109;4062:21;:52::i;:::-;3901:220:::0;;:::o;3006:131::-;3084:7;2324:4;-1:-1:-1;;;;;2333:6:16;2316:23;;2308:92;;;;-1:-1:-1;;;2308:92:16;;15493:2:20;2308:92:16;;;15475:21:20;15532:2;15512:18;;;15505:30;15571:34;15551:18;;;15544:62;15642:26;15622:18;;;15615:54;15686:19;;2308:92:16;15291:420:20;2308:92:16;-1:-1:-1;;;;;;;;;;;;3006:131:16;:::o;11220:818:0:-;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;11384:516:::1;::::0;;::::1;::::0;::::1;::::0;;11447:61:::1;11384:516:::0;;;-1:-1:-1;11384:516:0::1;::::0;::::1;::::0;;;-1:-1:-1;11384:516:0;;;11620:73:::1;::::0;2284:90;1334:13:10;:11;:13::i;:::-;2345:5:0::1;:22:::0;;-1:-1:-1;;;;;;2345:22:0::1;-1:-1:-1::0;;;;;2345:22:0;;;::::1;::::0;;;::::1;::::0;;2284:90::o;2064:101:10:-;1334:13;:11;:13::i;:::-;2128:30:::1;2155:1;2128:18;:30::i;:::-;2064:101::o:0;3116:2043:0:-;1331:15;;-1:-1:-1;;;;;1331:15:0;1309:10;:38;1301:104;;;;-1:-1:-1;;;1301:104:0;;16224:2:20;1301:104:0;;;16206:21:20;16263:2;16243:18;;;16236:30;16302:34;16282:18;;;16275:62;-1:-1:-1;;;16353:18:20;;;16346:51;16414:19;;1301:104:0;16022:417:20;1301:104:0;3309:7:::1;;3287;:18;;;:29;3279:86;;;::::0;-1:-1:-1;;;3279:86:0;;16646:2:20;3279:86:0::1;::::0;::::1;16628:21:20::0;16685:2;16665:18;;;16658:30;16724:34;16704:18;;;16697:62;-1:-1:-1;;;16775:18:20;;;16768:42;16827:19;;3279:86:0::1;16444:408:20::0;3279:86:0::1;3380:23;::::0;::::1;::::0;:97:::1;;3376:1777;;3493:35;3542:7;3531:46;;;;;;;;;;;;:::i;:::-;3692:30;::::0;;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;;;3692:30:0::1;::::0;;::::1;::::0;3660:16:::1;::::0;::::1;::::0;3644:34;;;::::1;::::0;3493:84;;-1:-1:-1;3644:79:0;;3640:747:::1;;3743:23;:21;:23::i;:::-;3479:918;3901:220:16::0;;:::o;3640:747:0:-:1;3805:44;3852:468;;;;;;;;3910:4;:14;;;3852:468;;;;4044:40;4070:4;:13;;;4044:25;:40::i;:::-;3852:468;;;;4117:43;4143:4;:16;;;4117:25;:43::i;:::-;3852:468;;;;4195:4;:16;;;-1:-1:-1::0;;;;;3852:468:0::1;;;;;4238:4;:8;;;-1:-1:-1::0;;;;;3852:468:0::1;;;;;3954:4;:11;;;-1:-1:-1::0;;;;;3852:468:0::1;;;;;3997:4;:13;;;-1:-1:-1::0;;;;;3852:468:0::1;;;;;4283:4;:18;;;-1:-1:-1::0;;;;;3852:468:0::1;;;::::0;3805:515:::1;;4338:34;4359:12;4338:20;:34::i;:::-;3787:600;3479:918;3901:220:16::0;;:::o;3376:1777:0:-:1;4440:60;4407:94;;:7;:23;;;:94;;::::0;4403:750:::1;;4517:46;4577:7;4566:57;;;;;;;;;;;;:::i;:::-;4694:5;::::0;:25:::1;::::0;;-1:-1:-1;;;4694:25:0;;20592:13:20;;20607:10;20588:30;4694:25:0::1;::::0;::::1;20570:49:20::0;20679:4;20667:17;;20661:24;-1:-1:-1;;;;;20657:49:20;20635:20;;;20628:79;20755:17;;;20749:24;-1:-1:-1;;;;;20745:65:20;20723:20;;;20716:95;20867:4;20855:17;;20849:24;20827:20;;;20820:54;20930:4;20918:17;;20912:24;20890:20;;;20883:54;20993:4;20981:17;;20975:24;20953:20;;;20946:54;21060:4;21048:17;;21042:24;-1:-1:-1;;;;;21038:50:20;;;21016:20;;;21009:80;4517:106:0;;-1:-1:-1;4694:5:0;::::1;::::0;:19:::1;::::0;20542::20;;4694:25:0::1;20349:746:20::0;4403:750:0::1;4773:60;4740:94;;:7;:23;;;:94;;::::0;4736:417:::1;;4850:46;4910:7;4899:57;;;;;;;;;;;;:::i;:::-;5027:5;::::0;:25:::1;::::0;-1:-1:-1;;;5027:25:0;;4850:106;;-1:-1:-1;;;;;;5027:5:0::1;::::0;:19:::1;::::0;:25:::1;::::0;4850:106;;5027:25:::1;;;:::i;4736:417::-;5083:59;::::0;-1:-1:-1;;;5083:59:0;;23349:2:20;5083:59:0::1;::::0;::::1;23331:21:20::0;23388:2;23368:18;;;23361:30;23427:34;23407:18;;;23400:62;-1:-1:-1;;;23478:18:20;;;23471:47;23535:19;;5083:59:0::1;23147:413:20::0;1664:108:0;3279:19:15;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:15;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:15;1713:19:17;:23;;;3387:66:15;;-1:-1:-1;3436:12:15;;;;;:17;3387:66;3325:201;;;;-1:-1:-1;;;3325:201:15;;23767:2:20;3325:201:15;;;23749:21:20;23806:2;23786:18;;;23779:30;23845:34;23825:18;;;23818:62;-1:-1:-1;;;23896:18:20;;;23889:44;23950:19;;3325:201:15;23565:410:20;3325:201:15;3536:12;:16;;-1:-1:-1;;3536:16:15;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;-1:-1:-1;;3596:20:15;;;;;3562:65;1715:16:0::1;:14;:16::i;:::-;1741:24;:22;:24::i;:::-;3651:14:15::0;3647:99;;;3697:5;3681:21;;-1:-1:-1;;3681:21:15;;;3721:14;;-1:-1:-1;24132:36:20;;3721:14:15;;24120:2:20;24105:18;3721:14:15;;;;;;;3269:483;1664:108:0:o;9403:793::-;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;9549:509:::1;::::0;;::::1;::::0;::::1;::::0;;;9497:49:::1;::::0;9549:509;9612:56:::1;9606:63;9549:509;;::::0;;9697:51:::1;9549:509;::::0;;::::1;::::0;;;9786:64:::1;9549:509:::0;;;;;;;;9895:4:::1;9549:509:::0;;;;9961:13:::1;::::0;9936:39;;;:24:::1;:39:::0;;;;;;-1:-1:-1;;;;;9936:39:0::1;9549:509:::0;;;;10001:7:::1;::::0;9549:509;;;;;;;;;;;;10117:16;;9497:561;;-1:-1:-1;9697:51:0;10117:16:::1;::::0;10128:4;;10117:16:::1;;:::i;6402:783::-:0;1174:5;;-1:-1:-1;;;;;1174:5:0;1152:10;:28;1144:84;;;;-1:-1:-1;;;1144:84:0;;;;;;;:::i;:::-;6546:501:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;6546:501:0;;;::::1;::::0;;::::1;::::0;;;6776:63:::1;6546:501:::0;;;;6884:4:::1;6546:501:::0;;;;6950:13:::1;::::0;6925:39;;;:24:::1;:39:::0;;;;;;-1:-1:-1;;;;;6925:39:0::1;6546:501:::0;;;;6990:7:::1;::::0;6546:501;;;;;;;;7106:16;;6546:501;;-1:-1:-1;;7106:16:0::1;::::0;7117:4;;7106:16:::1;;:::i;2100:90::-:0;1334:13:10;:11;:13::i;:::-;2165:7:0::1;:18:::0;2100:90::o;2314:198:10:-;1334:13;:11;:13::i;:::-;-1:-1:-1;;;;;2402:22:10;::::1;2394:73;;;::::0;-1:-1:-1;;;2394:73:10;;25312:2:20;2394:73:10::1;::::0;::::1;25294:21:20::0;25351:2;25331:18;;;25324:30;25390:34;25370:18;;;25363:62;-1:-1:-1;;;25441:18:20;;;25434:36;25487:19;;2394:73:10::1;25110:402:20::0;2394:73:10::1;2477:28;2496:8;2477:18;:28::i;2740:217:0:-:0;1334:13:10;:11;:13::i;:::-;2855::0::1;:24:::0;;;2889:34:::1;::::0;;;:24:::1;:34;::::0;;;;;:61;;-1:-1:-1;;;;;;2889:61:0::1;-1:-1:-1::0;;;;;2889:61:0;;::::1;::::0;;;::::1;::::0;;2740:217::o;1599:130:10:-;1513:6;;-1:-1:-1;;;;;1513:6:10;929:10:18;1662:23:10;1654:68;;;;-1:-1:-1;;;1654:68:10;;25719:2:20;1654:68:10;;;25701:21:20;;;25738:18;;;25731:30;25797:34;25777:18;;;25770:62;25849:18;;1654:68:10;25517:356:20;2820:944:13;971:66;3236:59;;;3232:526;;;3311:37;3330:17;3311:18;:37::i;3232:526::-;3412:17;-1:-1:-1;;;;;3383:61:13;;:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3383:63:13;;;;;;;;-1:-1:-1;;3383:63:13;;;;;;;;;;;;:::i;:::-;;;3379:302;;3610:56;;-1:-1:-1;;;3610:56:13;;26269:2:20;3610:56:13;;;26251:21:20;26308:2;26288:18;;;26281:30;26347:34;26327:18;;;26320:62;-1:-1:-1;;;26398:18:20;;;26391:44;26452:19;;3610:56:13;26067:410:20;3379:302:13;-1:-1:-1;;;;;;;;;;;3496:28:13;;3488:82;;;;-1:-1:-1;;;3488:82:13;;26684:2:20;3488:82:13;;;26666:21:20;26723:2;26703:18;;;26696:30;26762:34;26742:18;;;26735:62;-1:-1:-1;;;26813:18:20;;;26806:39;26862:19;;3488:82:13;26482:405:20;3488:82:13;3447:138;3694:53;3712:17;3731:4;3737:9;3694:17;:53::i;1778:84:0:-;1334:13:10;:11;:13::i;2666:187::-;2758:6;;;-1:-1:-1;;;;;2774:17:10;;;-1:-1:-1;;;;;;2774:17:10;;;;;;;2806:40;;2758:6;;;2774:17;2758:6;;2806:40;;2739:16;;2806:40;2729:124;2666:187;:::o;12084:1126:0:-;12136:36;12175:326;;;;;;;;12233:1;12225:10;;12175:326;;;;12335:1;12327:10;;12175:326;;;;12362:50;;;;;;;;;;;;;;-1:-1:-1;;;12362:50:0;;;:25;:50::i;:::-;12175:326;;12439:1;12175:326;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12563:509;;;;;;;;12136:365;;-1:-1:-1;12563:509:0;12626:56;12620:63;;517:138:5;589:7;642:4;625:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;615:33;;;;;;608:40;;517:138;;;:::o;5275:114:0:-;5362:5;;:20;;-1:-1:-1;;;5362:20:0;;-1:-1:-1;;;;;5362:5:0;;;;:14;;:20;;5377:4;;5362:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5275:114;:::o;1003:95:10:-;5374:13:15;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:15;;;;;;;:::i;:::-;1065:26:10::1;:24;:26::i;1042:67:16:-:0;5374:13:15;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:15;;;;;;;:::i;1699:281:13:-;-1:-1:-1;;;;;1713:19:17;;;1772:106:13;;;;-1:-1:-1;;;1772:106:13;;27800:2:20;1772:106:13;;;27782:21:20;27839:2;27819:18;;;27812:30;27878:34;27858:18;;;27851:62;-1:-1:-1;;;27929:18:20;;;27922:43;27982:19;;1772:106:13;27598:409:20;1772:106:13;-1:-1:-1;;;;;;;;;;;1888:85:13;;-1:-1:-1;;;;;;1888:85:13;-1:-1:-1;;;;;1888:85:13;;;;;;;;;;1699:281::o;2372:276::-;2480:29;2491:17;2480:10;:29::i;:::-;2537:1;2523:4;:11;:15;:28;;;;2542:9;2523:28;2519:123;;;2567:64;2607:17;2626:4;2567:39;:64::i;1104:111:10:-;5374:13:15;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:15;;;;;;;:::i;:::-;1176:32:10::1;929:10:18::0;1176:18:10::1;:32::i;2086:152:13:-:0;2152:37;2171:17;2152:18;:37::i;:::-;2204:27;;-1:-1:-1;;;;;2204:27:13;;;;;;;;2086:152;:::o;6685:198:17:-;6768:12;6799:77;6820:6;6828:4;6799:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;6792:84;;6685:198;;;;;:::o;7069:325::-;7210:12;7235;7249:23;7276:6;-1:-1:-1;;;;;7276:19:17;7296:4;7276:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7234:67;;;;7318:69;7345:6;7353:7;7362:10;7374:12;7318:26;:69::i;:::-;7311:76;7069:325;-1:-1:-1;;;;;;7069:325:17:o;7682:628::-;7862:12;7890:7;7886:418;;;7917:10;:17;7938:1;7917:22;7913:286;;-1:-1:-1;;;;;1713:19:17;;;8124:60;;;;-1:-1:-1;;;8124:60:17;;28506:2:20;8124:60:17;;;28488:21:20;28545:2;28525:18;;;28518:30;28584:31;28564:18;;;28557:59;28633:18;;8124:60:17;28304:353:20;8124:60:17;-1:-1:-1;8219:10:17;8212:17;;7886:418;8260:33;8268:10;8280:12;8991:17;;:21;8987:379;;9219:10;9213:17;9275:15;9262:10;9258:2;9254:19;9247:44;8987:379;9342:12;9335:20;;-1:-1:-1;;;9335:20:17;;;;;;;;:::i;14:127:20:-;75:10;70:3;66:20;63:1;56:31;106:4;103:1;96:15;130:4;127:1;120:15;146:253;218:2;212:9;260:4;248:17;;-1:-1:-1;;;;;280:34:20;;316:22;;;277:62;274:88;;;342:18;;:::i;:::-;378:2;371:22;146:253;:::o;404:::-;476:2;470:9;518:4;506:17;;-1:-1:-1;;;;;538:34:20;;574:22;;;535:62;532:88;;;600:18;;:::i;662:255::-;734:2;728:9;776:6;764:19;;-1:-1:-1;;;;;798:34:20;;834:22;;;795:62;792:88;;;860:18;;:::i;922:275::-;993:2;987:9;1058:2;1039:13;;-1:-1:-1;;1035:27:20;1023:40;;-1:-1:-1;;;;;1078:34:20;;1114:22;;;1075:62;1072:88;;;1140:18;;:::i;:::-;1176:2;1169:22;922:275;;-1:-1:-1;922:275:20:o;1202:131::-;-1:-1:-1;;;;;1277:31:20;;1267:42;;1257:70;;1323:1;1320;1313:12;1338:134;1406:20;;1435:31;1406:20;1435:31;:::i;:::-;1338:134;;;:::o;1477:146::-;-1:-1:-1;;;;;1556:5:20;1552:46;1545:5;1542:57;1532:85;;1613:1;1610;1603:12;1628:134;1696:20;;1725:31;1696:20;1725:31;:::i;1767:129::-;-1:-1:-1;;;;;1845:5:20;1841:30;1834:5;1831:41;1821:69;;1886:1;1883;1876:12;1901:132;1968:20;;1997:30;1968:20;1997:30;:::i;2038:769::-;2097:5;2145:4;2133:9;2128:3;2124:19;2120:30;2117:50;;;2163:1;2160;2153:12;2117:50;2185:22;;:::i;:::-;2176:31;;2243:9;2230:23;2223:5;2216:38;2306:2;2295:9;2291:18;2278:32;2319:33;2344:7;2319:33;:::i;:::-;2384:7;2379:2;2372:5;2368:14;2361:31;;2452:2;2441:9;2437:18;2424:32;2419:2;2412:5;2408:14;2401:56;2517:2;2506:9;2502:18;2489:32;2484:2;2477:5;2473:14;2466:56;2574:3;2563:9;2559:19;2546:33;2588;2613:7;2588:33;:::i;:::-;2648:3;2637:15;;2630:32;2714:3;2699:19;;2686:33;2728:32;2686:33;2728:32;:::i;:::-;2787:3;2776:15;;2769:32;2780:5;2038:769;-1:-1:-1;;2038:769:20:o;2812:238::-;2901:6;2954:3;2942:9;2933:7;2929:23;2925:33;2922:53;;;2971:1;2968;2961:12;2922:53;2994:50;3036:7;3025:9;2994:50;:::i;3237:247::-;3296:6;3349:2;3337:9;3328:7;3324:23;3320:32;3317:52;;;3365:1;3362;3355:12;3317:52;3404:9;3391:23;3423:31;3448:5;3423:31;:::i;:::-;3473:5;3237:247;-1:-1:-1;;;3237:247:20:o;3489:813::-;3561:5;3609:4;3597:9;3592:3;3588:19;3584:30;3581:50;;;3627:1;3624;3617:12;3581:50;3649:22;;:::i;:::-;3640:31;;3708:9;3695:23;3763:7;3756:15;3749:23;3740:7;3737:36;3727:64;;3787:1;3784;3777:12;3727:64;3800:22;;3874:2;3859:18;;3846:32;3887;3846;3887;:::i;:::-;3946:2;3935:14;;3928:31;4011:2;3996:18;;3983:32;4024:33;3983:32;4024:33;:::i;:::-;4089:7;4084:2;4077:5;4073:14;4066:31;;4157:2;4146:9;4142:18;4129:32;4124:2;4117:5;4113:14;4106:56;4223:3;4212:9;4208:19;4195:33;4189:3;4182:5;4178:15;4171:58;4290:3;4279:9;4275:19;4262:33;4256:3;4249:5;4245:15;4238:58;3489:813;;;;:::o;4307:264::-;4409:6;4462:3;4450:9;4441:7;4437:23;4433:33;4430:53;;;4479:1;4476;4469:12;4430:53;4502:63;4557:7;4546:9;4502:63;:::i;4576:373::-;4674:6;4682;4735:3;4723:9;4714:7;4710:23;4706:33;4703:53;;;4752:1;4749;4742:12;4703:53;4791:9;4778:23;4810:31;4835:5;4810:31;:::i;:::-;4860:5;-1:-1:-1;4884:59:20;4935:7;4930:2;4915:18;;4884:59;:::i;:::-;4874:69;;4576:373;;;;;:::o;4954:186::-;5002:4;-1:-1:-1;;;;;5027:6:20;5024:30;5021:56;;;5057:18;;:::i;:::-;-1:-1:-1;5123:2:20;5102:15;-1:-1:-1;;5098:29:20;5129:4;5094:40;;4954:186::o;5145:462::-;5187:5;5240:3;5233:4;5225:6;5221:17;5217:27;5207:55;;5258:1;5255;5248:12;5207:55;5294:6;5281:20;5325:48;5341:31;5369:2;5341:31;:::i;:::-;5325:48;:::i;:::-;5398:2;5389:7;5382:19;5444:3;5437:4;5432:2;5424:6;5420:15;5416:26;5413:35;5410:55;;;5461:1;5458;5451:12;5410:55;5526:2;5519:4;5511:6;5507:17;5500:4;5491:7;5487:18;5474:55;5574:1;5549:16;;;5567:4;5545:27;5538:38;;;;5553:7;5145:462;-1:-1:-1;;;5145:462:20:o;5612:455::-;5689:6;5697;5750:2;5738:9;5729:7;5725:23;5721:32;5718:52;;;5766:1;5763;5756:12;5718:52;5805:9;5792:23;5824:31;5849:5;5824:31;:::i;:::-;5874:5;-1:-1:-1;5930:2:20;5915:18;;5902:32;-1:-1:-1;;;;;5946:30:20;;5943:50;;;5989:1;5986;5979:12;5943:50;6012:49;6053:7;6044:6;6033:9;6029:22;6012:49;:::i;:::-;6002:59;;;5612:455;;;;;:::o;6523:114::-;6607:4;6600:5;6596:16;6589:5;6586:27;6576:55;;6627:1;6624;6617:12;6642:1242;6746:6;6754;6798:9;6789:7;6785:23;6828:3;6824:2;6820:12;6817:32;;;6845:1;6842;6835:12;6817:32;6869:4;6865:2;6861:13;6858:33;;;6887:1;6884;6877:12;6858:33;;6913:22;;:::i;:::-;6972:9;6959:23;6991:31;7014:7;6991:31;:::i;:::-;7031:22;;7105:2;7090:18;;7077:32;7118:31;7077:32;7118:31;:::i;:::-;7176:2;7165:14;;7158:31;7241:2;7226:18;;7213:32;7254:31;7213:32;7254:31;:::i;:::-;7312:2;7301:14;;7294:31;7377:2;7362:18;;7349:32;7390:33;7349:32;7390:33;:::i;:::-;7450:2;7439:14;;7432:31;7496:39;7530:3;7515:19;;7496:39;:::i;:::-;7490:3;7483:5;7479:15;7472:64;7597:3;7586:9;7582:19;7569:33;7563:3;7556:5;7552:15;7545:58;7664:3;7653:9;7649:19;7636:33;7630:3;7623:5;7619:15;7612:58;7689:5;7679:15;;;7745:4;7734:9;7730:20;7717:34;-1:-1:-1;;;;;7766:6:20;7763:30;7760:50;;;7806:1;7803;7796:12;8331:1026;8421:6;8452:3;8496:2;8484:9;8475:7;8471:23;8467:32;8464:52;;;8512:1;8509;8502:12;8464:52;8545:2;8539:9;8575:15;;;;-1:-1:-1;;;;;8605:34:20;;8641:22;;;8602:62;8599:88;;;8667:18;;:::i;:::-;8707:10;8703:2;8696:22;8755:9;8742:23;8734:6;8727:39;8827:2;8816:9;8812:18;8799:32;8794:2;8786:6;8782:15;8775:57;8893:2;8882:9;8878:18;8865:32;8860:2;8852:6;8848:15;8841:57;8948:2;8937:9;8933:18;8920:32;8907:45;;8961:31;8986:5;8961:31;:::i;:::-;9025:5;9020:2;9012:6;9008:15;9001:30;9065:39;9099:3;9088:9;9084:19;9065:39;:::i;:::-;9059:3;9051:6;9047:16;9040:65;9139:39;9173:3;9162:9;9158:19;9139:39;:::i;:::-;9133:3;9125:6;9121:16;9114:65;9213:39;9247:3;9236:9;9232:19;9213:39;:::i;:::-;9207:3;9199:6;9195:16;9188:65;9287:38;9320:3;9309:9;9305:19;9287:38;:::i;:::-;9281:3;9269:16;;9262:64;9273:6;8331:1026;-1:-1:-1;;;;8331:1026:20:o;9362:180::-;9421:6;9474:2;9462:9;9453:7;9449:23;9445:32;9442:52;;;9490:1;9487;9480:12;9442:52;-1:-1:-1;9513:23:20;;9362:180;-1:-1:-1;9362:180:20:o;9770:250::-;9855:1;9865:113;9879:6;9876:1;9873:13;9865:113;;;9955:11;;;9949:18;9936:11;;;9929:39;9901:2;9894:10;9865:113;;;-1:-1:-1;;10012:1:20;9994:16;;9987:27;9770:250::o;10025:271::-;10067:3;10105:5;10099:12;10132:6;10127:3;10120:19;10148:76;10217:6;10210:4;10205:3;10201:14;10194:4;10187:5;10183:16;10148:76;:::i;:::-;10278:2;10257:15;-1:-1:-1;;10253:29:20;10244:39;;;;10285:4;10240:50;;10025:271;-1:-1:-1;;10025:271:20:o;10301:220::-;10450:2;10439:9;10432:21;10413:4;10470:45;10511:2;10500:9;10496:18;10488:6;10470:45;:::i;10526:315::-;10594:6;10602;10655:2;10643:9;10634:7;10630:23;10626:32;10623:52;;;10671:1;10668;10661:12;10623:52;10707:9;10694:23;10684:33;;10767:2;10756:9;10752:18;10739:32;10780:31;10805:5;10780:31;:::i;:::-;10830:5;10820:15;;;10526:315;;;;;:::o;10846:127::-;10907:10;10902:3;10898:20;10895:1;10888:31;10938:4;10935:1;10928:15;10962:4;10959:1;10952:15;10978:652;11203:13;;11185:32;;11277:4;11265:17;;;11259:24;-1:-1:-1;;;;;11255:50:20;11233:20;;;11226:80;11362:4;11350:17;;;11344:24;11322:20;;;11315:54;11425:4;11413:17;;;11407:24;11385:20;;;11378:54;11492:4;11480:17;;;11474:24;-1:-1:-1;;;;;11470:65:20;11448:20;;;11441:95;11293:3;11584:17;;;11578:24;-1:-1:-1;;;;;11574:49:20;11552:20;;;11545:79;;;;11172:3;11157:19;;10978:652::o;11635:560::-;11728:4;11720:5;11714:12;11710:23;11705:3;11698:36;11795:4;11787;11780:5;11776:16;11770:23;11766:34;11759:4;11754:3;11750:14;11743:58;11862:4;11854;11847:5;11843:16;11837:23;11833:34;11826:4;11821:3;11817:14;11810:58;11914:4;11907:5;11903:16;11897:23;11956:1;11952;11947:3;11943:11;11939:19;12008:2;11994:12;11990:21;11983:4;11978:3;11974:14;11967:45;12073:2;12065:4;12058:5;12054:16;12048:23;12044:32;12037:4;12032:3;12028:14;12021:56;;;12126:4;12119:5;12115:16;12109:23;12102:4;12097:3;12093:14;12086:47;12182:4;12175:5;12171:16;12165:23;12158:4;12153:3;12149:14;12142:47;11635:560;;:::o;12200:387::-;12392:4;12421:3;12433:46;12469:9;12461:6;12433:46;:::i;:::-;12516:2;12510:3;12499:9;12495:19;12488:31;12536:45;12577:2;12566:9;12562:18;12554:6;12536:45;:::i;:::-;12528:53;12200:387;-1:-1:-1;;;;;12200:387:20:o;12592:184::-;12662:6;12715:2;12703:9;12694:7;12690:23;12686:32;12683:52;;;12731:1;12728;12721:12;12683:52;-1:-1:-1;12754:16:20;;12592:184;-1:-1:-1;12592:184:20:o;12781:407::-;12983:2;12965:21;;;13022:2;13002:18;;;12995:30;13061:34;13056:2;13041:18;;13034:62;-1:-1:-1;;;13127:2:20;13112:18;;13105:41;13178:3;13163:19;;12781:407::o;13670:301::-;13890:3;13875:19;;13903:62;13879:9;13947:6;13304:5;13298:12;13291:20;13284:28;13279:3;13272:41;-1:-1:-1;;;;;13366:4:20;13359:5;13355:16;13349:23;13345:48;13338:4;13333:3;13329:14;13322:72;-1:-1:-1;;;;;13447:4:20;13440:5;13436:16;13430:23;13426:64;13419:4;13414:3;13410:14;13403:88;13540:4;13533:5;13529:16;13523:23;13516:4;13511:3;13507:14;13500:47;13596:4;13589:5;13585:16;13579:23;13572:4;13567:3;13563:14;13556:47;13652:4;13645:5;13641:16;13635:23;13628:4;13623:3;13619:14;13612:47;;;13193:472;13976:484;-1:-1:-1;;;;;14255:32:20;;14237:51;;14196:4;14225:3;14297:55;14348:2;14333:18;;14325:6;14297:55;:::i;:::-;14389:2;14383:3;14372:9;14368:19;14361:31;14409:45;14450:2;14439:9;14435:18;14427:6;14409:45;:::i;16857:138::-;16936:13;;16958:31;16936:13;16958:31;:::i;17000:134::-;17077:13;;17099:29;17077:13;17099:29;:::i;17139:138::-;17218:13;;17240:31;17218:13;17240:31;:::i;17282:136::-;17360:13;;17382:30;17360:13;17382:30;:::i;17423:442::-;17477:5;17530:3;17523:4;17515:6;17511:17;17507:27;17497:55;;17548:1;17545;17538:12;17497:55;17577:6;17571:13;17608:48;17624:31;17652:2;17624:31;:::i;17608:48::-;17681:2;17672:7;17665:19;17727:3;17720:4;17715:2;17707:6;17703:15;17699:26;17696:35;17693:55;;;17744:1;17741;17734:12;17693:55;17757:77;17831:2;17824:4;17815:7;17811:18;17804:4;17796:6;17792:17;17757:77;:::i;17870:1644::-;17970:6;18023:2;18011:9;18002:7;17998:23;17994:32;17991:52;;;18039:1;18036;18029:12;17991:52;18072:9;18066:16;-1:-1:-1;;;;;18142:2:20;18134:6;18131:14;18128:34;;;18158:1;18155;18148:12;18128:34;18181:22;;;;18237:6;18219:16;;;18215:29;18212:49;;;18257:1;18254;18247:12;18212:49;18283:22;;:::i;:::-;18328:33;18358:2;18328:33;:::i;:::-;18321:5;18314:48;18394:42;18432:2;18428;18424:11;18394:42;:::i;:::-;18389:2;18382:5;18378:14;18371:66;18483:2;18479;18475:11;18469:18;18464:2;18457:5;18453:14;18446:42;18534:2;18530;18526:11;18520:18;18515:2;18508:5;18504:14;18497:42;18586:3;18582:2;18578:12;18572:19;18566:3;18559:5;18555:15;18548:44;18639:3;18635:2;18631:12;18625:19;18619:3;18612:5;18608:15;18601:44;18678:41;18714:3;18710:2;18706:12;18678:41;:::i;:::-;18672:3;18665:5;18661:15;18654:66;18753:43;18791:3;18787:2;18783:12;18753:43;:::i;:::-;18747:3;18740:5;18736:15;18729:68;18816:3;18851:41;18888:2;18884;18880:11;18851:41;:::i;:::-;18835:14;;;18828:65;18912:3;18947:42;18977:11;;;18947:42;:::i;:::-;18931:14;;;18924:66;19009:3;19044:41;19073:11;;;19044:41;:::i;:::-;19028:14;;;19021:65;19105:3;19139:11;;;19133:18;19163:16;;;19160:36;;;19192:1;19189;19182:12;19160:36;19228:56;19276:7;19265:8;19261:2;19257:17;19228:56;:::i;:::-;19223:2;19216:5;19212:14;19205:80;;;19304:3;19346:2;19342;19338:11;19332:18;19375:2;19365:8;19362:16;19359:36;;;19391:1;19388;19381:12;19359:36;19427:56;19475:7;19464:8;19460:2;19456:17;19427:56;:::i;:::-;19411:14;;;19404:80;;;;-1:-1:-1;19415:5:20;17870:1644;-1:-1:-1;;;;;17870:1644:20:o;19519:825::-;19626:6;19679:3;19667:9;19658:7;19654:23;19650:33;19647:53;;;19696:1;19693;19686:12;19647:53;19722:22;;:::i;:::-;19774:9;19768:16;19828:10;19819:7;19815:24;19806:7;19803:37;19793:65;;19854:1;19851;19844:12;19793:65;19867:22;;19921:48;19965:2;19950:18;;19921:48;:::i;:::-;19916:2;19909:5;19905:14;19898:72;20002:49;20047:2;20036:9;20032:18;20002:49;:::i;:::-;19997:2;19990:5;19986:14;19979:73;20105:2;20094:9;20090:18;20084:25;20079:2;20072:5;20068:14;20061:49;20164:3;20153:9;20149:19;20143:26;20137:3;20130:5;20126:15;20119:51;20224:3;20213:9;20209:19;20203:26;20197:3;20190:5;20186:15;20179:51;20263:50;20308:3;20297:9;20293:19;20263:50;:::i;:::-;20257:3;20246:15;;20239:75;20250:5;19519:825;-1:-1:-1;;;19519:825:20:o;21100:1114::-;21207:6;21260:2;21248:9;21239:7;21235:23;21231:32;21228:52;;;21276:1;21273;21266:12;21228:52;21309:9;21303:16;-1:-1:-1;;;;;21379:2:20;21371:6;21368:14;21365:34;;;21395:1;21392;21385:12;21365:34;21418:22;;;;21474:4;21456:16;;;21452:27;21449:47;;;21492:1;21489;21482:12;21449:47;21518:22;;:::i;:::-;21563:32;21592:2;21563:32;:::i;:::-;21556:5;21549:47;21628:42;21666:2;21662;21658:11;21628:42;:::i;:::-;21623:2;21616:5;21612:14;21605:66;21717:2;21713;21709:11;21703:18;21698:2;21691:5;21687:14;21680:42;21768:2;21764;21760:11;21754:18;21749:2;21742:5;21738:14;21731:42;21820:3;21816:2;21812:12;21806:19;21800:3;21793:5;21789:15;21782:44;21865:3;21861:2;21857:12;21851:19;21895:2;21885:8;21882:16;21879:36;;;21911:1;21908;21901:12;21879:36;21948:56;21996:7;21985:8;21981:2;21977:17;21948:56;:::i;:::-;21942:3;21935:5;21931:15;21924:81;;22044:3;22040:2;22036:12;22030:19;22074:2;22064:8;22061:16;22058:36;;;22090:1;22087;22080:12;22058:36;22127:56;22175:7;22164:8;22160:2;22156:17;22127:56;:::i;:::-;22121:3;22110:15;;22103:81;-1:-1:-1;22114:5:20;21100:1114;-1:-1:-1;;;;;21100:1114:20:o;22219:923::-;22422:2;22411:9;22404:21;-1:-1:-1;;;;;22471:6:20;22465:13;22461:38;22456:2;22445:9;22441:18;22434:66;-1:-1:-1;;;;;22558:2:20;22550:6;22546:15;22540:22;22536:63;22531:2;22520:9;22516:18;22509:91;22654:2;22646:6;22642:15;22636:22;22631:2;22620:9;22616:18;22609:50;22714:2;22706:6;22702:15;22696:22;22690:3;22679:9;22675:19;22668:51;22774:3;22766:6;22762:16;22756:23;22750:3;22739:9;22735:19;22728:52;22385:4;22827:3;22819:6;22815:16;22809:23;22869:4;22863:3;22852:9;22848:19;22841:33;22897:52;22944:3;22933:9;22929:19;22915:12;22897:52;:::i;:::-;22883:66;;22998:3;22990:6;22986:16;22980:23;23073:2;23069:7;23057:9;23049:6;23045:22;23041:36;23034:4;23023:9;23019:20;23012:66;23095:41;23129:6;23113:14;23095:41;:::i;24179:926::-;24333:4;24375:3;24364:9;24360:19;24352:27;;24412:6;24406:13;24395:9;24388:32;24476:4;24468:6;24464:17;24458:24;24451:4;24440:9;24436:20;24429:54;24539:4;24531:6;24527:17;24521:24;24514:4;24503:9;24499:20;24492:54;24593:4;24585:6;24581:17;24575:24;-1:-1:-1;;;;;24708:2:20;24694:12;24690:21;24683:4;24672:9;24668:20;24661:51;24780:2;24772:4;24764:6;24760:17;24754:24;24750:33;24743:4;24732:9;24728:20;24721:63;;;24833:4;24825:6;24821:17;24815:24;24875:1;24871;24866:3;24862:11;24858:19;24935:2;24919:14;24915:23;24908:4;24897:9;24893:20;24886:53;25007:2;24999:4;24991:6;24987:17;24981:24;24977:33;24970:4;24959:9;24955:20;24948:63;;;-1:-1:-1;;;;;25071:4:20;25063:6;25059:17;25053:24;25049:49;25042:4;25031:9;25027:20;25020:79;24179:926;;;;:::o;26892:289::-;27023:3;27061:6;27055:13;27077:66;27136:6;27131:3;27124:4;27116:6;27112:17;27077:66;:::i;:::-;27159:16;;;;;26892:289;-1:-1:-1;;26892:289:20:o;27186:407::-;27388:2;27370:21;;;27427:2;27407:18;;;27400:30;27466:34;27461:2;27446:18;;27439:62;-1:-1:-1;;;27532:2:20;27517:18;;27510:41;27583:3;27568:19;;27186:407::o

ipfs://0ca591efdf9e9dfef0d97fa254836fb591c508d62002b1c8ed152194da2a1bbd