Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity =0.8.19;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {BlastERC20RebasingManage} from "../integration/BlastERC20RebasingManage.sol";

import {IPairFactory} from "./interfaces/IPairFactory.sol";

// Pair Fees contract is used as a 1:1 pair relationship to split out fees, this ensures that the curve does not need to be modified for LP shares
contract PairFees is BlastERC20RebasingManage {
    address internal immutable pair; // The pair it is bonded to
    address internal immutable token0; // token0 of pair, saved localy and statically for gas optimization
    address internal immutable token1; // Token1 of pair, saved localy and statically for gas optimization
    address internal immutable factory; // The pair factory

    constructor(
        address _blastGovernor,
        address _blastPoints,
        address _blastPointsOperator,
        address _factory,
        address _token0,
        address _token1
    ) {
        __BlastERC20RebasingManage__init(_blastGovernor, _blastPoints, _blastPointsOperator);

        pair = msg.sender;
        token0 = _token0;
        token1 = _token1;
        factory = _factory;
    }

    function _safeTransfer(address token, address to, uint256 value) internal {
        require(token.code.length > 0);
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))));
    }

    // Allow the pair to transfer fees to users
    function claimFeesFor(address recipient, uint amount0, uint amount1) external {
        require(msg.sender == pair);
        if (amount0 > 0) _safeTransfer(token0, recipient, amount0);
        if (amount1 > 0) _safeTransfer(token1, recipient, amount1);
    }

    function _checkAccessForManageBlastERC20Rebasing() internal virtual override {
        IPairFactory factoryCache = IPairFactory(factory);
        require(
            msg.sender == address(factoryCache) || factoryCache.hasRole(factoryCache.PAIRS_ADMINISTRATOR_ROLE(), msg.sender),
            "ACCESS_DENIED"
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

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

interface IPairFactory {
    event PairCreated(address indexed token0, address indexed token1, bool stable, address pair, uint);
    event SetPaused(bool state);
    event SetCommunityVaultFactory(address indexed communityVaultFactory);
    event SetIsPublicPoolCreationMode(bool mode);
    event SetProtocolFee(uint256 fee);
    event SetCustomProtocolFee(address indexed pair, uint256 fee);
    event SetCustomFee(address indexed pair, uint256 fee);
    event SetFee(bool stable, uint256 fee);
    /**
     * @dev Emitted when the rebasing tokens governor address is set.
     *
     * @param oldRebasingTokensGovernor The previous address of the rebasing tokens governor.
     * @param newRebasingTokensGovernor The new address of the rebasing tokens governor.
     */
    event SetRebasingTokensGovernor(address indexed oldRebasingTokensGovernor, address indexed newRebasingTokensGovernor);

    error IncorrcectFee();
    error IncorrectPair();
    error IdenticalAddress();
    error PairExist();

    function implementation() external view returns (address);

    function PAIRS_ADMINISTRATOR_ROLE() external view returns (bytes32);

    function FEES_MANAGER_ROLE() external view returns (bytes32);

    function PAIRS_CREATOR_ROLE() external view returns (bytes32);

    function hasRole(bytes32 role, address user) external view returns (bool);

    function allPairsLength() external view returns (uint);

    function isPair(address pair) external view returns (bool);

    function allPairs(uint index) external view returns (address);

    function getPair(address tokenA, address token, bool stable) external view returns (address);

    function createPair(address tokenA, address tokenB, bool stable) external returns (address pair);

    function pairs() external view returns (address[] memory);

    function getFee(address pair_, bool stable_) external view returns (uint256);

    function getHookTarget(address pair_) external view returns (address);

    function getProtocolFee(address pair_) external view returns (uint256);

    function isPaused() external view returns (bool);

    function isPublicPoolCreationMode() external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity =0.8.19;

import {YieldMode, IERC20Rebasing, IBlastERC20RebasingManage} from "./interfaces/IBlastERC20RebasingManage.sol";
import {IBlastPoints} from "./interfaces/IBlastPoints.sol";
import {BlastGovernorClaimableSetup} from "./BlastGovernorClaimableSetup.sol";

/**
 * @title BlastERC20RebasingManage
 * @dev Abstract contract designed to manage ERC20 rebasing tokens within the Blast ecosystem.
 * It provides functionalities to configure and claim tokens while ensuring that only authorized
 * entities can perform these operations.
 */
abstract contract BlastERC20RebasingManage is IBlastERC20RebasingManage, BlastGovernorClaimableSetup {
    /**
     * @dev Initializes the BlastERC20RebasingManage contract. Sets up the initial configuration
     * for managing ERC20 rebasing tokens within the Blast ecosystem. This includes setting the Blast Governor,
     * configuring the Blast Points, and assigning the Blast Points operator.
     *
     * @param blastGovernor_ The address of the Blast Governor to be used for governance processes.
     * @param blastPoints_ The address of the Blast Points contract, used for managing points within the ecosystem.
     * @param blastPointsOperator_ The address of the operator authorized to manage points in the Blast Points contract.
     *
     * Requirements:
     * - `blastGovernor_`, `blastPoints_` and `blastPointsOperator_` must not be the zero address.
     *
     * Emits an `AddressZero` error if any of the required addresses are zero.
     */
    function __BlastERC20RebasingManage__init(address blastGovernor_, address blastPoints_, address blastPointsOperator_) internal {
        if (blastPoints_ == address(0) || blastPointsOperator_ == address(0)) {
            revert AddressZero();
        }
        __BlastGovernorClaimableSetup_init(blastGovernor_);
        IBlastPoints(blastPoints_).configurePointsOperator(blastPointsOperator_);
    }

    /**
     * @dev Configures the rebasing parameters of a specified ERC20 rebasing token.
     * This function can only be called by addresses with the required access permissions.
     * Implementations of this contract should ensure that the `_checkAccessForManageBlastERC20Rebasing`
     * function is called to enforce access control.
     *
     * @param erc20Rebasing_ The address of the ERC20 rebasing token to configure.
     * @param mode_ The yield mode to apply to the token, determining how rebasing mechanics are handled.
     * @return A uint256 value that represents the outcome of the configuration operation,
     * which could be an updated token supply or another relevant metric, depending on the ERC20 rebasing token implementation.
     */
    function configure(address erc20Rebasing_, YieldMode mode_) external virtual returns (uint256) {
        _checkAccessForManageBlastERC20Rebasing();

        return IERC20Rebasing(erc20Rebasing_).configure(mode_);
    }

    /**
     * @dev Claims rebasing tokens on behalf of the caller and transfers them to a specified recipient.
     * This function can only be executed by addresses with the necessary access permissions.
     *
     * @param erc20Rebasing_ The address of the ERC20 rebasing token from which tokens are claimed.
     * @param recipient_ The recipient address to receive the claimed tokens.
     * @param amount_ The amount of tokens to claim.
     * @return The result of the claim operation, specific to the ERC20 rebasing token implementation.
     */
    function claim(address erc20Rebasing_, address recipient_, uint256 amount_) external virtual returns (uint256) {
        _checkAccessForManageBlastERC20Rebasing();

        return IERC20Rebasing(erc20Rebasing_).claim(recipient_, amount_);
    }

    /**
     * @dev Internal function to check if the message sender has the required permissions to manage ERC20 rebasing tokens.
     * Reverts the transaction if the sender is not authorized.
     */
    function _checkAccessForManageBlastERC20Rebasing() internal virtual;
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity =0.8.19;

import {IBlastFull, YieldMode, GasMode} from "./interfaces/IBlastFull.sol";
import {IBlastGovernor} from "./interfaces/IBlastGovernor.sol";

/**
 * @title Blast Governor Claiamble Setup
 * @dev Abstract contract for setting up a governor in the Blast ecosystem.
 * This contract provides an initialization function to configure a governor address
 * for the Blast protocol, utilizing the `IBlast` interface.
 */
abstract contract BlastGovernorClaimableSetup {
    /// @dev Error thrown when an operation involves a zero address where a valid address is required.
    error AddressZero();

    /**
     * @dev Initializes the governor and claimable configuration for the Blast protocol.
     * This internal function is meant to be called in the initialization process
     * of a derived contract that sets up governance.
     *
     * @param blastGovernor_ The address of the governor to be configured in the Blast protocol.
     * Must be a non-zero address.
     */
    function __BlastGovernorClaimableSetup_init(address blastGovernor_) internal {
        if (blastGovernor_ == address(0)) {
            revert AddressZero();
        }
        IBlastFull(0x4300000000000000000000000000000000000002).configure(YieldMode.CLAIMABLE, GasMode.CLAIMABLE, blastGovernor_);
        if (blastGovernor_.code.length > 0) {
            IBlastGovernor(blastGovernor_).addGasHolder(address(this));
        }
    }
}

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

import {YieldMode, IERC20Rebasing} from "./IERC20Rebasing.sol";

/**
 * @title IBlastERC20RebasingManage Interface
 * @dev Interface for managing ERC20 rebasing tokens within the Blast ecosystem. It provides
 * the necessary functions to configure and claim tokens, ensuring that only authorized
 * entities can perform these operations. This interface mandates the implementation of
 * access control checks to secure the rebasing token management.
 */
interface IBlastERC20RebasingManage {
    /**
     * @dev Configures the rebasing parameters of a specified ERC20 rebasing token.
     * This function can only be called by addresses with the required access permissions.
     * Implementations of this contract should ensure that the `_checkAccessForManageBlastERC20Rebasing`
     * function is called to enforce access control.
     *
     * @param erc20Rebasing_ The address of the ERC20 rebasing token to configure.
     * @param mode_ The yield mode to apply to the token, determining how rebasing mechanics are handled.
     * @return A uint256 value that represents the outcome of the configuration operation,
     * which could be an updated token supply or another relevant metric, depending on the ERC20 rebasing token implementation.
     */
    function configure(address erc20Rebasing_, YieldMode mode_) external returns (uint256);

    /**
     * @dev Claims rebasing tokens on behalf of the caller and transfers them to a specified recipient.
     * This function can only be executed by addresses with the necessary access permissions.
     *
     * @param erc20Rebasing_ The address of the ERC20 rebasing token from which tokens are claimed.
     * @param recipient_ The recipient address to receive the claimed tokens.
     * @param amount_ The amount of tokens to claim.
     * @return The result of the claim operation, specific to the ERC20 rebasing token implementation.
     */
    function claim(address erc20Rebasing_, address recipient_, uint256 amount_) external returns (uint256);
}

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

/**
 * @title IBlastFull Interface
 * @dev Interface for interacting with the Blast protocol, specifically for configuring
 * governance settings. This interface abstracts the function to set up a governor
 * within the Blast ecosystem.
 */

enum GasMode {
    VOID,
    CLAIMABLE
}

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

interface IBlastFull {
    // configure
    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;

    function configure(YieldMode _yield, GasMode gasMode, address governor) external;

    // base configuration options
    function configureClaimableYield() external;

    function configureClaimableYieldOnBehalf(address contractAddress) external;

    function configureAutomaticYield() external;

    function configureAutomaticYieldOnBehalf(address contractAddress) external;

    function configureVoidYield() external;

    function configureVoidYieldOnBehalf(address contractAddress) external;

    function configureClaimableGas() external;

    function configureClaimableGasOnBehalf(address contractAddress) external;

    function configureVoidGas() external;

    function configureVoidGasOnBehalf(address contractAddress) external;

    function configureGovernor(address _governor) external;

    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

    // claim yield
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);

    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    // claim gas
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);

    // NOTE: can be off by 1 bip
    function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256);

    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);

    function claimGas(
        address contractAddress,
        address recipientOfGas,
        uint256 gasToClaim,
        uint256 gasSecondsToConsume
    ) external returns (uint256);

    // read functions
    function readClaimableYield(address contractAddress) external view returns (uint256);

    function readYieldConfiguration(address contractAddress) external view returns (uint8);

    function readGasParams(
        address contractAddress
    ) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);

    function isGovernor(address) external view returns (bool);

    function governorMap(address) external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity =0.8.19;

