编译器
0.8.28+commit.7893614a
文件 1 的 26：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 26：ConstantsLib.sol
pragma solidity 0.8.28;
uint256 constant EPOCH_UPDATE_INTERVAL = 8 hours;
uint256 constant MAX_EARLY_WITHDRAW_FEE_BIPS = 1000;
uint256 constant MAX_WIDGET_FEE_BIPS = 2000;
bytes32 constant SETTLEMENT_REQUEST_SIGNATURE_HASH = keccak256(
"SettlementRequest(uint256 nonce,uint256 deadline,address trader,bytes32 positionUpdates,address recipient)"
);
bytes32 constant REMOVE_COLLATERAL_REQUEST_SIGNATURE_HASH =
keccak256("RemoveCollateralRequest(uint256 nonce,uint256 deadline,address trader,bytes32 tokens,address recipient)");
bytes32 constant LIQUIDATION_REQUEST_SIGNATURE_HASH = keccak256(
"LiquidationRequest(uint256 nonce,uint256 deadline,address trader,bytes32 positionUpdates,bytes32 claimCollaterals,address recipient)"
);
bytes32 constant ORDER_SIGNATURE_HASH = keccak256(
"Order(uint256 id,address signer,address buyer,address seller,address buyerToken,address sellerToken,uint256 buyerTokenAmount,uint256 sellerTokenAmount,uint256 deadlineTimestamp,address caller,bytes16 quoteId)"
);
bytes32 constant RFQ_QUOTE_WIDGET_SIGNATURE_HASH =
keccak256("RFQTQuote(bytes32 quote,address widgetFeeRecipient,uint256 widgetFeeRate)");
bytes32 constant FILL_ORDER_SIGNATURE_HASH = keccak256(
"fillOrder(uint256 nonce,address recipient,address tokenIn,address tokenOut,uint256 amountIn,uint256 amountOut,uint256 deadline,address widgetFeeRecipient,uint256 widgetFeeRate)"
);
文件 3 的 26：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 4 的 26：CreditVault.sol
pragma solidity 0.8.28;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {EIP712, ECDSA} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "./libraries/ConstantsLib.sol";
import {ErrorsLib} from "./libraries/ErrorsLib.sol";
import {SafeERC20} from "./libraries/SafeERC20.sol";
import {ICreditVault} from "./interfaces/ICreditVault.sol";
import {ReentrancyGuardTransient} from "./libraries/ReentrancyGuardTransient.sol";
import {NativeLPToken} from "./NativeLPToken.sol";
contract CreditVault is ICreditVault, EIP712, Ownable2Step, ReentrancyGuardTransient {
using SafeERC20 for IERC20;
using SafeCast for uint256;
using SafeCast for int256;
address public feeWithdrawer;
address public signer;
address public epochUpdater;
NativeLPToken[] public allLPTokens;
mapping(address => bool) public creditPools;
mapping(address => uint256) public reserveFees;
mapping(address => uint256) public lastEpochUpdateTimestamp;
mapping(address => NativeLPToken) public lpTokens;
mapping(uint256 => bool) public nonces;
mapping(address => mapping(address => int256)) public positions;
mapping(address => mapping(address => uint256)) public collateral;
mapping(address => bool) public supportedMarkets;
mapping(address => bool) public traders;
mapping(address => address) public traderToSettler;
mapping(address => address) public traderToRecipient;
mapping(address => bool) public whitelistTraders;
mapping(address => bool) public liquidators;
mapping(address => address) public liquidatorToRecipient;
mapping(address => mapping(address => RebalanceCap)) public rebalanceCaps;
constructor() EIP712("Native Credit Vault", "1") {}
function swapCallback(
address trader,
address tokenIn,
int256 amountIn,
address tokenOut,
int256 amountOut
) external {
require(creditPools[msg.sender], ErrorsLib.OnlyCreditPool());
require(
address(lpTokens[tokenIn]) != address(0) && address(lpTokens[tokenOut]) != address(0),
ErrorsLib.InvalidUnderlying()
);
positions[trader][tokenIn] += amountIn;
positions[trader][tokenOut] -= amountOut;
}
function epochUpdate(AccruedFundingFee[] calldata accruedFees) external {
require(msg.sender == epochUpdater, ErrorsLib.OnlyEpochUpdater());
for (uint256 i; i < accruedFees.length; ++i) {
address trader = accruedFees[i].trader;
if (block.timestamp - lastEpochUpdateTimestamp[trader] < EPOCH_UPDATE_INTERVAL) {
revert ErrorsLib.EpochUpdateInCoolDown();
}
for (uint256 j; j < accruedFees[i].feeUpdates.length; ++j) {
address token = accruedFees[i].feeUpdates[j].token;
uint256 fundingFee = accruedFees[i].feeUpdates[j].fundingFee;
uint256 reserveFee = accruedFees[i].feeUpdates[j].reserveFee;
require(address(lpTokens[token]) != address(0), ErrorsLib.InvalidUnderlying());
if (fundingFee > 0) {
uint256 beforeExchangeRate = lpTokens[token].exchangeRate();
lpTokens[token].distributeYield(fundingFee);
if (((lpTokens[token].exchangeRate() - beforeExchangeRate) * 10_000) > beforeExchangeRate * 100) {
revert ErrorsLib.ExchangeRateIncreaseTooMuch();
}
}
if (reserveFee > 0) {
reserveFees[token] += reserveFee;
}
positions[trader][token] -= (reserveFee + fundingFee).toInt256();
}
lastEpochUpdateTimestamp[trader] = block.timestamp;
}
emit EpochUpdated(accruedFees);
}
function settle(
SettlementRequest calldata request,
bytes calldata signature
) external onlyTraderOrSettler(request.trader) nonReentrant {
_verifySettleSignature(request, signature);
_updatePositions(request.positionUpdates, request.trader);
address recipient = traderToRecipient[request.trader];
for (uint256 i; i < request.positionUpdates.length; ++i) {
address token = request.positionUpdates[i].token;
int256 amount = request.positionUpdates[i].amount;
if (amount > 0) {
IERC20(token).safeTransferFrom(msg.sender, address(this), amount.toUint256());
} else {
_updateRebalanceCap(request.trader, token, (-amount).toUint256());
IERC20(token).safeTransfer(recipient, (-amount).toUint256());
}
}
emit Settled(request.trader, request.positionUpdates);
}
function removeCollateral(
RemoveCollateralRequest calldata request,
bytes calldata signature
) external onlyTraderOrSettler(request.trader) nonReentrant {
_verifyRemoveCollateralSignature(request, signature);
for (uint256 i; i < request.tokens.length; ++i) {
collateral[request.trader][request.tokens[i].token] -= request.tokens[i].amount;
}
address recipient = traderToRecipient[request.trader];
for (uint256 i; i < request.tokens.length; ++i) {
address token = request.tokens[i].token;
uint256 amount = request.tokens[i].amount;
_updateRebalanceCap(request.trader, token, amount);
IERC20(token).safeTransfer(recipient, amount);
}
emit CollateralRemoved(request.trader, request.tokens);
}
function repay(
TokenAmountInt[] calldata positionUpdates,
address trader
) external onlyTraderOrSettler(trader) nonReentrant {
_updatePositions(positionUpdates, trader);
for (uint256 i; i < positionUpdates.length; ++i) {
IERC20(positionUpdates[i].token).safeTransferFrom(
msg.sender, address(this), positionUpdates[i].amount.toUint256()
);
}
emit Repaid(trader, positionUpdates);
}
function liquidate(
LiquidationRequest calldata request,
bytes calldata signature
) external onlyLiquidator nonReentrant {
_verifyLiquidationSignature(request, signature);
_updatePositions(request.positionUpdates, request.trader);
address recipient = liquidatorToRecipient[msg.sender];
for (uint256 i; i < request.claimCollaterals.length; ++i) {
collateral[request.trader][request.claimCollaterals[i].token] -= request.claimCollaterals[i].amount;
}
for (uint256 i; i < request.positionUpdates.length; ++i) {
address token = request.positionUpdates[i].token;
int256 amount = request.positionUpdates[i].amount;
if (amount > 0) {
IERC20(token).safeTransferFrom(msg.sender, address(this), amount.toUint256());
} else {
_updateRebalanceCap(msg.sender, token, (-amount).toUint256());
IERC20(token).safeTransfer(recipient, (-amount).toUint256());
}
}
for (uint256 i; i < request.claimCollaterals.length; ++i) {
address token = request.claimCollaterals[i].token;
_updateRebalanceCap(msg.sender, token, request.claimCollaterals[i].amount);
IERC20(token).safeTransfer(recipient, request.claimCollaterals[i].amount);
}
emit Liquidated(request.trader, msg.sender, request.positionUpdates, request.claimCollaterals);
}
function pay(address to, uint256 amount) external {
require(supportedMarkets[msg.sender], ErrorsLib.OnlyLpToken());
require(amount <= NativeLPToken(msg.sender).totalUnderlying(), ErrorsLib.InsufficientUnderlying());
IERC20(NativeLPToken(msg.sender).underlying()).safeTransfer(to, amount);
}
function addCollateral(TokenAmountUint[] calldata tokens, address trader) external nonReentrant {
require(traders[trader], ErrorsLib.OnlyTrader());
for (uint256 i; i < tokens.length; ++i) {
address token = tokens[i].token;
require(supportedMarkets[token], ErrorsLib.OnlyLpToken());
uint256 amount = tokens[i].amount;
collateral[trader][token] += amount;
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
}
emit CollateralAdded(trader, tokens);
}
function supportMarket(NativeLPToken lpToken) external onlyOwner {
require(!supportedMarkets[address(lpToken)], ErrorsLib.TokenAlreadyListed());
address underlying = address(lpToken.underlying());
require(
address(lpTokens[underlying]) == address(0) && lpToken.creditVault() == address(this),
ErrorsLib.InvalidMarket()
);
require(address(underlying) != address(0), ErrorsLib.InvalidLPToken());
lpTokens[underlying] = lpToken;
supportedMarkets[address(lpToken)] = true;
allLPTokens.push(lpToken);
emit MarketListed(address(lpToken));
}
function withdrawReserve(address underlying, address recipient, uint256 amount) external {
require(recipient != address(0), ErrorsLib.ZeroAddress());
require(msg.sender == feeWithdrawer, ErrorsLib.OnlyFeeWithdrawer());
require(amount <= reserveFees[underlying], ErrorsLib.InsufficientFundingFees());
reserveFees[underlying] -= amount;
IERC20(underlying).safeTransfer(recipient, amount);
emit ReserveWithdrawn(underlying, recipient, amount);
}
function setCreditPool(address pool, bool isActive) external onlyOwner {
require(pool != address(0), ErrorsLib.ZeroAddress());
creditPools[pool] = isActive;
emit CreditPoolUpdated(pool, isActive);
}
function setAllowance(TokenAmountUint[] calldata tokens, address pool) external onlyOwner {
for (uint256 i; i < tokens.length; ++i) {
require(address(lpTokens[tokens[i].token]) != address(0), ErrorsLib.InvalidUnderlying());
IERC20(tokens[i].token).safeApprove(pool, tokens[i].amount);
}
}
function setRebalanceCap(address operator, address token, uint256 limit) external onlyOwner {
require(token != address(0), ErrorsLib.ZeroAddress());
require(traders[operator] || liquidators[operator], ErrorsLib.NotTraderOrLiquidator());
rebalanceCaps[operator][token] = RebalanceCap({limit: limit, used: 0, lastDay: block.timestamp / 86_400});
emit RebalanceCapUpdated(operator, token, limit);
}
function setTrader(
address trader,
address settler,
address recipient,
bool isTrader,
bool isWhitelistTrader
) external onlyOwner {
require(trader != address(0) && settler != address(0) && recipient != address(0), ErrorsLib.ZeroAddress());
require(recipient != trader && recipient != settler, ErrorsLib.TraderRecipientConflict());
traders[trader] = isTrader;
traderToSettler[trader] = settler;
traderToRecipient[trader] = recipient;
whitelistTraders[trader] = isWhitelistTrader;
emit TraderSet(trader, isTrader, isWhitelistTrader, settler, recipient);
}
function setLiquidator(address liquidator, address recipient, bool status) external onlyOwner {
require(liquidator != address(0) && recipient != address(0), ErrorsLib.ZeroAddress());
require(liquidator != recipient, ErrorsLib.LiquidatorRecipientConflict());
liquidators[liquidator] = status;
liquidatorToRecipient[liquidator] = recipient;
emit LiquidatorSet(liquidator, status);
}
function setSigner(address _signer) external onlyOwner {
require(_signer != address(0), ErrorsLib.ZeroAddress());
signer = _signer;
emit SignerSet(_signer);
}
function setEpochUpdater(address _epochUpdater) external onlyOwner {
require(_epochUpdater != address(0), ErrorsLib.ZeroAddress());
epochUpdater = _epochUpdater;
emit EpochUpdaterSet(_epochUpdater);
}
function setFeeWithdrawer(address payable _feeWithdrawer) external onlyOwner {
require(_feeWithdrawer != address(0), ErrorsLib.ZeroAddress());
feeWithdrawer = _feeWithdrawer;
emit FeeWithdrawerSet(_feeWithdrawer);
}
function _updateNonce(uint256 nonce) internal {
require(!nonces[nonce], ErrorsLib.NonceUsed());
nonces[nonce] = true;
}
function _updatePositions(ICreditVault.TokenAmountInt[] memory positionUpdates, address trader) internal {
uint256 updatesLength = positionUpdates.length;
for (uint256 i; i < updatesLength; ++i) {
address token = positionUpdates[i].token;
int256 amount = positionUpdates[i].amount;
int256 newPosition = positions[trader][token] + amount;
require(address(lpTokens[token]) != address(0), ErrorsLib.InvalidLPToken());
if (positions[trader][token] * amount >= 0 || positions[trader][token] * newPosition < 0) {
revert ErrorsLib.InvalidPositionUpdateAmount();
}
positions[trader][token] = newPosition;
}
}
function _updateRebalanceCap(address trader, address token, uint256 amount) internal {
RebalanceCap storage cap = rebalanceCaps[trader][token];
uint256 currentDay = block.timestamp / 86_400;
uint256 newUsed;
if (currentDay > cap.lastDay) {
newUsed = amount;
} else {
newUsed = cap.used + amount;
}
require(cap.limit == 0 || newUsed <= cap.limit, ErrorsLib.RebalanceLimitExceeded());
rebalanceCaps[trader][token] = RebalanceCap({limit: cap.limit, used: newUsed, lastDay: currentDay});
}
function _verifySettleSignature(
ICreditVault.SettlementRequest calldata request,
bytes calldata signature
) internal {
require(request.deadline >= block.timestamp, ErrorsLib.RequestExpired());
_updateNonce(request.nonce);
bytes32 msgHash = keccak256(
abi.encode(
SETTLEMENT_REQUEST_SIGNATURE_HASH,
request.nonce,
request.deadline,
request.trader,
keccak256(abi.encode(request.positionUpdates)),
traderToRecipient[request.trader]
)
);
bytes32 digest = _hashTypedDataV4(msgHash);
address recoveredSigner = ECDSA.recover(digest, signature);
require(recoveredSigner == signer, ErrorsLib.InvalidSignature());
}
function _verifyRemoveCollateralSignature(
ICreditVault.RemoveCollateralRequest calldata request,
bytes calldata signature
) internal {
require(request.deadline >= block.timestamp, ErrorsLib.RequestExpired());
_updateNonce(request.nonce);
bytes32 msgHash = keccak256(
abi.encode(
REMOVE_COLLATERAL_REQUEST_SIGNATURE_HASH,
request.nonce,
request.deadline,
request.trader,
keccak256(abi.encode(request.tokens)),
traderToRecipient[request.trader]
)
);
bytes32 digest = _hashTypedDataV4(msgHash);
address recoveredSigner = ECDSA.recover(digest, signature);
require(recoveredSigner == signer, ErrorsLib.InvalidSignature());
}
function _verifyLiquidationSignature(
ICreditVault.LiquidationRequest calldata request,
bytes calldata signature
) internal {
require(request.deadline >= block.timestamp, ErrorsLib.RequestExpired());
_updateNonce(request.nonce);
bytes32 msgHash = keccak256(
abi.encode(
LIQUIDATION_REQUEST_SIGNATURE_HASH,
request.nonce,
request.deadline,
request.trader,
keccak256(abi.encode(request.positionUpdates)),
keccak256(abi.encode(request.claimCollaterals)),
liquidatorToRecipient[msg.sender]
)
);
bytes32 digest = _hashTypedDataV4(msgHash);
address recoveredSigner = ECDSA.recover(digest, signature);
require(recoveredSigner == signer, ErrorsLib.InvalidSignature());
}
modifier onlyTraderOrSettler(address trader) {
require(
(traders[trader] && trader == msg.sender)
|| (traders[trader] && msg.sender == traderToSettler[trader]),
ErrorsLib.OnlyTrader()
);
_;
}
modifier onlyLiquidator() {
require(liquidators[msg.sender], ErrorsLib.OnlyLiquidator());
_;
}
}
文件 5 的 26：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
文件 6 的 26：EIP712.sol
pragma solidity ^0.8.8;
import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
}
文件 7 的 26：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 8 的 26：ErrorsLib.sol
pragma solidity 0.8.28;
library ErrorsLib {
error ArraysLengthMismatch();
error BelowMinimumDeposit();
error CallerNotEpochUpdater();
error CallerNotLiquidator();
error CallerNotTraderSettler();
error CallerNotWETH9();
error EpochUpdateInCoolDown();
error ExchangeRateIncreaseTooMuch();
error ExternalCallFailed(address target, bytes4 selector);
error FeaturePaused();
error InsufficientFundingFees();
error InsufficientShares();
error InsufficientUnderlying();
error InsufficientWETH9();
error InvalidAmount();
error InvalidFeeBips();
error InvalidLPToken();
error InvalidUnderlying();
error InvalidMarket();
error InvalidPositionUpdateAmount();
error InvalidNativePool();
error InvalidSignature();
error InvalidSigner();
error InvalidWETH9Amount();
error InvalidWidgetFeeRate();
error LiquidatorRecipientConflict();
error NonceUsed();
error NotEnoughAmountOut(uint256 amountOut, uint256 amountOutMinimum);
error NotEnoughTokenReceived();
error NotTraderOrLiquidator();
error NotTrustedOperator();
error NoYieldToDistribute();
error OnlyCreditPool();
error OnlyCreditVault();
error OnlyEpochUpdater();
error OnlyFeeWithdrawer();
error OnlyLiquidator();
error OnlyLpToken();
error OnlyNativeRouter();
error OnlyOwner();
error OnlyTrader();
error OnlyWETH9();
error OrderExpired();
error Overflow();
error Permit2TokenMismatch();
error PoolNotInitialized();
error QuoteExpired();
error RebalanceLimitExceeded();
error RequestExpired();
error TokenAlreadyListed();
error TraderRecipientConflict();
error TransferInCooldown();
error TransferSelf();
error TransferToContract();
error UnexpectedMsgValue();
error ZeroAddress();
error ZeroAmount();
error ZeroInput();
}
文件 9 的 26：ICreditVault.sol
pragma solidity 0.8.28;
interface ICreditVault {
function swapCallback(
address signer,
address sellerToken,
int256 amount0Delta,
address buyerToken,
int256 amount1Delta
) external;
struct RebalanceCap {
uint256 limit;
uint256 used;
uint256 lastDay;
}
struct AccruedFundingFee {
address trader;
FundingFeeAmount[] feeUpdates;
}
struct FundingFeeAmount {
address token;
uint256 fundingFee;
uint256 reserveFee;
}
struct TokenAmountUint {
address token;
uint256 amount;
}
struct TokenAmountInt {
address token;
int256 amount;
}
struct SettlementRequest {
uint256 nonce;
uint256 deadline;
address trader;
TokenAmountInt[] positionUpdates;
}
struct RemoveCollateralRequest {
uint256 nonce;
uint256 deadline;
address trader;
TokenAmountUint[] tokens;
}
struct LiquidationRequest {
uint256 nonce;
uint256 deadline;
address trader;
TokenAmountInt[] positionUpdates;
TokenAmountUint[] claimCollaterals;
}
event MarketListed(address lpToken);
event EpochUpdated(AccruedFundingFee[] accruedFundingFees);
event Repaid(address trader, TokenAmountInt[] repayments);
event Settled(address trader, TokenAmountInt[] positionUpdates);
event CollateralAdded(address trader, TokenAmountUint[] collateralUpdates);
event CollateralRemoved(address trader, TokenAmountUint[] collateralUpdates);
event Liquidated(
address trader, address liquidator, TokenAmountInt[] positionUpdates, TokenAmountUint[] claimCollaterals
);
event CreditPoolUpdated(address indexed pool, bool isActive);
event RebalanceCapUpdated(address indexed operator, address indexed token, uint256 limit);
event TraderSet(address indexed trader, bool isTrader, bool isWhitelistTrader, address settler, address recipient);
event LiquidatorSet(address liquidator, bool status);
event SignerSet(address signer);
event EpochUpdaterSet(address epochUpdater);
event FeeWithdrawerSet(address feeWithdrawer);
event ReserveWithdrawn(address underlying, address recipient, uint256 amount);
}
文件 10 的 26：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 11 的 26：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 12 的 26：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 13 的 26：IERC5267.sol
pragma solidity ^0.8.0;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
文件 14 的 26：LiquidityPairing.sol
pragma solidity 0.8.28;
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ErrorsLib} from "../libraries/ErrorsLib.sol";
import {SafeERC20} from "../libraries/SafeERC20.sol";
import {NativeLPToken} from "../NativeLPToken.sol";
import {ReentrancyGuardTransient} from "../libraries/ReentrancyGuardTransient.sol";
contract LiquidityPairing is Ownable2Step, ReentrancyGuardTransient {
using SafeERC20 for IERC20;
struct UserInfo {
uint256 shares;
uint256 lockedShares;
mapping(address => uint256) rewardDebts;
mapping(address => uint256) unpaidRewards;
}
struct RewardInfo {
uint256 accTokenPerShare;
uint256 rewardPerSecond;
uint256 lastRewardTimestamp;
uint256 startTimestamp;
uint256 claimableTimestamp;
uint256 penaltyEndTimestamp;
uint256 endTimestamp;
uint256 precision;
}
string public name;
bool public emergencyEnabled;
uint256 public constant MAX_REWARD_TOKENS = 5;
uint256 public penaltyFeeBips;
uint256 public totalShares;
uint256 public minRedeemInterval = 8 hours;
NativeLPToken public immutable stakedToken;
address public immutable protocolToken;
IERC20 public immutable underlying;
address public earlyWithdrawFeeReceiver;
address[] public rewardTokens;
mapping(address => RewardInfo) public rewardTokenInfo;
mapping(address => UserInfo) public userInfo;
mapping(address => bool) public trustedOperators;
mapping(address => uint256) public nextFreeRedeemTimestamp;
event LiquidityAdded(address indexed from, address indexed to, uint256 amount, uint256 shares);
event LiquidityRemoved(address indexed from, address indexed to, uint256 shares, uint256 amount);
event TokenRecovery(address indexed token, uint256 amount);
event MinRedeemIntervalUpdated(uint256 newInterval);
event UpdatePool(address indexed token);
event RewardRateUpdated(address indexed token, uint256 newRate);
event RewardTokenAdded(
address indexed token,
uint256 rewardPerSecond,
uint256 startTimestamp,
uint256 claimableTimestamp,
uint256 penaltyEndTimestamp,
uint256 endTimestamp
);
event RewardHarvested(address indexed receiver, address indexed rewardToken, uint256 amount);
event RewardPenaltyCollected(address indexed user, address indexed rewardToken, uint256 penaltyAmount);
event RewardTimestampsUpdated(
address indexed token,
uint256 startTimestamp,
uint256 claimableTimestamp,
uint256 penaltyEndTimestamp,
uint256 endTimestamp
);
event EarlyWithdrawFeeReceiverUpdated(address oldReceiver, address newReceiver);
event EmergencyLiquidityRemoved(address indexed user, uint256 shares, uint256 amount);
event EarlyWithdrawFeeCollected(address indexed user, uint256 amount);
event EmergencyStatusSet(bool enabled);
event TrustedOperatorUpdated(address indexed account, bool status);
event SharesLocked(address indexed user, uint256 shares, address operator);
event SharesUnlocked(address indexed user, uint256 shares, address operator);
event PenaltyFeeBipsUpdated(uint256 oldFeeBips, uint256 newFeeBips);
constructor(string memory _name, NativeLPToken _stakedToken, address _protocolToken) {
name = _name;
stakedToken = _stakedToken;
underlying = _stakedToken.underlying();
protocolToken = _protocolToken;
earlyWithdrawFeeReceiver = msg.sender;
}
function addLiquidity(uint256 _amount) external nonReentrant returns (uint256 shares) {
shares = _addLiquidity(msg.sender, msg.sender, _amount, false);
}
function addLiquidity(uint256 _amount, bool _forceClaim) external nonReentrant returns (uint256 shares) {
shares = _addLiquidity(msg.sender, msg.sender, _amount, _forceClaim);
}
function addLiquidityFor(address _to, uint256 _amount) external nonReentrant returns (uint256 shares) {
require(_to != address(0), ErrorsLib.ZeroAddress());
require(trustedOperators[msg.sender], ErrorsLib.NotTrustedOperator());
shares = _addLiquidity(msg.sender, _to, _amount, true);
}
function removeLiquidity(uint256 _shares) external nonReentrant returns (uint256 amount) {
amount = _removeLiquidity(msg.sender, msg.sender, _shares, false);
}
function removeLiquidity(uint256 _shares, bool _forceClaim) external nonReentrant returns (uint256 amount) {
amount = _removeLiquidity(msg.sender, msg.sender, _shares, _forceClaim);
}
function removeLiquidityTo(
address _from,
address _to,
uint256 _shares
) external nonReentrant returns (uint256 amount) {
require(_from != address(0) && _to != address(0), ErrorsLib.ZeroAddress());
require(trustedOperators[msg.sender], ErrorsLib.NotTrustedOperator());
amount = _removeLiquidity(_from, _to, _shares, true);
}
function emergencyRemoveLiquidity() external nonReentrant returns (uint256 amount) {
require(emergencyEnabled, "Not in emergency mode");
UserInfo storage user = userInfo[msg.sender];
uint256 sharesToRemove = user.shares;
require(sharesToRemove > 0, "No shares to redeem");
user.shares = 0;
user.lockedShares = 0;
totalShares = totalShares - sharesToRemove;
amount = stakedToken.redeem(sharesToRemove);
for (uint256 i = 0; i < rewardTokens.length; i++) {
user.rewardDebts[rewardTokens[i]] = 0;
user.unpaidRewards[rewardTokens[i]] = 0;
}
amount = _transferUnderlyingAndFee(msg.sender, amount);
emit EmergencyLiquidityRemoved(msg.sender, sharesToRemove, amount);
}
function updateRewardPerSecond(address _rewardToken, uint256 _rewardPerSecond) external onlyOwner {
RewardInfo storage reward = rewardTokenInfo[_rewardToken];
require(block.timestamp < reward.startTimestamp, "Pool has started");
uint256 decimalsRewardToken = uint256(IERC20(_rewardToken).decimals());
require(reward.precision * _rewardPerSecond / (10 ** decimalsRewardToken) >= 1e8, "Reward rate too low");
reward.rewardPerSecond = _rewardPerSecond;
emit RewardRateUpdated(_rewardToken, _rewardPerSecond);
}
function updateRewardTimestamps(
address _rewardToken,
uint256 _startTimestamp,
uint256 _claimableTimestamp,
uint256 _penaltyEndTimestamp,
uint256 _endTimestamp
) external onlyOwner {
RewardInfo storage reward = rewardTokenInfo[_rewardToken];
require(reward.startTimestamp != 0, "Reward token not added");
require(block.timestamp < reward.startTimestamp || block.timestamp > reward.endTimestamp, "Reward in progress");
require(_startTimestamp <= _claimableTimestamp, "Claimable time must be after or equal to start time");
require(_claimableTimestamp <= _penaltyEndTimestamp, "Penalty end time must be after claimable time");
require(_penaltyEndTimestamp <= _endTimestamp, "End time must be after penalty end time");
require(_startTimestamp < _endTimestamp, "End time must be after start time");
require(block.timestamp < _startTimestamp, "Start time already passed");
if (block.timestamp > reward.endTimestamp && totalShares > 0) {
require(reward.lastRewardTimestamp == reward.endTimestamp, "Previous round reward accounting not finalized");
}
reward.startTimestamp = _startTimestamp;
reward.claimableTimestamp = _claimableTimestamp;
reward.penaltyEndTimestamp = _penaltyEndTimestamp;
reward.endTimestamp = _endTimestamp;
reward.lastRewardTimestamp = _startTimestamp;
emit RewardTimestampsUpdated(
_rewardToken, _startTimestamp, _claimableTimestamp, _penaltyEndTimestamp, _endTimestamp
);
}
function updatePool(address _rewardToken) external {
_updatePool(_rewardToken);
emit UpdatePool(_rewardToken);
}
function lockShares(address _user, uint256 _shares) external {
require(trustedOperators[msg.sender], "Not trusted operator");
UserInfo storage _userInfo = userInfo[_user];
require(_userInfo.shares - _userInfo.lockedShares >= _shares, "Insufficient unlocked shares");
_userInfo.lockedShares += _shares;
emit SharesLocked(_user, _shares, msg.sender);
}
function unlockShares(address _user, uint256 _shares) external {
require(trustedOperators[msg.sender], "Not trusted operator");
UserInfo storage _userInfo = userInfo[_user];
require(_userInfo.lockedShares >= _shares, "Insufficient locked shares");
_userInfo.lockedShares -= _shares;
emit SharesUnlocked(_user, _shares, msg.sender);
}
function addRewardToken(
address _rewardToken,
uint256 _rewardPerSecond,
uint256 _startTimestamp,
uint256 _claimableTimestamp,
uint256 _penaltyEndTimestamp,
uint256 _endTimestamp
) external onlyOwner {
require(rewardTokens.length < MAX_REWARD_TOKENS, "Max reward tokens reached");
require(_rewardToken != address(0), "Zero reward token address");
require(_rewardToken != address(stakedToken), "Reward token cannot be stake token");
require(_startTimestamp <= _claimableTimestamp, "Claimable time must be after or equal to start time");
require(
_claimableTimestamp <= _penaltyEndTimestamp, "Penalty end time must be after or equal to claimable time"
);
require(_penaltyEndTimestamp <= _endTimestamp, "End time must be after or equal to penalty end time");
require(_startTimestamp < _endTimestamp, "End time must be after start time");
require(block.timestamp < _startTimestamp, "Start time already passed");
require(stakedToken.redeemCooldownExempt(address(this)), "Current contract is not whitelisted");
for (uint256 i = 0; i < rewardTokens.length; i++) {
require(_rewardToken != rewardTokens[i], "Duplicate reward tokens");
}
uint256 decimals = IERC20(_rewardToken).decimals();
require(decimals < 30, "Token decimals exceed maximum precision");
uint256 precision = uint256(10 ** (uint256(30) - decimals));
rewardTokenInfo[_rewardToken] = RewardInfo({
accTokenPerShare: 0,
rewardPerSecond: _rewardPerSecond,
lastRewardTimestamp: _startTimestamp,
startTimestamp: _startTimestamp,
claimableTimestamp: _claimableTimestamp,
penaltyEndTimestamp: _penaltyEndTimestamp,
endTimestamp: _endTimestamp,
precision: precision
});
rewardTokens.push(_rewardToken);
require(precision * _rewardPerSecond / (10 ** decimals) >= 1e8, "Reward rate too low");
emit RewardTokenAdded(
_rewardToken, _rewardPerSecond, _startTimestamp, _claimableTimestamp, _penaltyEndTimestamp, _endTimestamp
);
}
function setMinRedeemInterval(uint256 _interval) external onlyOwner {
minRedeemInterval = _interval;
emit MinRedeemIntervalUpdated(_interval);
}
function setPenaltyFeeBips(uint256 _feeBips) external onlyOwner {
require(_feeBips <= 5000, "Penalty fee cannot exceed 50%");
uint256 oldFeeBips = penaltyFeeBips;
penaltyFeeBips = _feeBips;
emit PenaltyFeeBipsUpdated(oldFeeBips, _feeBips);
}
function setEarlyWithdrawFeeReceiver(address _receiver) external onlyOwner {
require(_receiver != address(0), ErrorsLib.ZeroAddress());
address oldReceiver = earlyWithdrawFeeReceiver;
earlyWithdrawFeeReceiver = _receiver;
emit EarlyWithdrawFeeReceiverUpdated(oldReceiver, _receiver);
}
function setTrustedOperator(address account, bool status) external onlyOwner {
require(account != address(0), ErrorsLib.ZeroAddress());
trustedOperators[account] = status;
emit TrustedOperatorUpdated(account, status);
}
function setEmergencyStatus(bool enabled) external onlyOwner {
emergencyEnabled = enabled;
emit EmergencyStatusSet(enabled);
}
function recoverToken(address _token) external onlyOwner {
require(
_token != address(stakedToken) && _token != address(underlying),
"Staked token and underlying not recoverable"
);
for (uint256 i = 0; i < rewardTokens.length; i++) {
require(_token != rewardTokens[i], "Reward token not recoverable");
}
uint256 balance = IERC20(_token).balanceOf(address(this));
require(balance != 0, "No tokens to recover");
IERC20(_token).safeTransfer(msg.sender, balance);
emit TokenRecovery(_token, balance);
}
function getPendingRewards(address _user)
external
view
returns (address[] memory tokens, uint256[] memory rewards)
{
tokens = rewardTokens;
rewards = new uint256[](tokens.length);
UserInfo storage user = userInfo[_user];
uint256 stakedTokenSupply = stakedToken.balanceOf(address(this));
for (uint256 i = 0; i < tokens.length; i++) {
RewardInfo storage reward = rewardTokenInfo[tokens[i]];
uint256 accTokenPerShare = reward.accTokenPerShare;
if (block.timestamp > reward.lastRewardTimestamp && stakedTokenSupply != 0) {
uint256 multiplier =
_calcRewardInterval(reward.endTimestamp, reward.lastRewardTimestamp, block.timestamp);
uint256 tokenReward = multiplier * reward.rewardPerSecond;
accTokenPerShare += (tokenReward * reward.precision) / stakedTokenSupply;
}
uint256 newlyEarned = (user.shares * accTokenPerShare) / reward.precision - user.rewardDebts[tokens[i]];
rewards[i] = newlyEarned + user.unpaidRewards[tokens[i]];
}
return (tokens, rewards);
}
function getTotalUnderlying() external view returns (uint256) {
return stakedToken.getUnderlyingByShares(totalShares);
}
function claimRewards() external nonReentrant {
UserInfo storage user = userInfo[msg.sender];
for (uint256 i = 0; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
uint256 unpaidAmount = user.unpaidRewards[token];
if (unpaidAmount > 0) {
IERC20(token).safeTransfer(msg.sender, unpaidAmount);
emit RewardHarvested(msg.sender, token, unpaidAmount);
user.unpaidRewards[token] = 0;
}
}
}
function _addLiquidity(
address _from,
address _to,
uint256 _amount,
bool _forceClaim
) internal returns (uint256 shares) {
UserInfo storage toUser = userInfo[_to];
_updatePools();
if (toUser.shares > 0) {
_harvestRewards(_to, _forceClaim);
}
if (_amount > 0) {
uint256 sharesBefore = stakedToken.sharesOf(address(this));
underlying.safeTransferFrom(_from, address(this), _amount);
underlying.safeApprove(address(stakedToken), _amount);
shares = stakedToken.deposit(_amount);
require(stakedToken.sharesOf(address(this)) - sharesBefore == shares, "Shares mismatch");
toUser.shares += shares;
totalShares += shares;
}
for (uint256 i = 0; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
RewardInfo storage reward = rewardTokenInfo[token];
toUser.rewardDebts[token] = (toUser.shares * reward.accTokenPerShare) / reward.precision;
}
if (!trustedOperators[_from]) {
nextFreeRedeemTimestamp[_to] = block.timestamp + minRedeemInterval;
}
emit LiquidityAdded(_from, _to, _amount, shares);
return shares;
}
function _removeLiquidity(
address _from,
address _to,
uint256 _shares,
bool _forceClaim
) internal returns (uint256 amount) {
UserInfo storage fromUser = userInfo[_from];
require(fromUser.shares >= _shares, "Insufficient shares");
require(fromUser.shares - fromUser.lockedShares >= _shares, "Shares locked");
_updatePools();
_harvestRewards(_from, _forceClaim);
if (_shares > 0) {
fromUser.shares -= _shares;
totalShares -= _shares;
amount = stakedToken.redeem(_shares);
amount = _transferUnderlyingAndFee(_to, amount);
}
for (uint256 i = 0; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
RewardInfo storage reward = rewardTokenInfo[token];
fromUser.rewardDebts[token] = (fromUser.shares * reward.accTokenPerShare) / reward.precision;
}
emit LiquidityRemoved(_from, _to, _shares, amount);
return amount;
}
function _updatePools() internal {
for (uint256 i = 0; i < rewardTokens.length; i++) {
_updatePool(rewardTokens[i]);
}
}
function _updatePool(address _rewardToken) internal {
RewardInfo storage reward = rewardTokenInfo[_rewardToken];
if (block.timestamp <= reward.lastRewardTimestamp) {
return;
}
if (totalShares == 0) {
reward.lastRewardTimestamp = block.timestamp;
return;
}
uint256 multiplier = _calcRewardInterval(reward.endTimestamp, reward.lastRewardTimestamp, block.timestamp);
uint256 tokenReward = multiplier * reward.rewardPerSecond;
reward.accTokenPerShare = reward.accTokenPerShare + (tokenReward * reward.precision) / totalShares;
reward.lastRewardTimestamp = block.timestamp > reward.endTimestamp ? reward.endTimestamp : block.timestamp;
}
function _harvestRewards(address _user, bool _forceClaim) internal {
UserInfo storage user = userInfo[_user];
for (uint256 i = 0; i < rewardTokens.length; i++) {
address token = rewardTokens[i];
RewardInfo storage reward = rewardTokenInfo[token];
uint256 newlyEarned = (user.shares * reward.accTokenPerShare) / reward.precision - user.rewardDebts[token];
uint256 totalPending = newlyEarned + user.unpaidRewards[token];
if (newlyEarned > 0) {
user.unpaidRewards[token] += newlyEarned;
}
bool shouldClaim = false;
if (totalPending > 0 && block.timestamp >= reward.claimableTimestamp) {
shouldClaim = _forceClaim;
}
if (shouldClaim) {
uint256 claimableAmount = totalPending;
uint256 penaltyAmount = 0;
if (block.timestamp < reward.penaltyEndTimestamp && penaltyFeeBips > 0) {
penaltyAmount = (totalPending * penaltyFeeBips) / 10_000;
claimableAmount = totalPending - penaltyAmount;
}
if (claimableAmount > 0) {
IERC20(token).safeTransfer(_user, claimableAmount);
emit RewardHarvested(_user, token, claimableAmount);
}
if (penaltyAmount > 0) {
IERC20(token).safeTransfer(earlyWithdrawFeeReceiver, penaltyAmount);
emit RewardPenaltyCollected(_user, token, penaltyAmount);
}
user.unpaidRewards[token] = 0;
}
}
}
function _transferUnderlyingAndFee(address _user, uint256 _amount) private returns (uint256 amount) {
amount = _amount;
uint256 earlyWithdrawFeeBips;
uint256 earlyWithdrawFee;
if (
block.timestamp < nextFreeRedeemTimestamp[_user]
&& (earlyWithdrawFeeBips = stakedToken.earlyWithdrawFeeBips()) > 0
) {
earlyWithdrawFee = (_amount * earlyWithdrawFeeBips) / 10_000;
amount -= earlyWithdrawFee;
}
underlying.safeTransfer(_user, amount);
if (earlyWithdrawFee > 0) {
underlying.safeTransfer(earlyWithdrawFeeReceiver, earlyWithdrawFee);
emit EarlyWithdrawFeeCollected(_user, earlyWithdrawFee);
}
}
function _calcRewardInterval(uint256 _endTimestamp, uint256 _from, uint256 _to) internal pure returns (uint256) {
if (_to <= _endTimestamp) {
return _to - _from;
} else if (_from >= _endTimestamp) {
return 0;
} else {
return _endTimestamp - _from;
}
}
}
文件 15 的 26：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 16 的 26：NativeLPToken.sol
pragma solidity 0.8.28;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20Metadata as IERC20} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./libraries/ConstantsLib.sol";
import {CreditVault} from "./CreditVault.sol";
import {ErrorsLib} from "./libraries/ErrorsLib.sol";
import {ReentrancyGuardTransient} from "./libraries/ReentrancyGuardTransient.sol";
contract NativeLPToken is ERC20, Ownable2Step, ReentrancyGuardTransient {
using SafeERC20 for IERC20;
bool public depositPaused;
bool public redeemPaused;
IERC20 public underlying;
address public creditVault;
uint8 private _decimals;
uint256 public earlyWithdrawFeeBips;
uint256 public totalUnderlying;
uint256 public totalShares;
uint256 public minRedeemInterval = 8 hours;
uint256 public minDeposit;
mapping(address => uint256) public shares;
mapping(address => bool) public trustedOperators;
mapping(address => uint256) public lastDepositTimestamp;
mapping(address => bool) public redeemCooldownExempt;
event DepositPaused();
event DepositUnpaused();
event RedeemPaused();
event RedeemUnpaused();
event YieldDistributed(uint256 yieldAmount);
event MinRedeemIntervalUpdated(uint256 newInterval);
event TransferShares(address indexed from, address indexed to, uint256 shares);
event SharesMinted(address indexed from, address indexed to, uint256 shares, uint256 underlyingAmount);
event SharesBurned(address indexed from, address indexed to, uint256 shares, uint256 underlyingAmount);
event MinDepositUpdated(uint256 oldAmount, uint256 newAmount);
event EarlyWithdrawFeeBipsUpdated(uint256 oldFeeBips, uint256 newFeeBips);
event TrustedOperatorUpdated(address indexed account, bool status);
event RedeemCooldownExemptUpdated(address indexed account, bool status);
constructor(
string memory _name,
string memory _symbol,
address _underlying,
address _creditVault
) ERC20(_name, _symbol) {
underlying = IERC20(_underlying);
creditVault = _creditVault;
_decimals = IERC20(address(underlying)).decimals();
}
function deposit(uint256 amount)
external
nonReentrant
whenNotPaused(depositPaused)
returns (uint256 sharesToMint)
{
sharesToMint = _deposit(msg.sender, msg.sender, amount);
}
function depositFor(
address to,
uint256 amount
) external nonReentrant whenNotPaused(depositPaused) returns (uint256 sharesToMint) {
require(to != address(0), ErrorsLib.ZeroAddress());
require(trustedOperators[msg.sender], ErrorsLib.NotTrustedOperator());
sharesToMint = _deposit(msg.sender, to, amount);
}
function redeem(uint256 sharesToBurn)
external
nonReentrant
whenNotPaused(redeemPaused)
returns (uint256 underlyingAmount)
{
underlyingAmount = _redeem(sharesToBurn, msg.sender);
}
function redeemTo(
uint256 sharesToBurn,
address to
) external nonReentrant whenNotPaused(redeemPaused) returns (uint256 underlyingAmount) {
require(to != address(0), ErrorsLib.ZeroAddress());
require(trustedOperators[msg.sender], ErrorsLib.NotTrustedOperator());
underlyingAmount = _redeem(sharesToBurn, to);
}
function transferShares(address recipient, uint256 sharesAmount) external returns (uint256) {
_transferShares(msg.sender, recipient, sharesAmount);
uint256 tokensAmount = getUnderlyingByShares(sharesAmount);
_emitTransferEvents(msg.sender, recipient, tokensAmount, sharesAmount);
return tokensAmount;
}
function distributeYield(uint256 yieldAmount) external {
require(totalShares > 0, ErrorsLib.PoolNotInitialized());
require(yieldAmount > 0, ErrorsLib.NoYieldToDistribute());
require(msg.sender == creditVault, ErrorsLib.OnlyCreditVault());
totalUnderlying += yieldAmount;
emit YieldDistributed(yieldAmount);
}
function balanceOf(address account) public view override returns (uint256) {
return getUnderlyingByShares(shares[account]);
}
function totalSupply() public view override returns (uint256) {
return totalUnderlying;
}
function sharesOf(address account) public view returns (uint256) {
return shares[account];
}
function getUnderlyingByShares(uint256 sharesAmount) public view returns (uint256) {
if (totalShares == 0) {
return sharesAmount;
}
return (sharesAmount * totalUnderlying) / totalShares;
}
function getSharesByUnderlying(uint256 underlyingAmount) public view returns (uint256) {
if (totalShares == 0) {
return underlyingAmount;
}
return (underlyingAmount * totalShares) / totalUnderlying;
}
function exchangeRate() public view returns (uint256) {
if (totalShares == 0) {
return 1e18;
}
return (totalUnderlying * 1e18) / totalShares;
}
function decimals() public view override returns (uint8) {
return _decimals;
}
function setMinDeposit(uint256 _minDeposit) external onlyOwner {
uint256 oldAmount = minDeposit;
minDeposit = _minDeposit;
emit MinDepositUpdated(oldAmount, _minDeposit);
}
function setMinRedeemInterval(uint256 _interval) external onlyOwner {
minRedeemInterval = _interval;
emit MinRedeemIntervalUpdated(_interval);
}
function setEarlyWithdrawFeeBips(uint256 _earlyWithdrawFeeBips) external onlyOwner {
require(_earlyWithdrawFeeBips <= MAX_EARLY_WITHDRAW_FEE_BIPS, ErrorsLib.InvalidFeeBips());
uint256 oldFeeBips = earlyWithdrawFeeBips;
earlyWithdrawFeeBips = _earlyWithdrawFeeBips;
emit EarlyWithdrawFeeBipsUpdated(oldFeeBips, _earlyWithdrawFeeBips);
}
function setTrustedOperator(address account, bool status) external onlyOwner {
require(account != address(0), ErrorsLib.ZeroAddress());
trustedOperators[account] = status;
emit TrustedOperatorUpdated(account, status);
}
function setRedeemCooldownExempt(address account, bool status) external onlyOwner {
require(account != address(0), ErrorsLib.ZeroAddress());
redeemCooldownExempt[account] = status;
emit RedeemCooldownExemptUpdated(account, status);
}
function pauseDeposit() external onlyOwner {
depositPaused = true;
emit DepositPaused();
}
function unpauseDeposit() external onlyOwner {
depositPaused = false;
emit DepositUnpaused();
}
function pauseRedeem() external onlyOwner {
redeemPaused = true;
emit RedeemPaused();
}
function unpauseRedeem() external onlyOwner {
redeemPaused = false;
emit RedeemUnpaused();
}
modifier whenNotPaused(bool feature) {
if (feature) {
revert ErrorsLib.FeaturePaused();
}
_;
}
function _deposit(address from, address to, uint256 amount) internal returns (uint256 sharesToMint) {
require(amount >= minDeposit && amount > 0, ErrorsLib.BelowMinimumDeposit());
uint256 balanceBefore = underlying.balanceOf(creditVault);
underlying.safeTransferFrom(from, creditVault, amount);
amount = underlying.balanceOf(creditVault) - balanceBefore;
if (totalShares == 0) {
sharesToMint = amount;
} else {
sharesToMint = (amount * totalShares) / totalUnderlying;
}
_mintShares(to, sharesToMint);
totalUnderlying += amount;
lastDepositTimestamp[to] = block.timestamp;
emit SharesMinted(from, to, sharesToMint, amount);
}
function _redeem(uint256 sharesToBurn, address to) internal returns (uint256 underlyingAmount) {
require(sharesToBurn > 0, ErrorsLib.ZeroAmount());
require(shares[msg.sender] >= sharesToBurn, ErrorsLib.InsufficientShares());
underlyingAmount = (sharesToBurn * totalUnderlying) / totalShares;
if (
block.timestamp < lastDepositTimestamp[msg.sender] + minRedeemInterval && earlyWithdrawFeeBips > 0
&& !redeemCooldownExempt[msg.sender]
) {
underlyingAmount -= (underlyingAmount * earlyWithdrawFeeBips) / 10_000;
}
_burnShares(msg.sender, sharesToBurn);
uint256 balanceBefore = underlying.balanceOf(creditVault);
CreditVault(creditVault).pay(to, underlyingAmount);
underlyingAmount = balanceBefore - underlying.balanceOf(creditVault);
totalUnderlying -= underlyingAmount;
emit SharesBurned(msg.sender, to, sharesToBurn, underlyingAmount);
}
function _mintShares(address to, uint256 shareAmount) internal {
require(shareAmount > 0, ErrorsLib.ZeroAmount());
require(to != address(0), ErrorsLib.ZeroAddress());
shares[to] += shareAmount;
totalShares += shareAmount;
}
function _burnShares(address from, uint256 shareAmount) internal {
require(shareAmount > 0, ErrorsLib.ZeroAmount());
require(from != address(0), ErrorsLib.ZeroAddress());
shares[from] -= shareAmount;
totalShares -= shareAmount;
}
function _transfer(address from, address to, uint256 amount) internal override {
uint256 sharesToTransfer = getSharesByUnderlying(amount);
_transferShares(from, to, sharesToTransfer);
_emitTransferEvents(from, to, amount, sharesToTransfer);
}
function _transferShares(address from, address to, uint256 _shares) internal {
require(from != address(0) && to != address(0), ErrorsLib.ZeroAddress());
require(from != to, ErrorsLib.TransferSelf());
require(to != address(this), ErrorsLib.TransferToContract());
_validateTransferCooldown(from);
shares[from] -= _shares;
shares[to] += _shares;
}
function _validateTransferCooldown(address user) internal view {
require(
lastDepositTimestamp[user] + minRedeemInterval <= block.timestamp || redeemCooldownExempt[user],
ErrorsLib.TransferInCooldown()
);
}
function _emitTransferEvents(address from, address to, uint256 tokenAmount, uint256 sharesAmount) internal {
emit Transfer(from, to, tokenAmount);
emit TransferShares(from, to, sharesAmount);
}
}
文件 17 的 26：Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 18 的 26：Ownable2Step.sol
pragma solidity ^0.8.0;
import "./Ownable.sol";
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() public virtual {
address sender = _msgSender();
require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
_transferOwnership(sender);
}
}
文件 19 的 26：ReentrancyGuardTransient.sol
pragma solidity 0.8.28;
import {TStorage} from "./TStorage.sol";
abstract contract ReentrancyGuardTransient {
using TStorage for bytes32;
bytes32 private constant REENTRANCY_GUARD_STORAGE =
0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
error ReentrancyGuardReentrantCall();
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_reentrancyGuardEntered()) {
revert ReentrancyGuardReentrantCall();
}
REENTRANCY_GUARD_STORAGE.tstore(true);
}
function _nonReentrantAfter() private {
REENTRANCY_GUARD_STORAGE.tstore(false);
}
function _reentrancyGuardEntered() internal view returns (bool) {
return REENTRANCY_GUARD_STORAGE.tload();
}
}
文件 20 的 26：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 21 的 26：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 22 的 26：ShortStrings.sol
pragma solidity ^0.8.8;
import "./StorageSlot.sol";
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
文件 23 的 26：SignedMath.sol
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
文件 24 的 26：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
文件 25 的 26：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SignedMath.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
文件 26 的 26：TStorage.sol
pragma solidity 0.8.28;
library TStorage {
function tload(bytes32 slot) internal view returns (bool value) {
assembly {
value := tload(slot)
}
}
function tstore(bytes32 slot, bool value) internal {
assembly {
tstore(slot, value)
}
}
}
{
"compilationTarget": {
"src/periphery/LiquidityPairing.sol": "LiquidityPairing"
},
"evmVersion": "cancun",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 2000000
},
"remappings": [
":@openzeppelin/=lib/openzeppelin-contracts/",
":@permit2/=lib/permit2/src/",
":ds-test/=lib/solmate/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/",
":permit2/=lib/permit2/",
":solmate/=lib/solmate/"
]
}[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"contract NativeLPToken","name":"_stakedToken","type":"address"},{"internalType":"address","name":"_protocolToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"NotTrustedOperator","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EarlyWithdrawFeeCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldReceiver","type":"address"},{"indexed":false,"internalType":"address","name":"newReceiver","type":"address"}],"name":"EarlyWithdrawFeeReceiverUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyLiquidityRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"}],"name":"EmergencyStatusSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"LiquidityAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LiquidityRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newInterval","type":"uint256"}],"name":"MinRedeemIntervalUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldFeeBips","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newFeeBips","type":"uint256"}],"name":"PenaltyFeeBipsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardHarvested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"penaltyAmount","type":"uint256"}],"name":"RewardPenaltyCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"newRate","type":"uint256"}],"name":"RewardRateUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimableTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penaltyEndTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTimestamp","type":"uint256"}],"name":"RewardTimestampsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"rewardPerSecond","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimableTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penaltyEndTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endTimestamp","type":"uint256"}],"name":"RewardTokenAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"SharesLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"address","name":"operator","type":"address"}],"name":"SharesUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"TrustedOperatorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"UpdatePool","type":"event"},{"inputs":[],"name":"MAX_REWARD_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"addLiquidity","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bool","name":"_forceClaim","type":"bool"}],"name":"addLiquidity","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"addLiquidityFor","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardPerSecond","type":"uint256"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_claimableTimestamp","type":"uint256"},{"internalType":"uint256","name":"_penaltyEndTimestamp","type":"uint256"},{"internalType":"uint256","name":"_endTimestamp","type":"uint256"}],"name":"addRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"earlyWithdrawFeeReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyRemoveLiquidity","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"getPendingRewards","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"rewards","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"lockShares","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minRedeemInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nextFreeRedeemTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"penaltyFeeBips","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"recoverToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"},{"internalType":"bool","name":"_forceClaim","type":"bool"}],"name":"removeLiquidity","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"removeLiquidity","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"removeLiquidityTo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardTokenInfo","outputs":[{"internalType":"uint256","name":"accTokenPerShare","type":"uint256"},{"internalType":"uint256","name":"rewardPerSecond","type":"uint256"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"startTimestamp","type":"uint256"},{"internalType":"uint256","name":"claimableTimestamp","type":"uint256"},{"internalType":"uint256","name":"penaltyEndTimestamp","type":"uint256"},{"internalType":"uint256","name":"endTimestamp","type":"uint256"},{"internalType":"uint256","name":"precision","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"}],"name":"setEarlyWithdrawFeeReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setEmergencyStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_interval","type":"uint256"}],"name":"setMinRedeemInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_feeBips","type":"uint256"}],"name":"setPenaltyFeeBips","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setTrustedOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakedToken","outputs":[{"internalType":"contract NativeLPToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"trustedOperators","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"unlockShares","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_rewardPerSecond","type":"uint256"}],"name":"updateRewardPerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"},{"internalType":"uint256","name":"_claimableTimestamp","type":"uint256"},{"internalType":"uint256","name":"_penaltyEndTimestamp","type":"uint256"},{"internalType":"uint256","name":"_endTimestamp","type":"uint256"}],"name":"updateRewardTimestamps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"lockedShares","type":"uint256"}],"stateMutability":"view","type":"function"}]
