Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {Clones} from "@openzeppelin/contracts/proxy/Clones.sol";
import {BimaOwnable} from "../dependencies/BimaOwnable.sol";
import {BIMA_COLLATERAL_DECIMALS} from "../dependencies/Constants.sol";
import {ITroveManager} from "../interfaces/ITroveManager.sol";
import {ISortedTroves} from "../interfaces/ISortedTroves.sol";
import {IFactory, IDebtToken, ILiquidationManager, IBorrowerOperations, IStabilityPool} from "../interfaces/IFactory.sol";

/**
    @title Bima Trove Factory
    @notice Deploys cloned pairs of `TroveManager` and `SortedTroves` in order to
            add new collateral types within the system.
 */
contract Factory is IFactory, BimaOwnable {
    using Clones for address;

    // fixed single-deployment contracts
    IDebtToken public immutable debtToken;
    IStabilityPool public immutable stabilityPool;
    ILiquidationManager public immutable liquidationManager;
    IBorrowerOperations public immutable borrowerOperations;

    // implementation contracts, redeployed each time via clone proxy
    address public sortedTrovesImpl;
    address public troveManagerImpl;

    address[] public troveManagers;

    constructor(
        address _bimaCore,
        IDebtToken _debtToken,
        IStabilityPool _stabilityPool,
        IBorrowerOperations _borrowerOperations,
        address _sortedTroves,
        address _troveManager,
        ILiquidationManager _liquidationManager
    ) BimaOwnable(_bimaCore) {
        debtToken = _debtToken;
        stabilityPool = _stabilityPool;
        borrowerOperations = _borrowerOperations;

        sortedTrovesImpl = _sortedTroves;
        troveManagerImpl = _troveManager;
        liquidationManager = _liquidationManager;
    }

    function troveManagerCount() external view returns (uint256 count) {
        count = troveManagers.length;
    }

    /**
        @notice Deploy new instances of `TroveManager` and `SortedTroves`, adding
                a new collateral type to the system.
        @dev * When using the default `PriceFeed`, ensure it is configured correctly
               prior to calling this function.
             * After calling this function, the owner should also call `Vault.registerReceiver`
               to enable BIMA emissions on the newly deployed `TroveManager`
        @param collateral Collateral token to use in new deployment
        @param priceFeed Custom `PriceFeed` deployment. Leave as `address(0)` to use the default.
        @param customTroveManagerImpl Custom `TroveManager` implementation to clone from.
                                      Leave as `address(0)` to use the default.
        @param customSortedTrovesImpl Custom `SortedTroves` implementation to clone from.
                                      Leave as `address(0)` to use the default.
        @param params Struct of initial parameters to be set on the new trove manager
     */
    function deployNewInstance(
        address collateral,
        address priceFeed,
        address customTroveManagerImpl,
        address customSortedTrovesImpl,
        DeploymentParams memory params
    ) external onlyOwner {
        IERC20Metadata collateralToken = IERC20Metadata(collateral);
        require(collateralToken.decimals() == BIMA_COLLATERAL_DECIMALS, "Invalid collateral decimals");

        address implementation = customTroveManagerImpl == address(0) ? troveManagerImpl : customTroveManagerImpl;
        address troveManager = implementation.cloneDeterministic(bytes32(bytes20(collateral)));
        troveManagers.push(troveManager);

        implementation = customSortedTrovesImpl == address(0) ? sortedTrovesImpl : customSortedTrovesImpl;
        address sortedTroves = implementation.cloneDeterministic(bytes32(bytes20(troveManager)));

        ITroveManager(troveManager).setAddresses(priceFeed, sortedTroves, collateral);
        ISortedTroves(sortedTroves).setAddresses(troveManager);

        // verify that the oracle is correctly working
        ITroveManager(troveManager).fetchPrice();

        stabilityPool.enableCollateral(collateralToken);
        liquidationManager.enableTroveManager(ITroveManager(troveManager));
        debtToken.enableTroveManager(troveManager);
        borrowerOperations.configureCollateral(ITroveManager(troveManager), collateralToken);

        ITroveManager(troveManager).setParameters(
            params.minuteDecayFactor,
            params.redemptionFeeFloor,
            params.maxRedemptionFee,
            params.borrowingFeeFloor,
            params.maxBorrowingFee,
            params.interestRateInBps,
            params.maxDebt,
            params.MCR
        );

        emit NewDeployment(collateral, priceFeed, troveManager, sortedTroves);
    }

    function setImplementations(address _troveManagerImpl, address _sortedTrovesImpl) external onlyOwner {
        troveManagerImpl = _troveManagerImpl;
        sortedTrovesImpl = _sortedTrovesImpl;

        emit ImplementationContractsChanged(_troveManagerImpl, _sortedTrovesImpl);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { IMessageLibManager } from "./IMessageLibManager.sol";
import { IMessagingComposer } from "./IMessagingComposer.sol";
import { IMessagingChannel } from "./IMessagingChannel.sol";
import { IMessagingContext } from "./IMessagingContext.sol";

struct MessagingParams {
    uint32 dstEid;
    bytes32 receiver;
    bytes message;
    bytes options;
    bool payInLzToken;
}

struct MessagingReceipt {
    bytes32 guid;
    uint64 nonce;
    MessagingFee fee;
}

struct MessagingFee {
    uint256 nativeFee;
    uint256 lzTokenFee;
}

struct Origin {
    uint32 srcEid;
    bytes32 sender;
    uint64 nonce;
}

interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);

    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);

    event PacketDelivered(Origin origin, address receiver);

    event LzReceiveAlert(
        address indexed receiver,
        address indexed executor,
        Origin origin,
        bytes32 guid,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    event LzTokenSet(address token);

    event DelegateSet(address sender, address delegate);

    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);

    function send(
        MessagingParams calldata _params,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory);

    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;

    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);

    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);

    function lzReceive(
        Origin calldata _origin,
        address _receiver,
        bytes32 _guid,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;

    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;

    function setLzToken(address _lzToken) external;

    function lzToken() external view returns (address);

    function nativeToken() external view returns (address);

    function setDelegate(address _delegate) external;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

struct SetConfigParam {
    uint32 eid;
    uint32 configType;
    bytes config;
}

interface IMessageLibManager {
    struct Timeout {
        address lib;
        uint256 expiry;
    }

    event LibraryRegistered(address newLib);
    event DefaultSendLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
    event SendLibrarySet(address sender, uint32 eid, address newLib);
    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);
    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);

    function registerLibrary(address _lib) external;

    function isRegisteredLibrary(address _lib) external view returns (bool);

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

    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;

    function defaultSendLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function defaultReceiveLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;

    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);

    function isSupportedEid(uint32 _eid) external view returns (bool);

    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);

    /// ------------------- OApp interfaces -------------------
    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;

    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);

    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);

    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);

    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _expiry) external;

    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);

    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;

    function getConfig(
        address _oapp,
        address _lib,
        uint32 _eid,
        uint32 _configType
    ) external view returns (bytes memory config);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingChannel {
    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

    function eid() external view returns (uint32);

    // this is an emergency function if a message cannot be verified for some reasons
    // required to provide _nextNonce to avoid race condition
    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;

    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);

    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);

    function inboundPayloadHash(
        address _receiver,
        uint32 _srcEid,
        bytes32 _sender,
        uint64 _nonce
    ) external view returns (bytes32);

    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingComposer {
    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
    event LzComposeAlert(
        address indexed from,
        address indexed to,
        address indexed executor,
        bytes32 guid,
        uint16 index,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    function composeQueue(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index
    ) external view returns (bytes32 messageHash);

    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;

    function lzCompose(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingContext {
    function isSendingMessage() external view returns (bool);

    function getSendContext() external view returns (uint32 dstEid, address sender);
}

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

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
 * deploying minimal proxy contracts, also known as "clones".
 *
 * > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
 * > a minimal bytecode implementation that delegates all calls to a known, fixed address.
 *
 * The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
 * (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
 * deterministic method.
 *
 * _Available since v3.4._
 */
library Clones {
    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     */
    function clone(address implementation) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create(0, 0x09, 0x37)
        }
        require(instance != address(0), "ERC1167: create failed");
    }

    /**
     * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     */
    function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
        /// @solidity memory-safe-assembly
        assembly {
            // Cleans the upper 96 bits of the `implementation` word, then packs the first 3 bytes
            // of the `implementation` address with the bytecode before the address.
            mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
            instance := create2(0, 0x09, 0x37, salt)
        }
        require(instance != address(0), "ERC1167: create2 failed");
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(add(ptr, 0x38), deployer)
            mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
            mstore(add(ptr, 0x14), implementation)
            mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
            mstore(add(ptr, 0x58), salt)
            mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
            predicted := keccak256(add(ptr, 0x43), 0x55)
        }
    }

    /**
     * @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes32 salt
    ) internal view returns (address predicted) {
        return predictDeterministicAddress(implementation, salt, address(this));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// 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.20;

import {IBimaCore} from "../interfaces/IBimaCore.sol";
import {IBimaOwnable} from "../interfaces/IEmissionSchedule.sol";

/**
    @title Bima Ownable
    @notice Contracts inheriting `BimaOwnable` have the same owner as `BimaCore`.
            The ownership cannot be independently modified or renounced.
 */
contract BimaOwnable is IBimaOwnable {
    IBimaCore public immutable BIMA_CORE;

    constructor(address _bimaCore) {
        BIMA_CORE = IBimaCore(_bimaCore);
    }

    modifier onlyOwner() {
        require(msg.sender == BIMA_CORE.owner(), "Only owner");
        _;
    }

    function owner() public view returns (address result) {
        result = BIMA_CORE.owner();
    }

    function guardian() public view returns (address result) {
        result = BIMA_CORE.guardian();
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

// represents 100% in BIMA used in denominator when
// calculating amounts based on a percentage
uint256 constant BIMA_100_PCT = 10_000;

// BIMA's default decimal precision
uint256 constant BIMA_DECIMAL_PRECISION = 1e18;

// BIMA's default scale factor
uint256 constant BIMA_SCALE_FACTOR = 1e9;

// BIMA's default reward duration
uint256 constant BIMA_REWARD_DURATION = 1 weeks;

// collateral tokens required decimals
uint8 constant BIMA_COLLATERAL_DECIMALS = 18;

// SPDX-License-Identifier: MIT
// Code from https://github.com/smartcontractkit/chainlink/blob/master/evm-contracts/src/v0.6/interfaces/AggregatorV3Interface.sol
pragma solidity 0.8.20;

interface IAggregatorV3Interface {
    function decimals() external view returns (uint8);

    function description() external view returns (string memory);

    function version() external view returns (uint256);

    // getRoundData and latestRoundData should both raise "No data present"
    // if they do not have data to report, instead of returning unset values
    // which could be misinterpreted as actual reported values.
    function getRoundData(
        uint80 _roundId
    )
        external
        view
        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

    function latestRoundData()
        external
        view
        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IBimaBase {
    function CCR() external returns (uint256);

    function DEBT_GAS_COMPENSATION() external returns (uint256);

    function PERCENT_DIVISOR() external returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IBimaCore {
    event FeeReceiverSet(address feeReceiver);
    event GuardianSet(address guardian);
    event NewOwnerAccepted(address oldOwner, address owner);
    event NewOwnerCommitted(address owner, address pendingOwner, uint256 deadline);
    event NewOwnerRevoked(address owner, address revokedOwner);
    event Paused();
    event PriceFeedSet(address priceFeed);
    event Unpaused();

    function acceptTransferOwnership() external;

    function commitTransferOwnership(address newOwner) external;

    function revokeTransferOwnership() external;

    function setFeeReceiver(address _feeReceiver) external;

    function setGuardian(address _guardian) external;

    function setPaused(bool _paused) external;

    function setPriceFeed(address _priceFeed) external;

    function OWNERSHIP_TRANSFER_DELAY() external view returns (uint256);

    function feeReceiver() external view returns (address);

    function guardian() external view returns (address);

    function owner() external view returns (address);

    function ownershipTransferDeadline() external view returns (uint256);

    function paused() external view returns (bool);

    function pendingOwner() external view returns (address);

    function priceFeed() external view returns (address);

    function startTime() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaCore} from "./IBimaCore.sol";

interface IBimaOwnable {
    function BIMA_CORE() external view returns (IBimaCore);

    function owner() external view returns (address);

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
import {ILayerZeroEndpointV2} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";

interface IBimaToken {
    struct SendParam {
        uint32 dstEid; // Destination endpoint ID.
        bytes32 to; // Recipient address.
        uint256 amountLD; // Amount to send in local decimals.
        uint256 minAmountLD; // Minimum amount to send in local decimals.
        bytes extraOptions; // Additional options supplied by the caller to be used in the LayerZero message.
        bytes composeMsg; // The composed message for the send() operation.
        bytes oftCmd; // The OFT command to be executed, unused in default OFT implementations.
    }

    struct OFTLimit {
        uint256 minAmountLD; // Minimum amount in local decimals that can be sent to the recipient.
        uint256 maxAmountLD; // Maximum amount in local decimals that can be sent to the recipient.
    }

    struct OFTReceipt {
        uint256 amountSentLD; // Amount of tokens ACTUALLY debited from the sender in local decimals.
        // @dev In non-default implementations, the amountReceivedLD COULD differ from this value.
        uint256 amountReceivedLD; // Amount of tokens to be received on the remote side.
    }

    struct OFTFeeDetail {
        int256 feeAmountLD; // Amount of the fee in local decimals.
        string description; // Description of the fee.
    }

    struct MessagingParams {
        uint32 dstEid;
        bytes32 receiver;
        bytes message;
        bytes options;
        bool payInLzToken;
    }

    struct MessagingReceipt {
        bytes32 guid;
        uint64 nonce;
        MessagingFee fee;
    }

    struct MessagingFee {
        uint256 nativeFee;
        uint256 lzTokenFee;
    }

    struct Origin {
        uint32 srcEid;
        bytes32 sender;
        uint64 nonce;
    }

    struct InboundPacket {
        Origin origin; // Origin information of the packet.
        uint32 dstEid; // Destination endpointId of the packet.
        address receiver; // Receiver address for the packet.
        bytes32 guid; // Unique identifier of the packet.
        uint256 value; // msg.value of the packet.
        address executor; // Executor address for the packet.
        bytes message; // Message payload of the packet.
        bytes extraData; // Additional arbitrary data for the packet.
    }

    struct EnforcedOptionParam {
        uint32 eid; // Endpoint ID
        uint16 msgType; // Message Type
        bytes options; // Additional options
    }

    event Approval(address indexed owner, address indexed spender, uint256 value);
    event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event ReceiveFromChain(uint16 indexed _srcChainId, address indexed _to, uint256 _amount);
    event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
    event SendToChain(uint16 indexed _dstChainId, address indexed _from, bytes _toAddress, uint256 _amount);
    event SetMinDstGas(uint16 _dstChainId, uint16 _type, uint256 _minDstGas);
    event SetPrecrime(address precrime);
    event SetTrustedRemote(uint16 _remoteChainId, bytes _path);
    event SetTrustedRemoteAddress(uint16 _remoteChainId, bytes _remoteAddress);
    event SetUseCustomAdapterParams(bool _useCustomAdapterParams);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event PreCrimeSet(address preCrimeAddress);
    event PeerSet(uint32 eid, bytes32 peer);

    event OFTSent(
        bytes32 indexed guid,
        uint32 dstEid,
        address indexed fromAddress,
        uint256 amountSentLD,
        uint256 amountReceivedLD
    );
    event OFTReceived(bytes32 indexed guid, uint32 srcEid, address indexed toAddress, uint256 amountReceivedLD);

    function approve(address spender, uint256 amount) external returns (bool);

    function authorizedMint(address _to, uint256 _amount) external;

    function burn(address _account, uint256 _amount) external;

    function burnWithGasCompensation(address _account, uint256 _amount) external returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);

    function enableTroveManager(address _troveManager) external;

    function flashLoan(address receiver, uint256 amount, bytes calldata data) external returns (bool);

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);

    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;

    function lzReceiveAndRevert(InboundPacket[] calldata _packets) external payable;

    function _lzReceiveSimulate(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external;

    function mint(address _account, uint256 _amount) external;

    function mintWithGasCompensation(address _account, uint256 _amount) external returns (bool);

    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function renounceOwnership() external;

    function returnFromPool(address _poolAddress, address _receiver, uint256 _amount) external;

    function send(
        SendParam calldata _sendParam,
        MessagingFee calldata _fee,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory, OFTReceipt memory);

    function sendToSP(address _sender, uint256 _amount) external;

    function setDelegate(address _delegate) external;

    function setEnforcedOptions(EnforcedOptionParam[] calldata _enforcedOptions) external;

    function setLendingVaultAdapterAddress(address _lendingVaultAdapterAddress) external;

    function setMsgInspector(address _msgInspector) external;

    function setPeer(uint32 _eid, bytes32 _peer) external;

    function setPrecrime(address _precrime) external;

    function transfer(address recipient, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    function transferOwnership(address newOwner) external;

    function allowance(address owner, address spender) external view returns (uint256);

    function allowInitializePath(Origin calldata _origin) external view returns (bool);

    function approvalRequired() external view returns (bool);

    function balanceOf(address account) external view returns (uint256);

    function borrowerOperationsAddress() external view returns (address);

    function combineOptions(
        uint32 _eid,
        uint16 _msgType,
        bytes calldata _extraOptions
    ) external view returns (bytes memory options);

    function DEBT_GAS_COMPENSATION() external view returns (uint256);

    function decimals() external view returns (uint8);

    function domainSeparator() external view returns (bytes32);

    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);

    function transferToLocker(address sender, uint256 amount) external returns (bool success);

    function mintToVault(uint256 _totalSupply) external returns (bool success);

    // enforcedOptions

    function factory() external view returns (address);

    function FLASH_LOAN_FEE() external view returns (uint256);

    function flashFee(address token, uint256 amount) external view returns (uint256);

    function gasPool() external view returns (address);

    function isComposeMsgSender(
        Origin calldata _origin,
        bytes calldata _message,
        address _sender
    ) external view returns (bool isSender);

    function isPeer(uint32 _eid, bytes32 _peer) external view returns (bool);

    function maxFlashLoan(address token) external view returns (uint256);

    function name() external view returns (string memory);

    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);

    function nonces(address owner) external view returns (uint256);

    function oApp() external view returns (address);

    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);

    function oftVersion() external view returns (bytes4 interfaceId, uint64 version);

    function owner() external view returns (address);

    function peers(uint32 _eid) external view returns (bytes32 peer);

    function permitTypeHash() external view returns (bytes32);

    function preCrime() external view returns (address);

    function quoteOFT(
        SendParam calldata _sendParam
    ) external view returns (OFTLimit memory, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory);

    function quoteSend(SendParam calldata _sendParam, bool _payInLzToken) external view returns (MessagingFee memory);

    function sharedDecimals() external view returns (uint8);

    function stabilityPoolAddress() external view returns (address);

    function symbol() external view returns (string memory);

    function token() external view returns (address);

    function totalSupply() external view returns (uint256);

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

    function version() external view returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {ISystemStart} from "./ISystemStart.sol";
import {ITokenLocker} from "../interfaces/ITokenLocker.sol";

interface IBoostCalculator is ISystemStart {
    function getBoostedAmountWrite(
        address account,
        uint256 amount,
        uint256 previousAmount,
        uint256 totalWeeklyEmissions
    ) external returns (uint256 adjustedAmount);

    function MAX_BOOST_GRACE_WEEKS() external view returns (uint256);

    function getBoostedAmount(
        address account,
        uint256 amount,
        uint256 previousAmount,
        uint256 totalWeeklyEmissions
    ) external view returns (uint256 adjustedAmount);

    function getClaimableWithBoost(
        address claimant,
        uint256 previousAmount,
        uint256 totalWeeklyEmissions
    ) external view returns (uint256 maxBoosted, uint256 boosted);

    function locker() external view returns (ITokenLocker);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

/**
    @title Bima Boost Delegate Interface
    @notice When enabling boost delegation via `Vault.setBoostDelegationParams`,
            you may optionally set a `callback` contract. If set, it should adhere
            to the following interface.
 */
interface IBoostDelegate {
    /**
        @notice Get the current fee percent charged to use this boost delegate
        @dev Optional. Only called if the feePct is set to `type(uint16).max` when
             enabling delegation.
        @param claimant Address that will perform the claim
        @param amount Amount to be claimed (before applying boost or fee)
        @param previousAmount Previous amount claimed this week by this contract
        @param totalWeeklyEmissions Total weekly emissions released this week
        @return feePct Fee % charged for claims that use this contracts' delegated boost.
                      Given as a whole number out of 10000. If a claim would be rejected,
                      the preferred return value is `type(uint256).max`.
     */
    function getFeePct(
        address claimant,
        address receiver,
        uint256 amount,
        uint256 previousAmount,
        uint256 totalWeeklyEmissions
    ) external view returns (uint256 feePct);

    /**
        @notice Callback function for boost delegators
        @dev MUST BE INCLUDED. Called after each successful claim which used
             this contract's delegated boost.
        @param claimant Address that performed the claim
        @param amount Amount that claimed (before applying boost or fee)
        @param adjustedAmount Actual amount received by `claimant`
        @param fee Fee amount paid by `claimant`
        @param previousAmount Previous amount claimed this week by this contract
        @param totalWeeklyEmissions Total weekly emissions released this week
     */
    function delegatedBoostCallback(
        address claimant,
        address receiver,
        uint256 amount,
        uint256 adjustedAmount,
        uint256 fee,
        uint256 previousAmount,
        uint256 totalWeeklyEmissions
    ) external returns (bool success);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ITroveManager} from "./ITroveManager.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {IBimaBase} from "./IBimaBase.sol";
import {IDelegatedOps} from "./IDelegatedOps.sol";

interface IBorrowerOperations is IBimaOwnable, IBimaBase, IDelegatedOps {
    enum BorrowerOperation {
        openTrove,
        closeTrove,
        adjustTrove
    }

    struct SystemBalances {
        uint256[] collaterals;
        uint256[] debts;
        uint256[] prices;
    }

    event BorrowingFeePaid(address indexed borrower, IERC20 collateralToken, uint256 amount);
    event CollateralConfigured(ITroveManager, IERC20 collateralToken);
    event TroveCreated(address indexed _borrower, uint256 arrayIndex);
    event TroveManagerRemoved(ITroveManager);
    event TroveUpdated(
        address indexed _borrower,
        uint256 _debt,
        uint256 _coll,
        uint256 stake,
        BorrowerOperation operation
    );
    event SetMinNetDebt(uint256 newMinNetDebt);

    function addColl(
        ITroveManager troveManager,
        address account,
        uint256 _collateralAmount,
        address _upperHint,
        address _lowerHint
    ) external;

    function adjustTrove(
        ITroveManager troveManager,
        address account,
        uint256 _maxFeePercentage,
        uint256 _collDeposit,
        uint256 _collWithdrawal,
        uint256 _debtChange,
        bool _isDebtIncrease,
        address _upperHint,
        address _lowerHint
    ) external;

    function closeTrove(ITroveManager troveManager, address account) external;

    function configureCollateral(ITroveManager troveManager, IERC20 collateralToken) external;

    function fetchBalances() external returns (SystemBalances memory balances);

    function getGlobalSystemBalances() external returns (uint256 totalPricedCollateral, uint256 totalDebt);

    function getTCR() external returns (uint256 globalTotalCollateralRatio);

    function openTrove(
        ITroveManager troveManager,
        address account,
        uint256 _maxFeePercentage,
        uint256 _collateralAmount,
        uint256 _debtAmount,
        address _upperHint,
        address _lowerHint
    ) external;

    function removeTroveManager(ITroveManager troveManager) external;

    function repayDebt(
        ITroveManager troveManager,
        address account,
        uint256 _debtAmount,
        address _upperHint,
        address _lowerHint
    ) external;

    function setMinNetDebt(uint256 _minNetDebt) external;

    function withdrawColl(
        ITroveManager troveManager,
        address account,
        uint256 _collWithdrawal,
        address _upperHint,
        address _lowerHint
    ) external;

    function withdrawDebt(
        ITroveManager troveManager,
        address account,
        uint256 _maxFeePercentage,
        uint256 _debtAmount,
        address _upperHint,
        address _lowerHint
    ) external;

    function checkRecoveryMode(uint256 TCR) external pure returns (bool);

    function debtToken() external view returns (IDebtToken);

    function factory() external view returns (address);

    function getCompositeDebt(uint256 _debt) external view returns (uint256);

    function minNetDebt() external view returns (uint256);

    function troveManagersData(ITroveManager) external view returns (IERC20 collateralToken, uint16 index);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
import {ILayerZeroEndpointV2} from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";

interface IDebtToken {
    struct SendParam {
        uint32 dstEid; // Destination endpoint ID.
        bytes32 to; // Recipient address.
        uint256 amountLD; // Amount to send in local decimals.
        uint256 minAmountLD; // Minimum amount to send in local decimals.
        bytes extraOptions; // Additional options supplied by the caller to be used in the LayerZero message.
        bytes composeMsg; // The composed message for the send() operation.
        bytes oftCmd; // The OFT command to be executed, unused in default OFT implementations.
    }

    struct OFTLimit {
        uint256 minAmountLD; // Minimum amount in local decimals that can be sent to the recipient.
        uint256 maxAmountLD; // Maximum amount in local decimals that can be sent to the recipient.
    }

    struct OFTReceipt {
        uint256 amountSentLD; // Amount of tokens ACTUALLY debited from the sender in local decimals.
        // @dev In non-default implementations, the amountReceivedLD COULD differ from this value.
        uint256 amountReceivedLD; // Amount of tokens to be received on the remote side.
    }

    struct OFTFeeDetail {
        int256 feeAmountLD; // Amount of the fee in local decimals.
        string description; // Description of the fee.
    }

    struct MessagingParams {
        uint32 dstEid;
        bytes32 receiver;
        bytes message;
        bytes options;
        bool payInLzToken;
    }

    struct MessagingReceipt {
        bytes32 guid;
        uint64 nonce;
        MessagingFee fee;
    }

    struct MessagingFee {
        uint256 nativeFee;
        uint256 lzTokenFee;
    }

    struct Origin {
        uint32 srcEid;
        bytes32 sender;
        uint64 nonce;
    }

    struct InboundPacket {
        Origin origin; // Origin information of the packet.
        uint32 dstEid; // Destination endpointId of the packet.
        address receiver; // Receiver address for the packet.
        bytes32 guid; // Unique identifier of the packet.
        uint256 value; // msg.value of the packet.
        address executor; // Executor address for the packet.
        bytes message; // Message payload of the packet.
        bytes extraData; // Additional arbitrary data for the packet.
    }

    struct EnforcedOptionParam {
        uint32 eid; // Endpoint ID
        uint16 msgType; // Message Type
        bytes options; // Additional options
    }

    event Approval(address indexed owner, address indexed spender, uint256 value);
    event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload, bytes _reason);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event ReceiveFromChain(uint16 indexed _srcChainId, address indexed _to, uint256 _amount);
    event RetryMessageSuccess(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes32 _payloadHash);
    event SendToChain(uint16 indexed _dstChainId, address indexed _from, bytes _toAddress, uint256 _amount);
    event SetMinDstGas(uint16 _dstChainId, uint16 _type, uint256 _minDstGas);
    event SetPrecrime(address precrime);
    event SetTrustedRemote(uint16 _remoteChainId, bytes _path);
    event SetTrustedRemoteAddress(uint16 _remoteChainId, bytes _remoteAddress);
    event SetUseCustomAdapterParams(bool _useCustomAdapterParams);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event PreCrimeSet(address preCrimeAddress);
    event PeerSet(uint32 eid, bytes32 peer);

    event OFTSent(
        bytes32 indexed guid,
        uint32 dstEid,
        address indexed fromAddress,
        uint256 amountSentLD,
        uint256 amountReceivedLD
    );
    event OFTReceived(bytes32 indexed guid, uint32 srcEid, address indexed toAddress, uint256 amountReceivedLD);

    function approve(address spender, uint256 amount) external returns (bool);

    function authorizedMint(address _to, uint256 _amount) external;

    function burn(address _account, uint256 _amount) external;

    function burnWithGasCompensation(address _account, uint256 _amount) external returns (bool);

    function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);

    function enableTroveManager(address _troveManager) external;

    function flashLoan(address receiver, uint256 amount, bytes calldata data) external returns (bool);

    function increaseAllowance(address spender, uint256 addedValue) external returns (bool);

    function lzReceive(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;

    function lzReceiveAndRevert(InboundPacket[] calldata _packets) external payable;

    function _lzReceiveSimulate(
        Origin calldata _origin,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external;

    function mint(address _account, uint256 _amount) external;

    function mintWithGasCompensation(address _account, uint256 _amount) external returns (bool);

    function permit(
        address owner,
        address spender,
        uint256 amount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function renounceOwnership() external;

    function returnFromPool(address _poolAddress, address _receiver, uint256 _amount) external;

    function send(
        SendParam calldata _sendParam,
        MessagingFee calldata _fee,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory, OFTReceipt memory);

    function sendToSP(address _sender, uint256 _amount) external;

    function setDelegate(address _delegate) external;

    function setEnforcedOptions(EnforcedOptionParam[] calldata _enforcedOptions) external;

    function setLendingVaultAdapterAddress(address _lendingVaultAdapterAddress) external;

    function setMsgInspector(address _msgInspector) external;

    function setPeer(uint32 _eid, bytes32 _peer) external;

    function setPrecrime(address _precrime) external;

    function transfer(address recipient, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    function transferOwnership(address newOwner) external;

    function allowance(address owner, address spender) external view returns (uint256);

    function allowInitializePath(Origin calldata _origin) external view returns (bool);

    function approvalRequired() external view returns (bool);

    function balanceOf(address account) external view returns (uint256);

    function borrowerOperationsAddress() external view returns (address);

    function combineOptions(
        uint32 _eid,
        uint16 _msgType,
        bytes calldata _extraOptions
    ) external view returns (bytes memory options);

    function DEBT_GAS_COMPENSATION() external view returns (uint256);

    function decimals() external view returns (uint8);

    function domainSeparator() external view returns (bytes32);

    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);

    // enforcedOptions

    function factory() external view returns (address);

    function FLASH_LOAN_FEE() external view returns (uint256);

    function flashFee(address token, uint256 amount) external view returns (uint256);

    function gasPool() external view returns (address);

    function isComposeMsgSender(
        Origin calldata _origin,
        bytes calldata _message,
        address _sender
    ) external view returns (bool isSender);

    function isPeer(uint32 _eid, bytes32 _peer) external view returns (bool);

    function maxFlashLoan(address token) external view returns (uint256);

    function name() external view returns (string memory);

    function nextNonce(uint32 _eid, bytes32 _sender) external view returns (uint64);

    function nonces(address owner) external view returns (uint256);

    function oApp() external view returns (address);

    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);

    function oftVersion() external view returns (bytes4 interfaceId, uint64 version);

    function owner() external view returns (address);

    function peers(uint32 _eid) external view returns (bytes32 peer);

    function permitTypeHash() external view returns (bytes32);

    function preCrime() external view returns (address);

    function quoteOFT(
        SendParam calldata _sendParam
    ) external view returns (OFTLimit memory, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory);

    function quoteSend(SendParam calldata _sendParam, bool _payInLzToken) external view returns (MessagingFee memory);

    function sharedDecimals() external view returns (uint8);

    function stabilityPoolAddress() external view returns (address);

    function symbol() external view returns (string memory);

    function token() external view returns (address);

    function totalSupply() external view returns (uint256);

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

    function version() external view returns (string memory);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IDelegatedOps {
    function isApprovedDelegate(address owner, address caller) external view returns (bool isApproved);

    function setDelegateApproval(address _delegate, bool _isApproved) external;
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface IEmissionReceiver {
    function notifyRegisteredId(uint256[] calldata assignedIds) external returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaCore} from "./IBimaCore.sol";
import {IIncentiveVoting} from "./IIncentiveVoting.sol";
import {IBimaVault} from "./IVault.sol";
import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ISystemStart} from "./ISystemStart.sol";

interface IEmissionSchedule is IBimaOwnable, ISystemStart {
    event LockParametersSet(uint256 lockWeeks, uint256 lockDecayWeeks);
    event WeeklyPctScheduleSet(uint64[2][] schedule);

    function getReceiverWeeklyEmissions(
        uint256 id,
        uint256 week,
        uint256 totalWeeklyEmissions
    ) external returns (uint256);

    function getTotalWeeklyEmissions(
        uint256 week,
        uint256 unallocatedTotal
    ) external returns (uint256 amount, uint64 lock);

    function setLockParameters(uint64 _lockWeeks, uint64 _lockDecayWeeks) external returns (bool);

    function setWeeklyPctSchedule(uint64[2][] calldata _schedule) external returns (bool);

    function MAX_LOCK_WEEKS() external view returns (uint256);

    function getWeeklyPctSchedule() external view returns (uint64[2][] memory);

    function lockDecayWeeks() external view returns (uint64);

    function lockWeeks() external view returns (uint64);

    function vault() external view returns (IBimaVault);

    function voter() external view returns (IIncentiveVoting);

    function weeklyPct() external view returns (uint64);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaOwnable} from "./IBimaOwnable.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {ILiquidationManager} from "./ILiquidationManager.sol";
import {IBorrowerOperations} from "./IBorrowerOperations.sol";
import {IStabilityPool} from "./IStabilityPool.sol";

interface IFactory is IBimaOwnable {
    // commented values are suggested default parameters
    struct DeploymentParams {
        uint256 minuteDecayFactor; // 999037758833783000  (half life of 12 hours)
        uint256 redemptionFeeFloor; // 1e18 / 1000 * 5  (0.5%)
        uint256 maxRedemptionFee; // 1e18  (100%)
        uint256 borrowingFeeFloor; // 1e18 / 1000 * 5  (0.5%)
        uint256 maxBorrowingFee; // 1e18 / 100 * 5  (5%)
        uint256 interestRateInBps; // 100 (1%)
        uint256 maxDebt;
        uint256 MCR; // 12 * 1e17  (120%)
    }

    event NewDeployment(address collateral, address priceFeed, address troveManager, address sortedTroves);
    event ImplementationContractsChanged(address newTroveManagerImpl, address newSortedTrovesImpl);

    function deployNewInstance(
        address collateral,
        address priceFeed,
        address customTroveManagerImpl,
        address customSortedTrovesImpl,
        DeploymentParams calldata params
    ) external;

    function setImplementations(address _troveManagerImpl, address _sortedTrovesImpl) external;

    function borrowerOperations() external view returns (IBorrowerOperations);

    function debtToken() external view returns (IDebtToken);

    function liquidationManager() external view returns (ILiquidationManager);

    function sortedTrovesImpl() external view returns (address);

    function stabilityPool() external view returns (IStabilityPool);

    function troveManagerCount() external view returns (uint256);

    function troveManagerImpl() external view returns (address);

    function troveManagers(uint256) external view returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {ISystemStart} from "./ISystemStart.sol";
import {IDelegatedOps} from "./IDelegatedOps.sol";
import {ITokenLocker} from "./ITokenLocker.sol";

interface IIncentiveVoting is ISystemStart, IDelegatedOps {
    struct Vote {
        uint256 id;
        uint256 points;
    }

    event AccountWeightRegistered(
        address indexed account,
        uint256 indexed week,
        uint256 frozenBalance,
        ITokenLocker.LockData[] registeredLockData
    );
    event ClearedVotes(address indexed account, uint256 indexed week);
    event NewVotes(address indexed account, uint256 indexed week, Vote[] newVotes, uint256 totalPointsUsed);

    function clearRegisteredWeight(address account) external returns (bool);

    function clearVote(address account) external;

    function getReceiverVoteInputs(uint256 id, uint256 week) external returns (uint256, uint256);

    function getReceiverWeightWrite(uint256 idx) external returns (uint256);

    function getTotalWeightWrite() external returns (uint256);

    function registerAccountWeight(address account, uint256 minWeeks) external;

    function registerAccountWeightAndVote(address account, uint256 minWeeks, Vote[] calldata votes) external;

    function registerNewReceiver() external returns (uint256);

    function unfreeze(address account, bool keepVote) external returns (bool);

    function vote(address account, Vote[] calldata votes, bool clearPrevious) external;

    function MAX_LOCK_WEEKS() external view returns (uint256);

    function MAX_POINTS() external view returns (uint256);

    function getAccountCurrentVotes(address account) external view returns (Vote[] memory votes);

    function getAccountRegisteredLocks(
        address account
    ) external view returns (uint256 frozenWeight, ITokenLocker.LockData[] memory lockData);

    function getReceiverWeight(uint256 idx) external view returns (uint256);

    function getReceiverWeightAt(uint256 idx, uint256 week) external view returns (uint256);

    function getTotalWeight() external view returns (uint256);

    function getTotalWeightAt(uint256 week) external view returns (uint256);

    function receiverCount() external view returns (uint256);

    function receiverDecayRate(uint256) external view returns (uint32);

    function receiverUpdatedWeek(uint256) external view returns (uint16);

    function receiverWeeklyUnlocks(uint256, uint256) external view returns (uint32);

    function tokenLocker() external view returns (ITokenLocker);

    function totalDecayRate() external view returns (uint32);

    function totalUpdatedWeek() external view returns (uint16);

    function totalWeeklyUnlocks(uint256) external view returns (uint32);

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaBase} from "./IBimaBase.sol";
import {IStabilityPool} from "../interfaces/IStabilityPool.sol";
import {IBorrowerOperations} from "../interfaces/IBorrowerOperations.sol";
import {ITroveManager} from "../interfaces/ITroveManager.sol";

interface ILiquidationManager is IBimaBase {
    function batchLiquidateTroves(ITroveManager troveManager, address[] calldata _troveArray) external;

    function enableTroveManager(ITroveManager _troveManager) external;

    function liquidate(ITroveManager troveManager, address borrower) external;

    function liquidateTroves(ITroveManager troveManager, uint256 maxTrovesToLiquidate, uint256 maxICR) external;

    function borrowerOperations() external view returns (IBorrowerOperations);

    function factory() external view returns (address);

    function stabilityPool() external view returns (IStabilityPool);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaOwnable} from "./IBimaOwnable.sol";
import {IAggregatorV3Interface} from "./IAggregatorV3Interface.sol";

interface IPriceFeed is IBimaOwnable {
    function fetchPrice(address _token) external returns (uint256);

    function setOracle(
        address _token,
        address _chainlinkOracle,
        uint32 _heartbeat,
        bytes4 sharePriceSignature,
        uint8 sharePriceDecimals,
        bool _isEthIndexed
    ) external;

    function MAX_PRICE_DEVIATION_FROM_PREVIOUS_ROUND() external view returns (uint256);

    function TARGET_DIGITS() external view returns (uint256);

    function oracleRecords(
        address
    )
        external
        view
        returns (
            IAggregatorV3Interface chainLinkOracle,
            uint8 decimals,
            uint32 heartbeat,
            bytes4 sharePriceSignature,
            uint8 sharePriceDecimals,
            bool isFeedWorking,
            bool isEthIndexed
        );

    function priceRecords(
        address
    ) external view returns (uint96 scaledPrice, uint32 timestamp, uint32 lastUpdated, uint80 roundId);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {ITroveManager} from "./ITroveManager.sol";

interface ISortedTroves {
    event NodeAdded(address _id, uint256 _NICR);
    event NodeRemoved(address _id);

    function insert(address _id, uint256 _NICR, address _prevId, address _nextId) external;

    function reInsert(address _id, uint256 _newNICR, address _prevId, address _nextId) external;

    function remove(address _id) external;

    function setAddresses(address _troveManagerAddress) external;

    function contains(address _id) external view returns (bool);

    function data() external view returns (address head, address tail, uint256 size);

    function findInsertPosition(
        uint256 _NICR,
        address _prevId,
        address _nextId
    ) external view returns (address, address);

    function getFirst() external view returns (address);

    function getLast() external view returns (address);

    function getNext(address _id) external view returns (address);

    function getPrev(address _id) external view returns (address);

    function getSize() external view returns (uint256);

    function isEmpty() external view returns (bool);

    function troveManager() external view returns (ITroveManager);

    function validInsertPosition(uint256 _NICR, address _prevId, address _nextId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ISystemStart} from "./ISystemStart.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {IBimaVault} from "./IVault.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IStabilityPool is IBimaOwnable, ISystemStart {
    event CollateralGainWithdrawn(address indexed _depositor, uint256[] _collateralGains);
    event CollateralOverwritten(IERC20 oldCollateral, IERC20 newCollateral);
    event DepositSnapshotUpdated(address indexed _depositor, uint256 _P, uint256 _G);
    event EpochUpdated(uint128 _currentEpoch);
    event G_Updated(uint256 _G, uint128 _epoch, uint128 _scale);
    event P_Updated(uint256 _P);
    event RewardClaimed(address indexed account, address indexed recipient, uint256 claimed);
    event S_Updated(uint256 idx, uint256 _S, uint128 _epoch, uint128 _scale);
    event ScaleUpdated(uint128 _currentScale);
    event StabilityPoolDebtBalanceUpdated(uint256 _newBalance);
    event UserDepositChanged(address indexed _depositor, uint256 _newDeposit);

    function claimCollateralGains(address recipient, uint256[] calldata collateralIndexes) external;

    function claimReward(address recipient) external returns (uint256 amount);

    function enableCollateral(IERC20 _collateral) external;

    function offset(IERC20 collateral, uint256 _debtToOffset, uint256 _collToAdd) external;

    function provideToSP(uint256 _amount) external;

    function startCollateralSunset(IERC20 collateral) external;

    function vaultClaimReward(address claimant, address) external returns (uint256 amount);

    function withdrawFromSP(uint256 _amount) external;

    function P() external view returns (uint256);

    function SUNSET_DURATION() external view returns (uint128);

    function accountDeposits(address) external view returns (uint128 amount, uint128 timestamp);

    function claimableReward(address _depositor) external view returns (uint256);

    function collateralGainsByDepositor(address depositor, IERC20 token) external view returns (uint256 gains);

    function collateralTokens(uint256) external view returns (IERC20);

    function currentEpoch() external view returns (uint128);

    function currentScale() external view returns (uint128);

    function debtToken() external view returns (IDebtToken);

    function depositSnapshots(address) external view returns (uint256 P, uint256 G, uint128 scale, uint128 epoch);

    function depositSums(address, IERC20) external view returns (uint256);

    function SP_EMISSION_ID() external view returns (uint256);

    function epochToScaleToG(uint128, uint128) external view returns (uint256);

    function epochToScaleToSums(uint128, uint128, IERC20) external view returns (uint256);

    function factory() external view returns (address);

    function getCompoundedDebtDeposit(address _depositor) external view returns (uint256);

    function getDepositorCollateralGain(address _depositor) external view returns (uint256[] memory collateralGains);

    function getTotalDebtTokenDeposits() external view returns (uint256);

    function indexByCollateral(IERC20 collateral) external view returns (uint256 index);

    function lastCollateralError_Offset(uint256) external view returns (uint256);

    function lastDebtLossError_Offset() external view returns (uint256);

    function lastBimaError() external view returns (uint256);

    function lastUpdate() external view returns (uint32);

    function liquidationManager() external view returns (address);

    function periodFinish() external view returns (uint32);

    function rewardRate() external view returns (uint128);

    function vault() external view returns (IBimaVault);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

interface ISystemStart {
    function getWeek() external view returns (uint256 week);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ISystemStart} from "./ISystemStart.sol";
import {IBimaToken} from "./IBimaToken.sol";
import {IBimaCore} from "./IBimaCore.sol";
import {IIncentiveVoting} from "./IIncentiveVoting.sol";

interface ITokenLocker is IBimaOwnable, ISystemStart {
    struct LockData {
        uint256 amount;
        uint256 weeksToUnlock;
    }
    struct ExtendLockData {
        uint256 amount;
        uint256 currentWeeks;
        uint256 newWeeks;
    }

    event LockCreated(address indexed account, uint256 amount, uint256 _weeks);
    event LockExtended(address indexed account, uint256 amount, uint256 _weeks, uint256 newWeeks);
    event LocksCreated(address indexed account, LockData[] newLocks);
    event LocksExtended(address indexed account, ExtendLockData[] locks);
    event LocksFrozen(address indexed account, uint256 amount);
    event LocksUnfrozen(address indexed account, uint256 amount);
    event LocksWithdrawn(address indexed account, uint256 withdrawn, uint256 penalty);
    event SetAllowPenaltyWithdrawAfter(uint256 startTime);
    event SetPenaltyWithdrawalsEnabled(bool status);

    function extendLock(uint256 _amount, uint256 _weeks, uint256 _newWeeks) external returns (bool);

    function extendMany(ExtendLockData[] calldata newExtendLocks) external returns (bool);

    function freeze() external;

    function getAccountWeightWrite(address account) external returns (uint256);

    function getTotalWeightWrite() external returns (uint256);

    function lock(address _account, uint256 _amount, uint256 _weeks) external returns (bool);

    function lockMany(address _account, LockData[] calldata newLocks) external returns (bool);

    function setPenaltyWithdrawalsEnabled(bool _enabled) external returns (bool);

    function unfreeze(bool keepIncentivesVote) external;

    function withdrawExpiredLocks(uint256 _weeks) external returns (bool);

    function withdrawWithPenalty(uint256 amountToWithdraw) external returns (uint256);

    function MAX_LOCK_WEEKS() external view returns (uint256);

    function getAccountActiveLocks(
        address account,
        uint256 minWeeks
    ) external view returns (LockData[] memory lockData, uint256 frozenAmount);

    function getAccountBalances(address account) external view returns (uint256 locked, uint256 unlocked);

    function getAccountWeight(address account) external view returns (uint256);

    function getAccountWeightAt(address account, uint256 week) external view returns (uint256);

    function getTotalWeight() external view returns (uint256);

    function getTotalWeightAt(uint256 week) external view returns (uint256);

    function getWithdrawWithPenaltyAmounts(
        address account,
        uint256 amountToWithdraw
    ) external view returns (uint256 amountWithdrawn, uint256 penaltyAmountPaid);

    function incentiveVoter() external view returns (IIncentiveVoting);

    function lockToTokenRatio() external view returns (uint256);

    function lockToken() external view returns (IBimaToken);

    function penaltyWithdrawalsEnabled() external view returns (bool);

    function bimaCore() external view returns (IBimaCore);

    function totalDecayRate() external view returns (uint32);

    function totalUpdatedWeek() external view returns (uint16);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaBase} from "./IBimaBase.sol";
import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ISystemStart} from "./ISystemStart.sol";
import {IDebtToken} from "./IDebtToken.sol";
import {IBimaVault} from "./IVault.sol";
import {IPriceFeed} from "./IPriceFeed.sol";
import {ISortedTroves} from "./ISortedTroves.sol";
import {IEmissionReceiver} from "./IEmissionReceiver.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface ITroveManager is IBimaBase, IBimaOwnable, ISystemStart, IEmissionReceiver {
    event BaseRateUpdated(uint256 _baseRate);
    event CollateralSent(address _to, uint256 _amount);
    event LTermsUpdated(uint256 _L_collateral, uint256 _L_debt);
    event LastFeeOpTimeUpdated(uint256 _lastFeeOpTime);
    event Redemption(
        uint256 _attemptedDebtAmount,
        uint256 _actualDebtAmount,
        uint256 _collateralSent,
        uint256 _collateralFee
    );
    event RewardClaimed(address indexed account, address indexed recipient, uint256 claimed);
    event SystemSnapshotsUpdated(uint256 _totalStakesSnapshot, uint256 _totalCollateralSnapshot);
    event TotalStakesUpdated(uint256 _newTotalStakes);
    event TroveIndexUpdated(address _borrower, uint256 _newIndex);
    event TroveSnapshotsUpdated(uint256 _L_collateral, uint256 _L_debt);
    event TroveUpdated(
        address indexed _borrower,
        uint256 _debt,
        uint256 _coll,
        uint256 _stake,
        TroveManagerOperation _operation
    );
    event Paused();
    event Unpaused();
    event SetPriceFeed(address);
    event StartSunset();
    event SetParameters(
        uint256 _minuteDecayFactor,
        uint256 _redemptionFeeFloor,
        uint256 _maxRedemptionFee,
        uint256 _borrowingFeeFloor,
        uint256 _maxBorrowingFee,
        uint256 _interestRateInBPS,
        uint256 _maxSystemDebt,
        uint256 _MCR
    );
    event CollectedInterest(uint256 amount);

    enum Status {
        nonExistent,
        active,
        closedByOwner,
        closedByLiquidation,
        closedByRedemption
    }

    enum TroveManagerOperation {
        applyPendingRewards,
        liquidateInNormalMode,
        liquidateInRecoveryMode,
        redeemCollateral
    }

    function addCollateralSurplus(address borrower, uint256 collSurplus) external;

    function applyPendingRewards(address _borrower) external returns (uint256 coll, uint256 debt);

    function claimCollateral(address _receiver) external;

    function claimReward(address receiver) external returns (uint256);

    function closeTrove(address _borrower, address _receiver, uint256 collAmount, uint256 debtAmount) external;

    function closeTroveByLiquidation(address _borrower) external;

    function collectInterests() external;

    function decayBaseRateAndGetBorrowingFee(uint256 _debt) external returns (uint256);

    function decreaseDebtAndSendCollateral(address account, uint256 debt, uint256 coll) external;

    function fetchPrice() external returns (uint256);

    function finalizeLiquidation(
        address _liquidator,
        uint256 _debt,
        uint256 _coll,
        uint256 _collSurplus,
        uint256 _debtGasComp,
        uint256 _collGasComp
    ) external;

    function getEntireSystemBalances() external returns (uint256, uint256, uint256);

    function movePendingTroveRewardsToActiveBalances(uint256 _debt, uint256 _collateral) external;

    function openTrove(
        address _borrower,
        uint256 _collateralAmount,
        uint256 _compositeDebt,
        uint256 NICR,
        address _upperHint,
        address _lowerHint,
        bool _isRecoveryMode
    ) external returns (uint256 stake, uint256 arrayIndex);

    function redeemCollateral(
        uint256 _debtAmount,
        address _firstRedemptionHint,
        address _upperPartialRedemptionHint,
        address _lowerPartialRedemptionHint,
        uint256 _partialRedemptionHintNICR,
        uint256 _maxIterations,
        uint256 _maxFeePercentage
    ) external;

    function setAddresses(address _priceFeedAddress, address _sortedTrovesAddress, address _collateralToken) external;

    function setParameters(
        uint256 _minuteDecayFactor,
        uint256 _redemptionFeeFloor,
        uint256 _maxRedemptionFee,
        uint256 _borrowingFeeFloor,
        uint256 _maxBorrowingFee,
        uint256 _interestRateInBPS,
        uint256 _maxSystemDebt,
        uint256 _MCR
    ) external;

    function setPaused(bool _paused) external;

    function setPriceFeed(address _priceFeedAddress) external;

    function startSunset() external;

    function updateBalances() external;

    function updateTroveFromAdjustment(
        bool _isRecoveryMode,
        bool _isDebtIncrease,
        uint256 _debtChange,
        uint256 _netDebtChange,
        bool _isCollIncrease,
        uint256 _collChange,
        address _upperHint,
        address _lowerHint,
        address _borrower,
        address _receiver
    ) external returns (uint256, uint256, uint256);

    function vaultClaimReward(address claimant, address) external returns (uint256);

    function BOOTSTRAP_PERIOD() external view returns (uint256);

    function L_collateral() external view returns (uint256);

    function L_debt() external view returns (uint256);

    function MAX_INTEREST_RATE_IN_BPS() external view returns (uint256);

    function MCR() external view returns (uint256);

    function SUNSETTING_INTEREST_RATE() external view returns (uint256);

    function Troves(
        address
    )
        external
        view
        returns (
            uint256 debt,
            uint256 coll,
            uint256 stake,
            Status status,
            uint128 arrayIndex,
            uint256 activeInterestIndex
        );

    function accountLatestMint(address) external view returns (uint256 amount, uint32 week, uint32 day);

    function activeInterestIndex() external view returns (uint256);

    function baseRate() external view returns (uint256);

    function borrowerOperationsAddress() external view returns (address);

    function borrowingFeeFloor() external view returns (uint256);

    function claimableReward(address account) external view returns (uint256);

    function collateralToken() external view returns (IERC20);

    function dailyMintReward(uint256) external view returns (uint256);

    function debtToken() external view returns (IDebtToken);

    function defaultedCollateral() external view returns (uint256);

    function defaultedDebt() external view returns (uint256);

    function emissionId() external view returns (uint16 debt, uint16 minting);

    function getBorrowingFee(uint256 _debt) external view returns (uint256);

    function getBorrowingFeeWithDecay(uint256 _debt) external view returns (uint256);

    function getBorrowingRate() external view returns (uint256);

    function getBorrowingRateWithDecay() external view returns (uint256);

    function getCurrentICR(address _borrower, uint256 _price) external view returns (uint256);

    function getEntireDebtAndColl(
        address _borrower
    ) external view returns (uint256 debt, uint256 coll, uint256 pendingDebtReward, uint256 pendingCollateralReward);

    function getEntireSystemColl() external view returns (uint256);

    function getEntireSystemDebt() external view returns (uint256);

    function getNominalICR(address _borrower) external view returns (uint256);

    function getPendingCollAndDebtRewards(address _borrower) external view returns (uint256, uint256);

    function getRedemptionFeeWithDecay(uint256 _collateralDrawn) external view returns (uint256);

    function getRedemptionRate() external view returns (uint256);

    function getRedemptionRateWithDecay() external view returns (uint256);

    function getTotalActiveCollateral() external view returns (uint256);

    function getTotalActiveDebt() external view returns (uint256);

    function getTotalMints(uint256 week) external view returns (uint256[7] memory);

    function getTroveCollAndDebt(address _borrower) external view returns (uint256 coll, uint256 debt);

    function getTroveFromTroveOwnersArray(uint256 _index) external view returns (address);

    function getTroveOwnersCount() external view returns (uint256);

    function getTroveStake(address _borrower) external view returns (uint256);

    function getTroveStatus(address _borrower) external view returns (Status);

    function getWeekAndDay() external view returns (uint256, uint256);

    function hasPendingRewards(address _borrower) external view returns (bool);

    function interestPayable() external view returns (uint256);

    function interestRate() external view returns (uint256);

    function lastActiveIndexUpdate() external view returns (uint256);

    function lastCollateralError_Redistribution() external view returns (uint256);

    function lastDebtError_Redistribution() external view returns (uint256);

    function lastFeeOperationTime() external view returns (uint256);

    function lastUpdate() external view returns (uint32);

    function liquidationManager() external view returns (address);

    function maxBorrowingFee() external view returns (uint256);

    function maxRedemptionFee() external view returns (uint256);

    function maxSystemDebt() external view returns (uint256);

    function minuteDecayFactor() external view returns (uint256);

    function paused() external view returns (bool);

    function periodFinish() external view returns (uint32);

    function priceFeed() external view returns (IPriceFeed);

    function redemptionFeeFloor() external view returns (uint256);

    function rewardIntegral() external view returns (uint256);

    function rewardIntegralFor(address) external view returns (uint256);

    function rewardRate() external view returns (uint128);

    function rewardSnapshots(address) external view returns (uint256 collateral, uint256 debt);

    function sortedTroves() external view returns (ISortedTroves);

    function sunsetting() external view returns (bool);

    function surplusBalances(address) external view returns (uint256);

    function systemDeploymentTime() external view returns (uint256);

    function totalCollateralSnapshot() external view returns (uint256);

    function totalStakes() external view returns (uint256);

    function totalStakesSnapshot() external view returns (uint256);

    function vault() external view returns (IBimaVault);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {IBimaOwnable} from "./IBimaOwnable.sol";
import {ISystemStart} from "./ISystemStart.sol";
import {IBoostCalculator} from "./IBoostCalculator.sol";
import {IBoostDelegate} from "./IBoostDelegate.sol";
import {ITokenLocker} from "./ITokenLocker.sol";
import {IIncentiveVoting} from "./IIncentiveVoting.sol";
import {IBimaToken} from "./IBimaToken.sol";
import {IEmissionSchedule} from "./IEmissionSchedule.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IRewards {
    function vaultClaimReward(address claimant, address receiver) external returns (uint256);

    function claimableReward(address account) external view returns (uint256);
}

interface IBimaVault is IBimaOwnable, ISystemStart {
    struct InitialAllowance {
        address receiver;
        uint256 amount;
    }

    event BoostCalculatorSet(address boostCalculator);
    event BoostDelegationSet(address indexed boostDelegate, bool isEnabled, uint256 feePct, address callback);
    event EmissionScheduleSet(address emissionScheduler);
    event IncreasedAllocation(address indexed receiver, uint256 increasedAmount);
    event NewReceiverRegistered(address receiver, uint256 id);
    event ReceiverIsActiveStatusModified(uint256 indexed id, bool isActive);
    event UnallocatedSupplyIncreased(uint256 increasedAmount, uint256 unallocatedTotal);
    event UnallocatedSupplyReduced(uint256 reducedAmount, uint256 unallocatedTotal);

    function allocateNewEmissions(uint256 id) external returns (uint256);

    function batchClaimRewards(
        address receiver,
        address boostDelegate,
        IRewards[] calldata rewardContracts,
        uint256 maxFeePct
    ) external returns (bool);

    function increaseUnallocatedSupply(uint256 amount) external returns (bool);

    function registerReceiver(address receiver, uint256 count) external returns (bool);

    function setBoostCalculator(IBoostCalculator _boostCalculator) external returns (bool);

    function setBoostDelegationParams(bool isEnabled, uint16 feePct, address callback) external returns (bool);

    function setEmissionSchedule(IEmissionSchedule _emissionSchedule) external returns (bool);

    function setInitialParameters(
        IEmissionSchedule _emissionSchedule,
        IBoostCalculator _boostCalculator,
        uint256 totalSupply,
        uint64 initialLockWeeks,
        uint128[] calldata _fixedInitialAmounts,
        InitialAllowance[] calldata initialAllowances
    ) external;

    function setReceiverIsActive(uint256 id, bool isActive) external returns (bool);

    function transferAllocatedTokens(address claimant, address receiver, uint256 amount) external returns (bool);

    function transferTokens(IERC20 token, address receiver, uint256 amount) external returns (bool);

    function allocated(address) external view returns (uint256);

    function boostCalculator() external view returns (IBoostCalculator);

    function boostDelegation(address) external view returns (bool isEnabled, uint16 feePct, IBoostDelegate callback);

    function claimableRewardAfterBoost(
        address account,
        address receiver,
        address boostDelegate,
        IRewards rewardContract
    ) external view returns (uint256 adjustedAmount, uint256 feeToDelegate);

    function emissionSchedule() external view returns (IEmissionSchedule);

    function getClaimableWithBoost(address claimant) external view returns (uint256 maxBoosted, uint256 boosted);

    function idToReceiver(uint256) external view returns (address account, bool isActive, uint16 updatedWeek);

    function isReceiverActive(uint256 id) external view returns (bool isActive);

    function isBoostDelegatedEnabled(address account) external view returns (bool isEnabled);

    function lockWeeks() external view returns (uint64);

    function locker() external view returns (ITokenLocker);

    function claimableBoostDelegationFees(address claimant) external view returns (uint256 amount);

    function bimaToken() external view returns (IBimaToken);

    function totalUpdateWeek() external view returns (uint64);

    function unallocatedTotal() external view returns (uint128);

    function voter() external view returns (IIncentiveVoting);

    function weeklyEmissions(uint256) external view returns (uint128);
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_bimaCore","type":"address"},{"internalType":"contract IDebtToken","name":"_debtToken","type":"address"},{"internalType":"contract IStabilityPool","name":"_stabilityPool","type":"address"},{"internalType":"contract IBorrowerOperations","name":"_borrowerOperations","type":"address"},{"internalType":"address","name":"_sortedTroves","type":"address"},{"internalType":"address","name":"_troveManager","type":"address"},{"internalType":"contract ILiquidationManager","name":"_liquidationManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newTroveManagerImpl","type":"address"},{"indexed":false,"internalType":"address","name":"newSortedTrovesImpl","type":"address"}],"name":"ImplementationContractsChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"collateral","type":"address"},{"indexed":false,"internalType":"address","name":"priceFeed","type":"address"},{"indexed":false,"internalType":"address","name":"troveManager","type":"address"},{"indexed":false,"internalType":"address","name":"sortedTroves","type":"address"}],"name":"NewDeployment","type":"event"},{"inputs":[],"name":"BIMA_CORE","outputs":[{"internalType":"contract IBimaCore","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"borrowerOperations","outputs":[{"internalType":"contract IBorrowerOperations","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debtToken","outputs":[{"internalType":"contract IDebtToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"collateral","type":"address"},{"internalType":"address","name":"priceFeed","type":"address"},{"internalType":"address","name":"customTroveManagerImpl","type":"address"},{"internalType":"address","name":"customSortedTrovesImpl","type":"address"},{"components":[{"internalType":"uint256","name":"minuteDecayFactor","type":"uint256"},{"internalType":"uint256","name":"redemptionFeeFloor","type":"uint256"},{"internalType":"uint256","name":"maxRedemptionFee","type":"uint256"},{"internalType":"uint256","name":"borrowingFeeFloor","type":"uint256"},{"internalType":"uint256","name":"maxBorrowingFee","type":"uint256"},{"internalType":"uint256","name":"interestRateInBps","type":"uint256"},{"internalType":"uint256","name":"maxDebt","type":"uint256"},{"internalType":"uint256","name":"MCR","type":"uint256"}],"internalType":"struct IFactory.DeploymentParams","name":"params","type":"tuple"}],"name":"deployNewInstance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"guardian","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidationManager","outputs":[{"internalType":"contract ILiquidationManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_troveManagerImpl","type":"address"},{"internalType":"address","name":"_sortedTrovesImpl","type":"address"}],"name":"setImplementations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sortedTrovesImpl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stabilityPool","outputs":[{"internalType":"contract IStabilityPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"troveManagerCount","outputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"troveManagerImpl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"troveManagers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000227e9323d692578ca3df92b87d06625df22380ab0000000000000000000000006bede1c6009a78c222d9bdb7974bb67847fdb68c0000000000000000000000005f2283c7c8967c5fb3a959e63ea89865b882d62700000000000000000000000087fed36c032ee7289a1d2f3c48798e4c7fcdfaec000000000000000000000000870a108234dee42a9fa01c36368e5e4ea3c56b4a0000000000000000000000008ed4f24f71ffbfba5109be1ed13c83b7cc6579380000000000000000000000002d3b9e988470d14a81b9965e4e5229aae06b73ba

-----Decoded View---------------
Arg [0] : _bimaCore (address): 0x227E9323D692578Ca3dF92b87d06625Df22380Ab
Arg [1] : _debtToken (address): 0x6bedE1c6009a78c222D9BDb7974bb67847fdB68c
Arg [2] : _stabilityPool (address): 0x5F2283c7C8967c5Fb3a959E63ea89865B882d627
Arg [3] : _borrowerOperations (address): 0x87FED36c032EE7289a1d2f3C48798e4C7fCDfAEc
Arg [4] : _sortedTroves (address): 0x870A108234DEe42A9Fa01c36368E5e4ea3C56b4A
Arg [5] : _troveManager (address): 0x8Ed4f24F71fFbfBA5109be1eD13c83b7cC657938
Arg [6] : _liquidationManager (address): 0x2D3b9e988470d14a81B9965e4E5229AaE06b73BA

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000227e9323d692578ca3df92b87d06625df22380ab
Arg [1] : 0000000000000000000000006bede1c6009a78c222d9bdb7974bb67847fdb68c
Arg [2] : 0000000000000000000000005f2283c7c8967c5fb3a959e63ea89865b882d627
Arg [3] : 00000000000000000000000087fed36c032ee7289a1d2f3c48798e4c7fcdfaec
Arg [4] : 000000000000000000000000870a108234dee42a9fa01c36368e5e4ea3c56b4a
Arg [5] : 0000000000000000000000008ed4f24f71ffbfba5109be1ed13c83b7cc657938
Arg [6] : 0000000000000000000000002d3b9e988470d14a81b9965e4e5229aae06b73ba