import {GasMode} from "./IBlastFull.sol";

/**
 * @title IBlastGovernor
 * @dev Interface for the BlastGovernor contract.
 */
interface IBlastGovernor {
    /**
     * @dev Structure representing gas parameters.
     * @param contractAddress Address of the gas holder contract.
     * @param etherSeconds Accumulated ether seconds.
     * @param etherBalance Ether balance.
     * @param lastUpdated Timestamp of the last update.
     * @param gasMode Current gas mode.
     */
    struct GasParamsResult {
        address contractAddress;
        uint256 etherSeconds;
        uint256 etherBalance;
        uint256 lastUpdated;
        GasMode gasMode;
    }

    /**
     * @dev Emitted when a gas holder is added.
     * @param contractAddress The address of the added gas holder contract.
     */
    event AddGasHolder(address indexed contractAddress);

    /**
     * @dev Emitted when gas is claimed.
     * @param caller The address of the caller who initiated the claim.
     * @param recipient The address of the recipient who receives the claimed gas.
     * @param gasHolders The addresses of the gas holders from which gas was claimed.
     * @param totalClaimedAmount The total amount of gas claimed.
     */
    event ClaimGas(address indexed caller, address indexed recipient, address[] gasHolders, uint256 totalClaimedAmount);

    /**
     * @notice Adds a gas holder.
     * @dev Adds a contract to the list of gas holders.
     * @param contractAddress_ The address of the gas holder contract.
     */
    function addGasHolder(address contractAddress_) external;

    /**
     * @notice Claims all gas for a recipient within the specified range.
     * @param recipient_ The address of the recipient.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimAllGas(address recipient_, uint256 offset_, uint256 limit_) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims all gas for a recipient from specified gas holders.
     * @param recipient_ The address of the recipient.
     * @param holders_ The addresses of the gas holders.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimAllGasFromSpecifiedGasHolders(address recipient_, address[] memory holders_) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims gas at minimum claim rate for a recipient within the specified range.
     * @param recipient_ The address of the recipient.
     * @param minClaimRateBips_ The minimum claim rate in basis points.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimGasAtMinClaimRate(
        address recipient_,
        uint256 minClaimRateBips_,
        uint256 offset_,
        uint256 limit_
    ) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims gas at minimum claim rate for a recipient from specified gas holders.
     * @param recipient_ The address of the recipient.
     * @param minClaimRateBips_ The minimum claim rate in basis points.
     * @param holders_ The addresses of the gas holders.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimGasAtMinClaimRateFromSpecifiedGasHolders(
        address recipient_,
        uint256 minClaimRateBips_,
        address[] memory holders_
    ) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims maximum gas for a recipient within the specified range.
     * @param recipient_ The address of the recipient.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimMaxGas(address recipient_, uint256 offset_, uint256 limit_) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims maximum gas for a recipient from specified gas holders.
     * @param recipient_ The address of the recipient.
     * @param holders_ The addresses of the gas holders.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimMaxGasFromSpecifiedGasHolders(address recipient_, address[] memory holders_) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims a specific amount of gas for a recipient within the specified range.
     * @param recipient_ The address of the recipient.
     * @param gasToClaim_ The amount of gas to claim.
     * @param gasSecondsToConsume_ The amount of gas seconds to consume.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimGas(
        address recipient_,
        uint256 gasToClaim_,
        uint256 gasSecondsToConsume_,
        uint256 offset_,
        uint256 limit_
    ) external returns (uint256 totalClaimedGas);

    /**
     * @notice Claims a specific amount of gas for a recipient from specified gas holders.
     * @param recipient_ The address of the recipient.
     * @param gasToClaim_ The amount of gas to claim.
     * @param gasSecondsToConsume_ The amount of gas seconds to consume.
     * @param holders_ The addresses of the gas holders.
     * @return totalClaimedGas The total amount of gas claimed.
     */
    function claimGasFromSpecifiedGasHolders(
        address recipient_,
        uint256 gasToClaim_,
        uint256 gasSecondsToConsume_,
        address[] memory holders_
    ) external returns (uint256 totalClaimedGas);

    /**
     * @notice Reads gas parameters within the specified range.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return gasHoldersParams The gas parameters of the gas holders.
     */
    function readGasParams(uint256 offset_, uint256 limit_) external view returns (GasParamsResult[] memory gasHoldersParams);

    /**
     * @notice Reads gas parameters from specified gas holders.
     * @param holders_ The addresses of the gas holders.
     * @return gasHoldersParams The gas parameters of the gas holders.
     */
    function readGasParamsFromSpecifiedGasHolders(
        address[] memory holders_
    ) external view returns (GasParamsResult[] memory gasHoldersParams);

    /**
     * @notice Checks if a contract is a registered gas holder.
     * @param contractAddress_ The address of the contract.
     * @return isRegistered Whether the contract is a registered gas holder.
     */
    function isRegisteredGasHolder(address contractAddress_) external view returns (bool isRegistered);

    /**
     * @notice Lists gas holders within the specified range.
     * @param offset_ The offset to start from.
     * @param limit_ The maximum number of gas holders to process.
     * @return gasHolders The addresses of the gas holders.
     */
    function listGasHolders(uint256 offset_, uint256 limit_) external view returns (address[] memory gasHolders);
}

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

interface IBlastPoints {
    function configurePointsOperator(address operator) external;

    function configurePointsOperatorOnBehalf(address contractAddress, address operator) external;
}

// SPDX-License-Identifier: MIT
pragma solidity =0.8.19;

enum YieldMode {
    AUTOMATIC,
    VOID,
    CLAIMABLE
}

interface IERC20Rebasing {
    // changes the yield mode of the caller and update the balance
    // to reflect the configuration
    function configure(YieldMode) external returns (uint256);

    // "claimable" yield mode accounts can call this this claim their yield
    // to another address
    function claim(address recipient, uint256 amount) external returns (uint256);

    // read the claimable amount for an account
    function getClaimableAmount(address account) external view returns (uint256);

    /// @notice Query an account's configured yield mode.
    /// @param account Address to query the configuration.
    /// @return Configured yield mode.
    function getConfiguration(address account) external view returns (YieldMode);
}

{
  "evmVersion": "paris",
  "viaIR": true,
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "metadata": {
    "bytecodeHash": "none"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_blastGovernor","type":"address"},{"internalType":"address","name":"_blastPoints","type":"address"},{"internalType":"address","name":"_blastPointsOperator","type":"address"},{"internalType":"address","name":"_factory","type":"address"},{"internalType":"address","name":"_token0","type":"address"},{"internalType":"address","name":"_token1","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AddressZero","type":"error"},{"inputs":[{"internalType":"address","name":"erc20Rebasing_","type":"address"},{"internalType":"address","name":"recipient_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"claimFeesFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc20Rebasing_","type":"address"},{"internalType":"enum YieldMode","name":"mode_","type":"uint8"}],"name":"configure","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

0x604060808152600436101561001357600080fd5b600090813560e01c80633bdbe9a514610226578063533cf5ce146101515763996cba681461004057600080fd5b3461014d57606060031936011261014d576100596102b9565b73ffffffffffffffffffffffffffffffffffffffff91906024358381168103610149576020916100e79161008b61046d565b8685519687809581947faad3ec9600000000000000000000000000000000000000000000000000000000835260443590600484016020909392919373ffffffffffffffffffffffffffffffffffffffff60408201951681520152565b0393165af191821561013f578392610104575b6020838351908152f35b9091506020813d8211610137575b8161011f602093836102e1565b8101031261013357602092505190386100fa565b8280fd5b3d9150610112565b81513d85823e3d90fd5b8480fd5b5080fd5b82346102235760606003193601126102235761016b6102b9565b6044356024357f000000000000000000000000031e673c2cbbc1ede15b6595f55e917d1668065873ffffffffffffffffffffffffffffffffffffffff16330361021f57806101ee575b50806101be578280f35b6101e8917f0000000000000000000000005c09a9ce08c4b332ef1cc5f7cadb1158c32767ce61034b565b81808280f35b61021990837f000000000000000000000000430000000000000000000000000000000000000461034b565b836101b4565b8380fd5b80fd5b503461014d578060031936011261014d5761023f6102b9565b90602435600381101561021f5773ffffffffffffffffffffffffffffffffffffffff92602460209261026f61046d565b86855196879485937f1a33757d0000000000000000000000000000000000000000000000000000000085526004850152165af191821561013f578392610104576020838351908152f35b6004359073ffffffffffffffffffffffffffffffffffffffff821682036102dc57565b600080fd5b90601f601f19910116810190811067ffffffffffffffff82111761030457604052565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b908160209103126102dc575180151581036102dc5790565b9190823b156102dc576040517fa9059cbb000000000000000000000000000000000000000000000000000000006020820190815273ffffffffffffffffffffffffffffffffffffffff929092166024820152604480820193909352918252601f19916103b86064826102e1565b600093849283809351925af1903d15610465573d67ffffffffffffffff8111610438576103f0602060405193601f84011601836102e1565b81523d83602083013e5b81610409575b50156102235750565b805180159250821561041e575b505038610400565b6104319250602080918301019101610333565b3880610416565b6024847f4e487b710000000000000000000000000000000000000000000000000000000081526041600452fd5b5060606103fa565b73ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000a19c51d91891d3df7c13ed22a2f89d328a82950f16803314908115610515575b50156104b757565b60646040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152600d60248201527f4143434553535f44454e494544000000000000000000000000000000000000006044820152fd5b6040517f84d397cc000000000000000000000000000000000000000000000000000000008152602092508281600481855afa80156105d55783916000916105e1575b506044604051809481937f91d1485400000000000000000000000000000000000000000000000000000000835260048301523360248301525afa9182156105d5576000926105a8575b5050386104af565b6105c79250803d106105ce575b6105bf81836102e1565b810190610333565b38806105a0565b503d6105b5565b6040513d6000823e3d90fd5b9182813d8311610608575b6105f681836102e1565b81010312610223575082905138610557565b503d6105ec56fea164736f6c6343000813000a